1. Copy the contents of source/ into your project, e.g. src/arktype/.

2. Ensure tsconfig.json has strict mode and path aliases if you renamed the directory:

{
  "compilerOptions": {
    "strict": true,
    "moduleResolution": "bundler",
    "module": "ESNext",
    "target": "ESNext",
    "paths": {
      "arktype": ["./src/arktype/index.ts"]
    }
  }
}

3. If you are importing directly from source rather than via npm, replace bare specifier imports (arktype) with relative paths or your configured alias throughout your codebase.

4. No environment variables are required. No native build steps, no pod install, no prebuild.

5. For Node.js 18+, ESM is recommended. Add "type": "module" to your package.json or use .mts extensions.

Public API

type

import { type } from "arktype"

const MySchema = type({ name: "string", age: "number > 0" })
type MyType = typeof MySchema.infer
// => { name: string; age: number }

The primary entry point. Accepts string literals, object literals, and tuple expressions matching TypeScript syntax. Use it to define runtime validators that also carry full TypeScript inference.

scope

import { scope } from "arktype"

const myScope = scope({
  User: { name: "string", role: "Role" },
  Role: "'admin' | 'viewer'"
})
const types = myScope.export()

Creates an isolated registry for mutually recursive or co-dependent type definitions. Use scope when types reference each other by name, or when you want a bounded namespace separate from the global ark registry.

Type

import { Type } from "arktype"

declare const MyType: Type<{ id: string }>
const result = MyType({ id: "abc" }) // ArkErrors | { id: string }

The class returned by type(...). Instances are callable validators. Call them directly to validate data; the return is either the parsed/transformed value or an ArkErrors collection. Useful when you need to pass a validator as a value or extend it.

match

import { match } from "arktype"

const classify = match
  .in("string | number")
  .when("string", s => `str:${s}`)
  .when("number", n => n * 2)
  .finalize()

Builds exhaustive discriminated-union handlers. .in() constrains the input type; .when() adds cases; .finalize() produces a callable. Use when replacing large if/switch chains that need type-safe narrowing.

distill

import type { distill, Out } from "arktype"

type Parsed = distill<string | Out<number>, "out">
// => number

A type-level utility that extracts the "in" or "out" face of a morphed type. Use in generic helpers when you need to reason about pre- or post-transformation shapes without instantiating a Type.

Working examples

Scenario - Basic object validation

Parse and validate a plain object with nested constraints expressed in ArkType's string syntax. The validator infers the TypeScript type automatically.

import { type, ArkErrors } from "arktype"

const User = type({
  id: "string.uuid",
  email: "string.email",
  age: "integer >= 18"
})

const result = User({ id: "not-a-uuid", email: "user@example.com", age: 25 })

if (result instanceof ArkErrors) {
  for (const err of result) {
    console.error(err.message)
  }
} else {
  console.log(result.id) // typed as string
}

Scenario - Scoped recursive types

Define mutually recursive types inside a scope so each alias can reference the others by name before they are fully defined.

import { scope, ArkErrors } from "arktype"

const types = scope({
  Category: {
    name: "string",
    "subcategories?": "Category[]"
  }
}).export()

const result = types.Category({
  name: "Root",
  subcategories: [{ name: "Child" }]
})

if (result instanceof ArkErrors) {
  console.error(result.summary)
} else {
  console.log(result.name) // "Root"
}

Scenario - Morphing / transformation pipeline

Use the pipe operator to validate input and transform it in one schema definition. The output type reflects the transformed shape.

import { type } from "arktype"

const ParsedDate = type("string").pipe(s => new Date(s), type("instanceof(Date)"))

const result = ParsedDate("2024-01-15")
if (result instanceof Date) {
  console.log(result.getFullYear()) // 2024
}

Scenario - Pattern matching with match

Replace a switch/if chain with a type-safe exhaustive matcher that handles a union of inputs.

import { match } from "arktype"

const describe = match
  .when("string", s => `String of length ${s.length}`)
  .when("number", n => `Number: ${n}`)
  .when("boolean", b => `Boolean: ${b}`)
  .finalize()

console.log(describe("hello"))   // "String of length 5"
console.log(describe(42))        // "Number: 42"
console.log(describe(true))      // "Boolean: true"

File walkthrough

• index.ts — Barrel re-exporting every public symbol; your import target.
• attributes.ts — Pure type-level helpers (distill, Out, Comparator, RegexLiteral) used throughout the inference layer.
• config.ts — Exports configuration types and helpers for customizing ArkType's global behavior.
• declare.ts — Exposes DeclarationParser for forward-referencing types in recursive schemas.
• fn.ts — FnParser wraps function schemas so argument/return types are validated at runtime.
• generic.ts — Generic and GenericParser enable parameterized, reusable type constructors.
• match.ts — MatchParser and CaseMatchParser implement the chainable pattern-matching DSL.
• module.ts — Module / BoundModule / Submodule organize exported scope aliases into typed namespaces.
• nary.ts — Type-level N-ary union/intersection/pipe helpers used internally by type.
• scope.ts — scope() factory and Scope class; the isolated registry for multi-type definitions.
• type.ts — Type class definition: the callable validator object with .pipe, .narrow, .assert, etc.
• keywords/ — Built-in primitive and prototype keywords (string.email, number.integer, Array, etc.).
• parser/ — Internal string parser, AST reduction, and tuple expression handling; not imported directly.
• variants/ — Internal per-type-flavor implementations (array, date, number, object, string); not imported directly.

Common pitfalls and fixes

• moduleResolution must be "bundler" or "node16" — ArkType source uses .ts extensions in imports; older "node" resolution will fail to resolve them. Set "moduleResolution": "bundler" in tsconfig.json.
• @ark/schema and @ark/util must be the exact same version as the vendored source — Version mismatches cause silent type errors or runtime crashes. Pin all three to matching releases.
• Calling type(...) outside a scope uses the global ark registry — If you define aliases with declare and forget to call .export() on a scope, resolution fails at runtime with a missing alias error. Always call scope({...}).export().
• ArkErrors is iterable, not a plain Error — Checking result instanceof Error will miss validation failures. Always check result instanceof ArkErrors before accessing .summary or iterating.
• String syntax is parsed at call time, not compile time — Typos in string literals like "stirng" produce runtime ParseError throws, not TypeScript errors unless you use the typed overloads. Prefer object-literal syntax for IDE autocomplete.
• ESM/CJS interop — If your project uses CommonJS, import via require("arktype") only works when the installed npm package provides a CJS build. Vendoring the raw source requires an ESM-capable bundler or ts-node --esm.

Vibe-coding prompt template

I have vendored the ArkType TypeScript validation library into my project under `src/arktype/`.
The integration guide is in `USAGE.md` next to this message.
The upstream package is `arktype` (npm).

Please help me integrate ArkType into my existing project step by step:

1. Read `USAGE.md` and `source/index.ts` to understand all available exports.
2. Identify where I currently do manual runtime validation or use zod/yup/joi.
3. Replace those validators with equivalent `type(...)` or `scope(...)` definitions
   using real ArkType syntax from the docs.
4. Add `ArkErrors` handling where validators are called, replacing any try/catch
   or manual error objects.
5. If I have mutually recursive types, wrap them in `scope({}).export()`.
6. Update my `tsconfig.json` `paths` so `arktype` resolves to `src/arktype/index.ts`.
7. Show the final diff for each changed file and confirm TypeScript compiles cleanly.

My project is: [DESCRIBE YOUR PROJECT HERE]
Files that need validation: [LIST FILES OR PASTE CODE]

License and credit

ArkType is released under the MIT License. See source/LICENSE if present, or refer to the arktype npm package and the official repository for the authoritative license text and changelog.

This product’s unique contribution is clean room implementation of valuable code block into AVCP compatible standard.

完整安装指南与集成提示词将在购买后解锁。