@orkestrel/contract 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Orkestrel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,46 @@
+# @orkestrel/contract
+
+The zero-dependency contract toolkit — runtime type guards, guard combinators, coerce-and-extract
+parsers, and a shape DSL that compiles once into a guard, parser, JSON Schema, and generator that
+can never drift. The foundation package of the `@orkestrel` line.
+
+## Install
+
+```sh
+npm install @orkestrel/contract
+```
+
+## Requirements
+
+- Node.js >= 24
+- TypeScript-first (ships its own `.d.ts` types)
+
+## Usage
+
+```ts
+import { createContract, integerShape, objectShape, stringShape } from '@orkestrel/contract'
+
+const user = createContract(
+	objectShape({
+		name: stringShape({ min: 1 }),
+		age: integerShape({ min: 0, max: 120 }),
+	}),
+)
+
+user.is({ name: 'Ada', age: 36 }) // true
+user.parse({ name: 'Ada', age: '36' }) // { name: 'Ada', age: 36 } — coerces, or undefined
+user.schema // the compiled JSON Schema
+```
+
+## Guide
+
+For the full surface — guards, combinators, parsers, the JSON boundary, and the shape DSL — see
+[`guides/src/contract.md`](guides/src/contract.md).
+
+## Package
+
+Published as a single typed entry point per the `exports` field in `package.json`.
+
+## License
+
+MIT © [Orkestrel](https://github.com/orkestrel) — see [LICENSE](./LICENSE).

package/dist/src/core/combinators.d.ts

@@ -0,0 +1,384 @@
+import type { AnyConstructor, FromGuards, Guard, GuardsShape, GuardType, IntersectionFromGuards, OptionalFromGuards, TupleFromGuards } from './types.js';
+/**
+ * Build a guard that accepts arrays whose every element satisfies `elementGuard`.
+ *
+ * @example
+ * ```ts
+ * const isStringArray = arrayOf(isString)
+ * isStringArray(['a', 'b']) // true
+ * isStringArray(['a', 1])   // false
+ * ```
+ */
+export declare function arrayOf<T>(elementGuard: Guard<T>): Guard<readonly T[]>;
+export declare function arrayOf(elementGuard: (value: unknown) => boolean): Guard<readonly unknown[]>;
+/**
+ * Build a guard that accepts fixed-arity tuples, testing each index with the
+ * corresponding guard.
+ *
+ * @example
+ * ```ts
+ * const isPair = tupleOf(isString, isNumber)
+ * isPair(['hello', 42]) // true
+ * isPair(['hello'])     // false — wrong arity
+ * ```
+ */
+export declare function tupleOf<const Gs extends ReadonlyArray<Guard<unknown>>>(...guards: Gs): Guard<TupleFromGuards<Gs>>;
+export declare function tupleOf(...predicates: ReadonlyArray<(value: unknown) => boolean>): Guard<readonly unknown[]>;
+/**
+ * Build a guard that accepts values identical (via `Object.is`) to one of the
+ * provided literal primitives.
+ *
+ * @example
+ * ```ts
+ * const isRole = literalOf('admin', 'member', 'guest')
+ * isRole('admin') // true
+ * isRole('owner') // false
+ * ```
+ */
+export declare function literalOf<const Literals extends ReadonlyArray<string | number | boolean>>(...literals: Literals): Guard<Literals[number]>;
+/**
+ * Build a guard that accepts instances of the provided constructor.
+ *
+ * @remarks
+ * Verifies that `ctor` is a real constructor (via {@link isConstructor}) first,
+ * so passing an arrow function does not silently produce a broken guard.
+ *
+ * @example
+ * ```ts
+ * const isDateValue = instanceOf(Date)
+ * isDateValue(new Date()) // true
+ * isDateValue({})         // false
+ * ```
+ */
+export declare function instanceOf<C>(ctor: C): Guard<InstanceType<C & AnyConstructor<object>>>;
+/**
+ * Build a guard from a native `enum` or any object whose values are strings or
+ * numbers.
+ *
+ * @example
+ * ```ts
+ * enum Direction { Up = 'up', Down = 'down' }
+ * const isDirection = enumOf(Direction)
+ * isDirection('up')   // true
+ * isDirection('left') // false
+ * ```
+ */
+export declare function enumOf<E extends Record<string, string | number>>(enumeration: E): Guard<E[keyof E]>;
+/**
+ * Build a guard that accepts `Set` instances whose every element satisfies
+ * `elementGuard`.
+ *
+ * @example
+ * ```ts
+ * const isStringSet = setOf(isString)
+ * isStringSet(new Set(['a', 'b'])) // true
+ * isStringSet(new Set(['a', 1]))   // false
+ * ```
+ */
+export declare function setOf<T>(elementGuard: Guard<T>): Guard<ReadonlySet<T>>;
+export declare function setOf(elementGuard: (value: unknown) => boolean): Guard<ReadonlySet<unknown>>;
+/**
+ * Build a guard that accepts `Map` instances where every key satisfies
+ * `keyGuard` and every value satisfies `valueGuard`.
+ *
+ * @example
+ * ```ts
+ * const isStringNumberMap = mapOf(isString, isNumber)
+ * isStringNumberMap(new Map([['a', 1]])) // true
+ * isStringNumberMap(new Map([[1, 'a']])) // false
+ * ```
+ */
+export declare function mapOf<K, V>(keyGuard: Guard<K>, valueGuard: Guard<V>): Guard<ReadonlyMap<K, V>>;
+export declare function mapOf(keyPredicate: (value: unknown) => boolean, valuePredicate: (value: unknown) => boolean): Guard<ReadonlyMap<unknown, unknown>>;
+export declare function recordOf<S extends GuardsShape>(shape: S): Guard<FromGuards<S>>;
+export declare function recordOf<S extends GuardsShape, K extends ReadonlyArray<keyof S & string>>(shape: S, optional: K): Guard<OptionalFromGuards<S, K>>;
+export declare function recordOf<S extends GuardsShape>(shape: S, optional: true): Guard<Readonly<{
+    [P in keyof S]: FromGuards<S>[P] | undefined;
+}>>;
+/**
+ * Build a guard that accepts any iterable whose every element satisfies
+ * `elementGuard`.
+ *
+ * @example
+ * ```ts
+ * const isNumberIterable = iterableOf(isNumber)
+ * isNumberIterable([1, 2, 3])       // true
+ * isNumberIterable(new Set([1, 2])) // true
+ * isNumberIterable([1, 'two'])      // false
+ * ```
+ */
+export declare function iterableOf<T>(elementGuard: Guard<T>): Guard<Iterable<T>>;
+export declare function iterableOf(elementGuard: (value: unknown) => boolean): Guard<Iterable<unknown>>;
+/**
+ * Build a guard that accepts values that are own keys of the provided object.
+ *
+ * @remarks
+ * Membership is tested with `Object.hasOwn`, so inherited prototype-chain keys
+ * (`toString`, `constructor`, …) are rejected. An own property that shadows a
+ * prototype name is accepted.
+ *
+ * @example
+ * ```ts
+ * const COLORS = { red: '#f00', green: '#0f0', blue: '#00f' } as const
+ * const isColorKey = keyOf(COLORS)
+ * isColorKey('red')      // true
+ * isColorKey('purple')   // false
+ * isColorKey('toString') // false — inherited, not an own key
+ * ```
+ */
+export declare function keyOf<const O extends Readonly<Record<PropertyKey, unknown>>>(value: O): Guard<keyof O>;
+/**
+ * Build a new guard shape by keeping only the listed keys — the structural
+ * equivalent of `Pick<T, K>`. Produces a shape for {@link recordOf}, not a guard.
+ *
+ * @example
+ * ```ts
+ * const full = { name: isString, age: isNumber, role: isString }
+ * const isName = recordOf(pickOf(full, ['name']))
+ * isName({ name: 'Ada' }) // true
+ * ```
+ */
+export declare function pickOf<S extends GuardsShape, K extends ReadonlyArray<keyof S & string>>(shape: S, keys: K): Pick<S, K[number]>;
+/**
+ * Build a new guard shape by removing the listed keys — the structural
+ * equivalent of `Omit<T, K>`. Produces a shape for {@link recordOf}, not a guard.
+ *
+ * @example
+ * ```ts
+ * const full = { name: isString, age: isNumber, role: isString }
+ * const isPublic = recordOf(omitOf(full, ['role']))
+ * isPublic({ name: 'Ada', age: 36 }) // true
+ * ```
+ */
+export declare function omitOf<S extends GuardsShape, K extends ReadonlyArray<keyof S & string>>(shape: S, keys: K): Omit<S, K[number]>;
+/**
+ * Combine two guards with logical AND — passes only when both pass.
+ *
+ * @remarks
+ * Use {@link whereOf} when the right side refines an already-narrowed type; use
+ * `andOf` to combine two independent guards.
+ *
+ * @example
+ * ```ts
+ * const isShortString = andOf(isString, isNonEmptyString)
+ * ```
+ */
+export declare function andOf<A, B>(left: Guard<A>, right: Guard<B>): Guard<A & B>;
+export declare function andOf<T, U extends T>(left: Guard<T>, right: (value: T) => value is U): Guard<U>;
+export declare function andOf<T>(left: Guard<T>, right: (value: T) => boolean): Guard<T>;
+export declare function andOf(left: (value: unknown) => boolean, right: (value: unknown) => boolean): Guard<unknown>;
+/**
+ * Combine two guards with logical OR — passes when at least one passes. For more
+ * than two variants prefer {@link unionOf}.
+ *
+ * @example
+ * ```ts
+ * const isStringOrNumber = orOf(isString, isNumber)
+ * ```
+ */
+export declare function orOf<A, B>(left: Guard<A>, right: Guard<B>): Guard<A | B>;
+export declare function orOf(left: (value: unknown) => boolean, right: (value: unknown) => boolean): Guard<unknown>;
+/**
+ * Negate a guard or predicate — passes when `guard` returns `false`.
+ *
+ * @remarks
+ * Typed as `Guard<unknown>` because `Exclude<unknown, T>` is not useful; use
+ * {@link complementOf} when you need the narrowed `Exclude<TBase, TExcluded>`.
+ *
+ * @example
+ * ```ts
+ * const isNotNull = notOf(isNull)
+ * ```
+ */
+export declare function notOf(guard: (value: unknown) => boolean): Guard<unknown>;
+/**
+ * Build a guard for `Exclude<TBase, TExcluded>` — accepts values that pass
+ * `base` but not `excluded`.
+ *
+ * @example
+ * ```ts
+ * const isNonEmpty = complementOf(isString, isEmptyString)
+ * isNonEmpty('hi') // true
+ * isNonEmpty('')   // false
+ * ```
+ */
+export declare function complementOf<TBase, TExcluded extends TBase>(base: Guard<TBase>, excluded: Guard<TExcluded> | ((value: TBase) => value is TExcluded)): Guard<Exclude<TBase, TExcluded>>;
+/**
+ * Build a guard that accepts values matching at least one of the provided
+ * guards — the variadic form of {@link orOf}.
+ *
+ * @example
+ * ```ts
+ * const isStringOrBoolean = unionOf(isString, isBoolean)
+ * ```
+ */
+export declare function unionOf<const Gs extends ReadonlyArray<Guard<unknown>>>(...guards: Gs): Guard<GuardType<Gs[number]>>;
+export declare function unionOf(...predicates: ReadonlyArray<(value: unknown) => boolean>): Guard<unknown>;
+/**
+ * Build a guard that accepts values matching ALL of the provided guards — the
+ * variadic form of {@link andOf}.
+ *
+ * @example
+ * ```ts
+ * const isNonEmpty = intersectionOf(isString, isNonEmptyString)
+ * ```
+ */
+export declare function intersectionOf<const Gs extends ReadonlyArray<Guard<unknown>>>(...guards: Gs): Guard<IntersectionFromGuards<Gs>>;
+export declare function intersectionOf(...predicates: ReadonlyArray<(value: unknown) => boolean>): Guard<unknown>;
+/**
+ * Refine a base guard with an additional predicate that runs only when the base
+ * passes.
+ *
+ * @remarks
+ * The predicate receives a value already narrowed to `T`. When the predicate is
+ * itself a type guard (`value is U`), the result narrows to `Guard<U>` — it
+ * passes only when the value is genuinely a `U`, so the narrowing is sound. Per
+ * §14 the returned guard never throws: if `predicate` throws, the throw is
+ * contained and the guard reports a non-match.
+ *
+ * @example
+ * ```ts
+ * const isPositive = whereOf(isNumber, (n) => n > 0)
+ * isPositive(5)  // true
+ * isPositive(-1) // false
+ *
+ * // A narrowing predicate refines the result type to Guard<5>
+ * const isFive = whereOf(isNumber, (n): n is 5 => n === 5)
+ * ```
+ */
+export declare function whereOf<T, U extends T>(base: Guard<T>, predicate: (value: T) => value is U): Guard<U>;
+export declare function whereOf<T>(base: Guard<T>, predicate: (value: T) => boolean): Guard<T>;
+/**
+ * Defer guard creation until first use by calling `thunk()` on every
+ * invocation.
+ *
+ * @remarks
+ * `thunk` is called on every guard call, not cached — this lets it close over a
+ * binding assigned *after* `lazyOf` is called, the primary use case for
+ * self-referential recursive guards. Per §14 a throw from `thunk` (or the guard
+ * it resolves to) is contained and reported as a non-match.
+ *
+ * A recursive guard built this way has no cycle/depth detection: a cyclic or
+ * pathologically deep input is stack-bounded — the overflow is contained and the
+ * guard returns `false` rather than throwing, but it is not validated correctly
+ * past that bound.
+ *
+ * @example
+ * ```ts
+ * type Tree = { value: number; children: Tree[] }
+ * let isTree: Guard<Tree>
+ * isTree = recordOf({ value: isNumber, children: arrayOf(lazyOf(() => isTree)) })
+ * ```
+ */
+export declare function lazyOf<T>(thunk: () => Guard<T>): Guard<T>;
+/**
+ * Build a guard that passes when the base passes AND the projection of the value
+ * satisfies the target guard. Still narrows to `T` (the base type) — the target
+ * check is a validity constraint on a derived view, not a type transformation.
+ *
+ * @remarks
+ * `project` is a plain `(value: T) => U`. Per §14 the returned guard never
+ * throws: a throw from `project` is contained and reported as a non-match.
+ * `target` is itself a Guard (already §14-bound), so it stays outside the
+ * contained region. (Unlike the reference implementation, there is no
+ * "curried projector" branch — a projection that legitimately returns a function
+ * would be double-invoked under that scheme. Compose explicitly if you need it.)
+ *
+ * @example
+ * ```ts
+ * const isBounded = transformOf(
+ *   isString,
+ *   (s) => s.trim().length,
+ *   whereOf(isNumber, (n) => n >= 1 && n <= 50),
+ * )
+ * isBounded('hello') // true
+ * isBounded('')      // false
+ * ```
+ */
+export declare function transformOf<T, U>(base: Guard<T>, project: (value: T) => U, target: Guard<U>): Guard<T>;
+export declare function transformOf<T>(base: Guard<T>, project: (value: T) => unknown, target: (value: unknown) => boolean): Guard<T>;
+/**
+ * Build a guard that accepts finite numbers within an inclusive `[min, max]`
+ * range.
+ *
+ * @remarks
+ * Refines {@link isFiniteNumber} with the bound comparison, so `NaN` /
+ * `±Infinity` are rejected before any comparison runs. An absent bound never
+ * constrains that side. Reused for a number's own value AND, applied to a
+ * `.length`, for string and array length refinements — the single source of the
+ * bound logic shared by the compiled guard and parser (compilers.ts).
+ *
+ * @example
+ * ```ts
+ * const inRange = boundsOf(1, 5)
+ * inRange(3)  // true
+ * inRange(0)  // false — below min
+ * inRange(6)  // false — above max
+ *
+ * const atLeastTwo = boundsOf(2)
+ * atLeastTwo(2) // true — unbounded above
+ * ```
+ */
+export declare function boundsOf(min?: number, max?: number): Guard<number>;
+/**
+ * Build a guard that accepts strings matching a regular expression.
+ *
+ * @example
+ * ```ts
+ * const isHex = matchOf(/^[0-9a-f]+$/)
+ * isHex('1a2f') // true
+ * isHex('xyz')  // false
+ * ```
+ */
+export declare function matchOf(pattern: RegExp): Guard<string>;
+/**
+ * Build a guard that accepts strings satisfying optional length and pattern
+ * refinements — `min` / `max` length and a `pattern`.
+ *
+ * @remarks
+ * Composes {@link isString} with {@link boundsOf} on the string's `.length` and
+ * an inline `pattern.test` (the same refinement {@link matchOf} performs). When all three options are absent it returns
+ * the bare {@link isString} guard (the unconstrained fast path), so an
+ * unrefined string leaf pays no wrapping cost. The single source of the string
+ * refinement shared by the compiled guard and parser (compilers.ts).
+ *
+ * @example
+ * ```ts
+ * const isSlug = stringOf({ min: 1, max: 32, pattern: /^[a-z-]+$/ })
+ * isSlug('hello-world') // true
+ * isSlug('')            // false — below min
+ * isSlug('Hello')       // false — pattern miss
+ *
+ * stringOf() // identical to isString
+ * ```
+ */
+export declare function stringOf(options?: {
+    min?: number;
+    max?: number;
+    pattern?: RegExp;
+}): Guard<string>;
+/**
+ * Extend a guard to also allow `null`.
+ *
+ * @example
+ * ```ts
+ * const isNullableString = nullableOf(isString)
+ * isNullableString('hi') // true
+ * isNullableString(null) // true
+ * isNullableString(42)   // false
+ * ```
+ */
+export declare function nullableOf<T>(guard: Guard<T>): Guard<T | null>;
+/**
+ * Extend a guard to also allow `undefined` — the optional counterpart of
+ * {@link nullableOf}.
+ *
+ * @example
+ * ```ts
+ * const isOptionalString = optionalOf(isString)
+ * isOptionalString('hi')        // true
+ * isOptionalString(undefined)   // true
+ * isOptionalString(null)        // false
+ * ```
+ */
+export declare function optionalOf<T>(guard: Guard<T>): Guard<T | undefined>;

package/dist/src/core/compilers.d.ts

@@ -0,0 +1,119 @@
+import type { ContractInterface, ContractShape, Guard, Infer, JSONSchema, Parser, RandomFunction } from './types.js';
+/**
+ * Validate that a {@link ContractShape} tree is well-formed — a pure recursive
+ * prepass run before compilation.
+ *
+ * @remarks
+ * Fail-fast, per AGENTS §12: a malformed shape is a programmer error, so this
+ * throws a plain `Error` immediately rather than surfacing as a silently-wrong
+ * guard, parser, schema, or generator later. Checks, recursively:
+ *
+ * - An {@link OptionalShape} is only legal as a direct object-property value —
+ *   `optionalShape` wrapping an array item, a union variant, another
+ *   optional/nullable's inner shape, `additionalProperties`, or the top-level
+ *   shape all throw. An object property IS the one legal placement: its value
+ *   is unwrapped to `.inner` before recursing, so `.inner` itself is validated
+ *   as a normal (non-optional-wrapping) shape.
+ * - A {@link UnionShape} needs at least one variant; a {@link LiteralShape}
+ *   needs at least one value and rejects non-finite (`NaN` / `Infinity` /
+ *   `-Infinity`) number values.
+ * - A bounded {@link StringShape} / {@link NumberShape} / {@link ArrayShape}
+ *   needs `min <= max` when both are set.
+ * - An integer {@link NumberShape} (`integer: true`) needs a non-empty integer
+ *   range: `Math.ceil(min ?? -Infinity) <= Math.floor(max ?? Infinity)`.
+ * - `null` / `json` / `raw` / `boolean` are always-valid leaves. Recursion
+ *   continues into array items, object properties (and `additionalProperties`
+ *   when it is a shape), union variants, and optional/nullable inner shapes.
+ *
+ * @param shape - The shape to validate
+ * @throws {Error} When the shape is malformed
+ */
+export declare function validateShape(shape: ContractShape): void;
+/**
+ * Compile a {@link ContractShape} into a JSON Schema document.
+ *
+ * @remarks
+ * Object shapes emit `additionalProperties: false` (unless opened) and list only
+ * required keys in `required`; nullable shapes emit an `anyOf` with `{ type:
+ * 'null' }`. Emission only — it never inspects a runtime value.
+ *
+ * @param shape - The shape to compile
+ * @returns The emitted JSON Schema
+ */
+export declare function compileSchema(shape: ContractShape): JSONSchema;
+/**
+ * Compile a {@link ContractShape} into a runtime type guard.
+ *
+ * @remarks
+ * Reuses the combinators: `literalOf` for literals, `arrayOf` for arrays,
+ * `recordOf` for closed objects, `unionOf` for unions, `nullableOf` for nullable,
+ * and `whereOf` for constraint refinement. Like every guard it is total — it
+ * never throws (AGENTS §14).
+ *
+ * @param shape - The shape to compile
+ * @returns A guard narrowing to the shape's inferred type
+ */
+export declare function compileGuard(shape: ContractShape): Guard<unknown>;
+/**
+ * Compile a {@link ContractShape} into an input parser.
+ *
+ * @remarks
+ * Reuses the leaf parsers (`parseString` / `parseInteger` / `parseNumber` /
+ * `parseBoolean` / `parseRecord`) and coerces structurally. An object fails as a
+ * whole on any required-field failure; a union returns a guard-valid value
+ * unchanged, otherwise the first variant that both parses and guards wins.
+ *
+ * After coercing a leaf, it re-applies that leaf's REFINEMENTS through the same
+ * combinators `compileGuard` uses — `stringOf` for a string's length/pattern and
+ * `boundsOf` for a number's value and an array's length — so a value that coerces
+ * but violates a bound parses to `undefined`. The result is full parse↔guard
+ * soundness (AGENTS §14): a non-`undefined` parse always satisfies the contract's
+ * `is`, refinements included.
+ *
+ * @param shape - The shape to compile
+ * @returns A parser yielding the shape's inferred type or `undefined`
+ */
+export declare function compileParser(shape: ContractShape): Parser<unknown>;
+/**
+ * Compile a {@link ContractShape} into a deterministic seed value.
+ *
+ * @remarks
+ * The same shape and the same `random` source always produce the same value, so
+ * seed data is reproducible. Defaults to a {@link seededRandom} source seeded
+ * from the wall clock when none is supplied. Throws on a degenerate empty
+ * `literalShape` / `unionShape`, on a pattern-constrained `stringShape` whose
+ * generated sample cannot satisfy the pattern, or on a `rawShape` (its embedded
+ * schema is arbitrary and cannot be auto-generated) — a programmer error that
+ * cannot generate a value (AGENTS §12). `createContract` runs
+ * {@link validateShape} first, so a degenerate `literalShape` / `unionShape` /
+ * bounded shape is normally caught there; these throws remain here as defense
+ * for standalone `compileGenerator` use.
+ *
+ * @param shape - The shape to generate from
+ * @param random - A seeded random source (defaults to `seededRandom(Date.now())`)
+ * @returns A value matching the shape
+ */
+export declare function compileGenerator(shape: ContractShape, random?: RandomFunction): unknown;
+/**
+ * Compile a {@link ContractShape} into a {@link ContractInterface} — the four
+ * lockstep outputs from one declaration.
+ *
+ * @remarks
+ * Runs {@link validateShape} first — a malformed shape throws immediately
+ * rather than compiling into a silently-wrong contract (AGENTS §12). Then
+ * precompiles the schema, guard, and parser once; `generate` walks the shape
+ * per call with the supplied random source.
+ *
+ * @param shape - The shape to compile
+ * @returns A contract bundling `schema` / `is` / `parse` / `generate`
+ *
+ * @example
+ * ```ts
+ * const user = createContract(objectShape({ name: stringShape(), age: integerShape() }))
+ * user.is({ name: 'Ada', age: 36 })        // true
+ * user.parse({ name: 'Ada', age: '36' })   // { name: 'Ada', age: 36 }
+ * user.schema                              // { type: 'object', properties: { … }, … }
+ * ```
+ */
+export declare function createContract<S extends ContractShape>(shape: S): ContractInterface<Infer<S>>;
+export declare function createContract(shape: ContractShape): ContractInterface<unknown>;

package/dist/src/core/constants.d.ts

@@ -0,0 +1,20 @@
+import type { JSONSchemaType } from './types.js';
+/**
+ * The seven standard JSON Schema `type` names, frozen.
+ *
+ * @remarks
+ * The runtime source of truth for the {@link JSONSchemaType} vocabulary. Compose
+ * it with the shipped primitives instead of reaching for a bespoke guard:
+ * `literalOf(...JSON_SCHEMA_TYPES)` is the guard, and
+ * `parseEnum(value, JSON_SCHEMA_TYPES)` / `parseEnumField(record, path, JSON_SCHEMA_TYPES)`
+ * is the parser.
+ *
+ * @example
+ * ```ts
+ * import { JSON_SCHEMA_TYPES, literalOf, parseEnumField } from '@src/core'
+ *
+ * const isSchemaType = literalOf(...JSON_SCHEMA_TYPES) // Guard<JSONSchemaType>
+ * parseEnumField(schema, 'type', JSON_SCHEMA_TYPES)    // JSONSchemaType | undefined
+ * ```
+ */
+export declare const JSON_SCHEMA_TYPES: readonly JSONSchemaType[];