@fougere/schema 0.1.0-alpha.0

package/dist/field/field.d.ts

@@ -0,0 +1,64 @@
+import type { Shape } from './shape.js';
+import type { Role } from './role.js';
+import type { Lifecycle } from './lifecycle.js';
+import type { BoundaryRef } from './boundary.js';
+import type { Meta } from './meta.js';
+/**
+ * A field — the single source of truth, decomposed on four orthogonal axes
+ * plus one documentary compartment:
+ * `shape` (is the value valid? — nullability included, as the `[T,'null']` union),
+ * `role` (place in the entity graph), `lifecycle` (who writes the value, at which
+ * moment), `boundary` (how a value crosses wire↔domain), `meta` (human-facing,
+ * never decides). Adapters read the axes they care about; nothing reads all of
+ * them at once. `boundary` is usually absent — its default is derived from
+ * `shape` and the slot only overrides it.
+ *
+ * @typeParam T - the data type this field carries (phantom, TS inference only)
+ * @typeParam A - "auto-supplied at creation" (primary/auto/default/optional) →
+ *   the field is optional in `new X(input)`. Phantom, type-level only.
+ */
+export interface Field<T = unknown, A extends boolean = false> {
+    readonly __brand: 'fougere_field';
+    readonly shape?: Shape;
+    readonly role?: Role;
+    readonly lifecycle?: Lifecycle;
+    readonly boundary?: BoundaryRef;
+    readonly meta?: Meta;
+    /** Phantom — data type, never read at runtime. */
+    readonly _type?: T;
+    /** Phantom — auto-at-creation flag, never read at runtime. */
+    readonly _auto?: A;
+}
+/** Any field, regardless of its T/A parameters — the correct generic bound. */
+export type AnyField = Field<any, boolean>;
+/** A record of fields — the input to `entity()` and every derivation. */
+export type Fields = Record<string, AnyField>;
+export interface FieldInit {
+    shape?: Shape;
+    role?: Role;
+    lifecycle?: Lifecycle;
+    boundary?: BoundaryRef;
+    meta?: Meta;
+}
+export declare function createField<T, A extends boolean = false>(init?: FieldInit): Field<T, A>;
+/**
+ * Copy a field, overriding only the named axes — every OTHER axis is preserved.
+ * This is the invariant every field transform must hold: change what you mean,
+ * keep the rest. Enumerating axes by hand (the old `optional`/`primary`) silently
+ * drops whatever axis was added last — `codec` did exactly that. Spread + override,
+ * so a future 6th slot travels for free. (Spread props skip excess-property checks,
+ * so the field's `__brand`/phantoms ride along harmlessly and `createField` resets them.)
+ */
+export declare function cloneField(field: AnyField, overrides?: FieldInit): AnyField;
+/** Duck type for anything with fields — Entity, SchemaConstructor. */
+export interface SchemaLike {
+    getFields(): Fields;
+    /** The view's validation mode (patch…) — carried by SchemaConstructor, optional on bare wrappers. */
+    getOpts?(): {
+        patch?: boolean;
+    };
+    /** Field groups unique together — carried by SchemaConstructor, absent on bare wrappers. */
+    getUnique?(): ReadonlyArray<ReadonlyArray<string>> | undefined;
+}
+export declare function isField(value: unknown): value is AnyField;
+//# sourceMappingURL=field.d.ts.map

package/dist/field/field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field.d.ts","sourceRoot":"","sources":["../../src/field/field.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEtC;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,SAAS,OAAO,GAAG,KAAK;IAC3D,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC;IACrB,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC;IAC/B,QAAQ,CAAC,QAAQ,CAAC,EAAE,WAAW,CAAC;IAChC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC;IACrB,kDAAkD;IAClD,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IACnB,8DAA8D;IAC9D,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;CACpB;AAED,+EAA+E;AAC/E,MAAM,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;AAE3C,yEAAyE;AACzE,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;AAE9C,MAAM,WAAW,SAAS;IACxB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,IAAI,CAAC,EAAE,IAAI,CAAC;CACb;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,SAAS,OAAO,GAAG,KAAK,EAAE,IAAI,GAAE,SAAc,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAS3F;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,QAAQ,EAAE,SAAS,GAAE,SAAc,GAAG,QAAQ,CAE/E;AAED,sEAAsE;AACtE,MAAM,WAAW,UAAU;IACzB,SAAS,IAAI,MAAM,CAAC;IACpB,qGAAqG;IACrG,OAAO,CAAC,IAAI;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAChC,4FAA4F;IAC5F,SAAS,CAAC,IAAI,aAAa,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC;CAChE;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAOzD"}

package/dist/field/field.js

@@ -0,0 +1,28 @@
+export function createField(init = {}) {
+    return {
+        __brand: 'fougere_field',
+        shape: init.shape,
+        role: init.role,
+        lifecycle: init.lifecycle,
+        boundary: init.boundary,
+        meta: init.meta,
+    };
+}
+/**
+ * Copy a field, overriding only the named axes — every OTHER axis is preserved.
+ * This is the invariant every field transform must hold: change what you mean,
+ * keep the rest. Enumerating axes by hand (the old `optional`/`primary`) silently
+ * drops whatever axis was added last — `codec` did exactly that. Spread + override,
+ * so a future 6th slot travels for free. (Spread props skip excess-property checks,
+ * so the field's `__brand`/phantoms ride along harmlessly and `createField` resets them.)
+ */
+export function cloneField(field, overrides = {}) {
+    return createField({ ...field, ...overrides });
+}
+export function isField(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        '__brand' in value &&
+        value.__brand === 'fougere_field');
+}
+//# sourceMappingURL=field.js.map

package/dist/field/field.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"field.js","sourceRoot":"","sources":["../../src/field/field.ts"],"names":[],"mappings":"AA+CA,MAAM,UAAU,WAAW,CAA+B,IAAI,GAAc,EAAE;IAC5E,OAAO;QACL,OAAO,EAAE,eAAe;QACxB,KAAK,EAAE,IAAI,CAAC,KAAK;QACjB,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,QAAQ,EAAE,IAAI,CAAC,QAAQ;QACvB,IAAI,EAAE,IAAI,CAAC,IAAI;KAChB,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,UAAU,CAAC,KAAe,EAAE,SAAS,GAAc,EAAE;IACnE,OAAO,WAAW,CAAC,EAAE,GAAG,KAAK,EAAE,GAAG,SAAS,EAAE,CAAC,CAAC;AACjD,CAAC;AAWD,MAAM,UAAU,OAAO,CAAC,KAAc;IACpC,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,SAAS,IAAI,KAAK;QACjB,KAAa,CAAC,OAAO,KAAK,eAAe,CAC3C,CAAC;AACJ,CAAC"}

package/dist/field/index.d.ts

@@ -0,0 +1,7 @@
+export { type Shape, type ShapeType, type BaseShape, type ShapeAnatomy, type StringFormat, nullableShape, anatomy, isNullable, } from './shape.js';
+export { type Role, type Relation, type EntityConstructor, toTargetThunk, uniqueMembers } from './role.js';
+export { type Lifecycle, type GeneratorRef, registerGenerator, resolveCustomGenerator, } from './lifecycle.js';
+export { type Boundary, type BoundaryRef, type Decoder, type Encoder, resolveBoundary, declaredBoundary, boundaryOf, registerDecoder, registerEncoder, registerBoundaryAlias, } from './boundary.js';
+export { type Meta } from './meta.js';
+export { type Field, type AnyField, type Fields, type FieldInit, type SchemaLike, createField, cloneField, isField, } from './field.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/field/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/field/index.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,KAAK,EACV,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,aAAa,EACb,OAAO,EACP,UAAU,GACX,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAE,KAAK,iBAAiB,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC3G,OAAO,EACL,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,iBAAiB,EACjB,sBAAsB,GACvB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,KAAK,OAAO,EACZ,KAAK,OAAO,EACZ,eAAe,EACf,gBAAgB,EAChB,UAAU,EACV,eAAe,EACf,eAAe,EACf,qBAAqB,GACtB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EACL,KAAK,KAAK,EACV,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,KAAK,SAAS,EACd,KAAK,UAAU,EACf,WAAW,EACX,UAAU,EACV,OAAO,GACR,MAAM,YAAY,CAAC"}

package/dist/field/index.js

@@ -0,0 +1,9 @@
+// The primitive — a Field decomposed on four orthogonal axes plus the meta
+// compartment. Each axis lives in its own file; this barrel is the
+// package-internal (and index-level) view.
+export { nullableShape, anatomy, isNullable, } from './shape.js';
+export { toTargetThunk, uniqueMembers } from './role.js';
+export { registerGenerator, resolveCustomGenerator, } from './lifecycle.js';
+export { resolveBoundary, declaredBoundary, boundaryOf, registerDecoder, registerEncoder, registerBoundaryAlias, } from './boundary.js';
+export { createField, cloneField, isField, } from './field.js';
+//# sourceMappingURL=index.js.map

package/dist/field/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/field/index.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,mEAAmE;AACnE,2CAA2C;AAC3C,OAAO,EAML,aAAa,EACb,OAAO,EACP,UAAU,GACX,MAAM,YAAY,CAAC;AACpB,OAAO,EAAoD,aAAa,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC3G,OAAO,EAGL,iBAAiB,EACjB,sBAAsB,GACvB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAKL,eAAe,EACf,gBAAgB,EAChB,UAAU,EACV,eAAe,EACf,eAAe,EACf,qBAAqB,GACtB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAML,WAAW,EACX,UAAU,EACV,OAAO,GACR,MAAM,YAAY,CAAC"}

package/dist/field/lifecycle.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Generator TOKEN — a built-in preset or a name registered via
+ * {@link registerGenerator}. Never a closure: a function would silently vanish
+ * through describe/reconstruct (JSON.stringify drops it without an error) and
+ * the remote frond would pay. With a name, the failure is loud and local
+ * ("unknown generator") instead of silent and at the neighbour's.
+ */
+export type GeneratorRef = 'cuid2' | 'uuid' | 'nanoid' | (string & {});
+export interface Lifecycle {
+    /**
+     * The CREATE rule — what happens when the input omits the value:
+     * - key absent      → required, the caller must supply it
+     * - `{ value }`     → filled with this literal (a `default`)
+     * - `'now'`         → stamped `new Date()` (a managed creation timestamp)
+     * - `{ generate }`  → the storage adapter stamps a fresh id at insert
+     * - `'optional'`    → absence permitted, nothing produced
+     * A supplied value is always accepted (create); restricting WHAT a surface
+     * accepts is a derivation (`pick`), never a rule here.
+     */
+    create?: {
+        value: unknown;
+    } | 'now' | {
+        generate: GeneratorRef;
+    } | 'optional';
+    /**
+     * The UPDATE rule — what happens on a patch:
+     * - key absent     → the field is only written if the client supplies it
+     * - `'now'`        → stamped `new Date()` at every update even when absent
+     *                    (the canonical `updatedAt`); a supplied value is accepted
+     * - `'forbidden'`  → immutable: supplying the field in a patch is a
+     *                    validation error; absent, nothing happens
+     * The validation only JUDGES these rules; realising `'now'` (stamping) is the
+     * storage adapter's role at the point of persistence — same split as create.
+     */
+    update?: 'now' | 'forbidden';
+}
+export declare function registerGenerator(name: string, fn: () => string): void;
+/** A registered custom generator, or undefined (built-in presets live storage-side). */
+export declare function resolveCustomGenerator(ref: GeneratorRef): (() => string) | undefined;
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/field/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../src/field/lifecycle.ts"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AAEvE,MAAM,WAAW,SAAS;IACxB;;;;;;;;;OASG;IACH,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,GAAG,KAAK,GAAG;QAAE,QAAQ,EAAE,YAAY,CAAA;KAAE,GAAG,UAAU,CAAC;IAC9E;;;;;;;;;OASG;IACH,MAAM,CAAC,EAAE,KAAK,GAAG,WAAW,CAAC;CAC9B;AAgBD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,MAAM,GAAG,IAAI,CAEtE;AAED,wFAAwF;AACxF,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,YAAY,GAAG,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAEpF"}

package/dist/field/lifecycle.js

@@ -0,0 +1,27 @@
+// ─── Axis 3 · lifecycle — WHO WRITES THE VALUE, AT WHICH MOMENT ────
+// The normal form is indexed by the situation (the write moment); reading is a
+// key access plus a switch on a named token — never an interpreter function.
+// The interpretation happened ONCE, at declaration (the vocabulary translates
+// its sugar into this form). Declarative, named only — never an opaque closure
+// (a value mutation invisible to adapters is forbidden).
+// (Coercion — converting a supplied value — is NOT here; that is the `boundary` axis.)
+// ─── Generator registry (open, same spirit as the boundary registries) ──
+// CUSTOM generators, declared once per module:
+//   registerGenerator('monId', () => …)  →  primary({ generate: 'monId' })
+//
+// The BUILT-IN presets (cuid2/uuid/nanoid) used to be resolved by each storage adapter,
+// on the grounds that this package took no dependency. It took one already
+// (`@cfworker/json-schema`, for the other projection), and the arrangement put the
+// inversion in plain sight: a generator YOU invented reached every adapter, and the
+// three the framework ships did not — so a second adapter honoured `cuid2` differently
+// or not at all. They live with the realization now (`projections/lifecycle.ts`), which
+// consults this registry first.
+const generators = new Map();
+export function registerGenerator(name, fn) {
+    generators.set(name, fn);
+}
+/** A registered custom generator, or undefined (built-in presets live storage-side). */
+export function resolveCustomGenerator(ref) {
+    return generators.get(ref);
+}
+//# sourceMappingURL=lifecycle.js.map

package/dist/field/lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.js","sourceRoot":"","sources":["../../src/field/lifecycle.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,+EAA+E;AAC/E,6EAA6E;AAC7E,8EAA8E;AAC9E,+EAA+E;AAC/E,yDAAyD;AACzD,uFAAuF;AAoCvF,2EAA2E;AAC3E,+CAA+C;AAC/C,2EAA2E;AAC3E,EAAE;AACF,wFAAwF;AACxF,2EAA2E;AAC3E,mFAAmF;AACnF,oFAAoF;AACpF,uFAAuF;AACvF,wFAAwF;AACxF,gCAAgC;AAEhC,MAAM,UAAU,GAAG,IAAI,GAAG,EAAwB,CAAC;AAEnD,MAAM,UAAU,iBAAiB,CAAC,IAAY,EAAE,EAAgB;IAC9D,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;AAC3B,CAAC;AAED,wFAAwF;AACxF,MAAM,UAAU,sBAAsB,CAAC,GAAiB;IACtD,OAAO,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC7B,CAAC"}

package/dist/field/meta.d.ts

@@ -0,0 +1,9 @@
+export interface Meta {
+    /**
+     * Human-readable annotation. Read by CLI help (`cli/bridge.ts`) and carried by the
+     * portable card — that is the whole current reach. No OpenAPI generation exists in
+     * this repo, and `schema-graphql` never reads meta.
+     */
+    description?: string;
+}
+//# sourceMappingURL=meta.d.ts.map

package/dist/field/meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta.d.ts","sourceRoot":"","sources":["../../src/field/meta.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,IAAI;IACnB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB"}

package/dist/field/meta.js

@@ -0,0 +1,7 @@
+// ─── meta — the documentary compartment (NOT an axis) ────────────
+// Universal, human-facing information. The contract is strict and holds: NO consumer
+// ever DECIDES by reading meta — the axes govern behaviour, meta informs humans.
+// Per-consumer specifics belong to `hints`, not here. Future candidates of the same
+// nature: title, example, deprecated.
+export {};
+//# sourceMappingURL=meta.js.map

package/dist/field/meta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta.js","sourceRoot":"","sources":["../../src/field/meta.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE,qFAAqF;AACrF,iFAAiF;AACjF,oFAAoF;AACpF,sCAAsC"}

package/dist/field/role.d.ts

@@ -0,0 +1,54 @@
+export type EntityConstructor = abstract new (...args: any[]) => any;
+/**
+ * Normalize a relation target to a lazy thunk. A target may be given as the entity
+ * class directly (`ref(Author)`) or as a thunk (`ref(() => Author)`) — the thunk
+ * form is needed for circular/forward references, where the class isn't defined yet
+ * when `entity({...})` is evaluated. An entity class is recognized by its static
+ * `getFields`; anything else is treated as the thunk itself.
+ */
+export declare function toTargetThunk<E extends EntityConstructor>(target: E | (() => E)): () => E;
+export interface Relation {
+    to: () => EntityConstructor;
+    kind: 'one' | 'many';
+    onDelete?: 'cascade' | 'restrict' | 'set null';
+}
+export interface Role {
+    primary?: boolean;
+    /**
+     * The unique constraints this field is a member of — one member list per constraint.
+     *
+     * A constraint is a NAMED SET of fields, and a lone `unique(slug)` is the degenerate
+     * case: a set of one. So there is one shape, not two — `boolean` could say "unique on
+     * its own" and nothing else, neither "unique together with docId" nor "in two
+     * constraints at once".
+     *
+     * **An empty member list denotes the field carrying it.** `unique(text())` applies to a
+     * field that does not yet know its own key — `slug` exists only once `entity({...})`
+     * assembles the object — so the self-reference is written as `[]` and stays that way:
+     * nothing to resolve, nothing to remap when a view renames the key, and a reader that
+     * never went through `entity()` still reads something true. A group with named members
+     * comes from the entity's own declaration (`entity(fields, { unique: [[...]] })`), which
+     * is where a fact about a pair belongs — no field holds it alone.
+     *
+     * So NEVER read a group directly — {@link uniqueMembers} is the accessor.
+     */
+    unique?: ReadonlyArray<ReadonlyArray<string>>;
+    index?: boolean;
+    relation?: Relation;
+}
+/**
+ * The constraint a member list denotes, resolved against the field carrying it — the
+ * accessor every reader of `role.unique` goes through.
+ *
+ * ```ts
+ * uniqueMembers([], 'slug')                 // ['slug']            — the self-reference
+ * uniqueMembers(['listId', 'docId'], 'docId')  // ['listId','docId'] — already named
+ * ```
+ *
+ * `ownKey` is the half the field is missing, and only its holder can supply it: iterate
+ * `Object.entries(getFields())`, never the field alone. Two spellings for one constraint
+ * is the price of a self-reference that survives `rename()` untouched; this function is
+ * what makes them one, and it is why the two forms never need to be compared as data.
+ */
+export declare function uniqueMembers(group: ReadonlyArray<string>, ownKey: string): string[];
+//# sourceMappingURL=role.d.ts.map

package/dist/field/role.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"role.d.ts","sourceRoot":"","sources":["../../src/field/role.ts"],"names":[],"mappings":"AA4BA,MAAM,MAAM,iBAAiB,GAAG,QAAQ,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;AAErE;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,iBAAiB,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,CAEzF;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,iBAAiB,CAAC;IAC5B,IAAI,EAAE,KAAK,GAAG,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,SAAS,GAAG,UAAU,GAAG,UAAU,CAAC;CAChD;AAED,MAAM,WAAW,IAAI;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,EAAE,aAAa,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC;IAC9C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAEpF"}

package/dist/field/role.js

@@ -0,0 +1,55 @@
+// ─── Axis 2 · role — place in the entity graph ────────────
+// What no value validator expresses: identity and relations. Read by the storage and
+// transport adapters, and ALSO by validation — `relation.kind === 'many'` decides that
+// an absent collection defaults to `[]` and that a supplied one must be an array
+// (`projections/validation.ts`). The earlier claim "never by validation" was false.
+//
+// `unique` and `index` are STORAGE facts, and the only axis member realized outside the
+// framework: `unique(...)`/`indexed(...)` set them, the DDL emits the constraint and the
+// index, and the database enforces uniqueness on every write — including ones Fougere
+// never saw. A collision therefore surfaces as the driver's error, never as a
+// `validate()` failure: judging one value can never see the other rows.
+//
+// ⚠️ READING `unique` — the one member of this axis that is not self-contained. A member
+// list may be EMPTY, denoting the field that carries it, so a reader that walks the array
+// literally sees a group of no fields. Every reader goes through `uniqueMembers(group,
+// key)`, which needs the field's key — the half a field does not have (`slug` is named by
+// the object literal `entity({...})` receives, one call up).
+//
+//   for (const [key, field] of Object.entries(schema.getFields()))
+//     for (const group of field.role?.unique ?? [])
+//       uniqueMembers(group, key)     // ← always. `[]` at key `slug` means `['slug']`.
+//
+// The in-repo readers do this (`schema-sql/src/table.ts`, `projections/describe.ts`). A
+// consumer reading a CARD never meets the empty form: `describe` resolves it on the way
+// out, so the wire always names its members — which is the point of resolving it there
+// and not in `entity()`. Keeping it unresolved in memory is what makes `rename()` free:
+// a self-reference names no key, so there is nothing to remap when the key moves.
+/**
+ * Normalize a relation target to a lazy thunk. A target may be given as the entity
+ * class directly (`ref(Author)`) or as a thunk (`ref(() => Author)`) — the thunk
+ * form is needed for circular/forward references, where the class isn't defined yet
+ * when `entity({...})` is evaluated. An entity class is recognized by its static
+ * `getFields`; anything else is treated as the thunk itself.
+ */
+export function toTargetThunk(target) {
+    return 'getFields' in target ? () => target : target;
+}
+/**
+ * The constraint a member list denotes, resolved against the field carrying it — the
+ * accessor every reader of `role.unique` goes through.
+ *
+ * ```ts
+ * uniqueMembers([], 'slug')                 // ['slug']            — the self-reference
+ * uniqueMembers(['listId', 'docId'], 'docId')  // ['listId','docId'] — already named
+ * ```
+ *
+ * `ownKey` is the half the field is missing, and only its holder can supply it: iterate
+ * `Object.entries(getFields())`, never the field alone. Two spellings for one constraint
+ * is the price of a self-reference that survives `rename()` untouched; this function is
+ * what makes them one, and it is why the two forms never need to be compared as data.
+ */
+export function uniqueMembers(group, ownKey) {
+    return group.length === 0 ? [ownKey] : [...group];
+}
+//# sourceMappingURL=role.js.map

package/dist/field/role.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"role.js","sourceRoot":"","sources":["../../src/field/role.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,qFAAqF;AACrF,uFAAuF;AACvF,iFAAiF;AACjF,oFAAoF;AACpF,EAAE;AACF,wFAAwF;AACxF,yFAAyF;AACzF,sFAAsF;AACtF,8EAA8E;AAC9E,wEAAwE;AACxE,EAAE;AACF,yFAAyF;AACzF,0FAA0F;AAC1F,uFAAuF;AACvF,0FAA0F;AAC1F,6DAA6D;AAC7D,EAAE;AACF,mEAAmE;AACnE,oDAAoD;AACpD,wFAAwF;AACxF,EAAE;AACF,wFAAwF;AACxF,wFAAwF;AACxF,uFAAuF;AACvF,wFAAwF;AACxF,kFAAkF;AAIlF;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAA8B,MAAqB;IAC9E,OAAO,WAAW,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,MAAW,CAAC,CAAC,CAAE,MAAkB,CAAC;AACzE,CAAC;AAiCD;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,aAAa,CAAC,KAA4B,EAAE,MAAc;IACxE,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC;AACpD,CAAC"}

package/dist/field/shape.d.ts

@@ -0,0 +1,77 @@
+export type StringFormat = 'date-time' | 'date' | 'time' | 'email' | 'uuid' | 'uri';
+/** A base type name, alone or in the nullable union form. */
+type Nullably<T extends string> = T | readonly [T, 'null'];
+interface StringConstraints {
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    enum?: readonly (string | null)[];
+    format?: StringFormat;
+}
+interface NumericConstraints {
+    minimum?: number;
+    maximum?: number;
+}
+interface ArrayConstraints {
+    items: Shape;
+    minItems?: number;
+    maxItems?: number;
+}
+interface ObjectConstraints {
+    properties?: Record<string, unknown>;
+    required?: readonly string[];
+}
+export type Shape = ({
+    type: Nullably<'string'>;
+} & StringConstraints) | ({
+    type: Nullably<'number'> | Nullably<'integer'>;
+} & NumericConstraints) | {
+    type: Nullably<'boolean'>;
+} | ({
+    type: Nullably<'array'>;
+} & ArrayConstraints) | ({
+    type: Nullably<'object'>;
+} & ObjectConstraints);
+/** The BASE type names — what `anatomy(shape).base?.type` narrows to for a dispatch. */
+export type ShapeType = 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object';
+/**
+ * `Shape` with `type` guaranteed scalar — what `anatomy` returns as `base`, the
+ * ONLY form consumers dispatch on. A scalar literal is a real discriminant, so
+ * `switch (base?.type)` narrows; the raw `Shape` union can't (the `[T,'null']`
+ * tuple is not a unit type).
+ */
+export type BaseShape = ({
+    type: 'string';
+} & StringConstraints) | ({
+    type: 'number' | 'integer';
+} & NumericConstraints) | {
+    type: 'boolean';
+} | ({
+    type: 'array';
+} & ArrayConstraints) | ({
+    type: 'object';
+} & ObjectConstraints);
+/**
+ * Write side: make a shape's grammar accept `null` — the type becomes the union
+ * `[T, 'null']`, and `null` joins `enum` when present (an enum is a closed value
+ * set; null must be IN it to be legal). Idempotent.
+ */
+export declare function nullableShape(shape: Shape): Shape;
+/** A shape split back into its base grammar and its nullability. */
+export interface ShapeAnatomy {
+    /** The shape stripped of `null` (scalar `type`, `enum` without null) — dispatch on THIS. */
+    base?: BaseShape;
+    nullable: boolean;
+}
+/**
+ * Read side — the single customs post at the standard's border. Every consumer
+ * that dispatches on a shape's type MUST come through here: `shape.type` may be
+ * the union `[T, 'null']`, and a direct `shape.type === 'string'` comparison
+ * fails silently on it. Cached per shape reference (shapes are stable — the
+ * derivations copy field refs, they never rebuild shapes).
+ */
+export declare function anatomy(shape?: Shape): ShapeAnatomy;
+/** Sugar for the most common read: does this shape's grammar accept `null`? */
+export declare function isNullable(shape?: Shape): boolean;
+export {};
+//# sourceMappingURL=shape.d.ts.map

package/dist/field/shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape.d.ts","sourceRoot":"","sources":["../../src/field/shape.ts"],"names":[],"mappings":"AAuBA,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC;AAEpF,6DAA6D;AAC7D,KAAK,QAAQ,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AAI3D,UAAU,iBAAiB;IAAG,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,SAAS,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,CAAA;CAAE;AAClJ,UAAU,kBAAkB;IAAG,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE;AAGnE,UAAU,gBAAgB;IAAG,KAAK,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE;AAIjF,UAAU,iBAAiB;IAAG,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE;AAElG,MAAM,MAAM,KAAK,GACb,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAA;CAAE,GAAG,iBAAiB,CAAC,GAClD,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAA;CAAE,GAAG,kBAAkB,CAAC,GACzE;IAAE,IAAI,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAA;CAAE,GAC7B,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAA;CAAE,GAAG,gBAAgB,CAAC,GAChD,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAA;CAAE,GAAG,iBAAiB,CAAC,CAAC;AAEvD,wFAAwF;AACxF,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEzF;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GACjB,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,iBAAiB,CAAC,GACxC,CAAC;IAAE,IAAI,EAAE,QAAQ,GAAG,SAAS,CAAA;CAAE,GAAG,kBAAkB,CAAC,GACrD;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,GACnB,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG,gBAAgB,CAAC,GACtC,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,iBAAiB,CAAC,CAAC;AAI7C;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAOjD;AAED,oEAAoE;AACpE,MAAM,WAAW,YAAY;IAC3B,4FAA4F;IAC5F,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAKD;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,KAAK,CAAC,EAAE,KAAK,GAAG,YAAY,CAiBnD;AAED,+EAA+E;AAC/E,wBAAgB,UAAU,CAAC,KAAK,CAAC,EAAE,KAAK,GAAG,OAAO,CAEjD"}

package/dist/field/shape.js

@@ -0,0 +1,49 @@
+// ─── nullableShape / anatomy — the two gates of the union ──────────
+/**
+ * Write side: make a shape's grammar accept `null` — the type becomes the union
+ * `[T, 'null']`, and `null` joins `enum` when present (an enum is a closed value
+ * set; null must be IN it to be legal). Idempotent.
+ */
+export function nullableShape(shape) {
+    if (Array.isArray(shape.type))
+        return shape;
+    const out = { ...shape, type: [shape.type, 'null'] };
+    if ('enum' in out && out.enum && !out.enum.includes(null)) {
+        out.enum = [...out.enum, null];
+    }
+    return out;
+}
+const anatomies = new WeakMap();
+const NO_SHAPE = { base: undefined, nullable: false };
+/**
+ * Read side — the single customs post at the standard's border. Every consumer
+ * that dispatches on a shape's type MUST come through here: `shape.type` may be
+ * the union `[T, 'null']`, and a direct `shape.type === 'string'` comparison
+ * fails silently on it. Cached per shape reference (shapes are stable — the
+ * derivations copy field refs, they never rebuild shapes).
+ */
+export function anatomy(shape) {
+    if (!shape)
+        return NO_SHAPE;
+    let a = anatomies.get(shape);
+    if (!a) {
+        if (Array.isArray(shape.type)) {
+            const baseType = shape.type.find((t) => t !== 'null');
+            const base = { ...shape, type: baseType };
+            if ('enum' in base && base.enum) {
+                base.enum = base.enum.filter((v) => v !== null);
+            }
+            a = { base, nullable: true };
+        }
+        else {
+            a = { base: shape, nullable: false };
+        }
+        anatomies.set(shape, a);
+    }
+    return a;
+}
+/** Sugar for the most common read: does this shape's grammar accept `null`? */
+export function isNullable(shape) {
+    return anatomy(shape).nullable;
+}
+//# sourceMappingURL=shape.js.map

package/dist/field/shape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape.js","sourceRoot":"","sources":["../../src/field/shape.ts"],"names":[],"mappings":"AA+DA,sEAAsE;AAEtE;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAAC,KAAY;IACxC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC;QAAE,OAAO,KAAK,CAAC;IAC5C,MAAM,GAAG,GAAG,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,EAAsB,CAAC;IACzE,IAAI,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACzD,GAA4C,CAAC,IAAI,GAAG,CAAC,GAAG,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAC3E,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AASD,MAAM,SAAS,GAAG,IAAI,OAAO,EAAwB,CAAC;AACtD,MAAM,QAAQ,GAAiB,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;AAEpE;;;;;;GAMG;AACH,MAAM,UAAU,OAAO,CAAC,KAAa;IACnC,IAAI,CAAC,KAAK;QAAE,OAAO,QAAQ,CAAC;IAC5B,IAAI,CAAC,GAAG,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAC7B,IAAI,CAAC,CAAC,EAAE,CAAC;QACP,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YAC9B,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC;YACtD,MAAM,IAAI,GAAG,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAe,CAAC;YACvD,IAAI,MAAM,IAAI,IAAI,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;gBAC/B,IAA6C,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC;YAC5F,CAAC;YACD,CAAC,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;QAC/B,CAAC;aAAM,CAAC;YACN,CAAC,GAAG,EAAE,IAAI,EAAE,KAAkB,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;QACpD,CAAC;QACD,SAAS,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAC1B,CAAC;IACD,OAAO,CAAC,CAAC;AACX,CAAC;AAED,+EAA+E;AAC/E,MAAM,UAAU,UAAU,CAAC,KAAa;IACtC,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC;AACjC,CAAC"}

package/dist/hints.d.ts

@@ -0,0 +1,33 @@
+import type { Fields } from "./field/index.js";
+/**
+ * Open registry of per-consumer hints — the escape hatch for the irreducible
+ * bits a single neutral field can't carry (e.g. "store `body` as a `tsvector`
+ * with a GIN index", which validation and the API must ignore).
+ *
+ * EMPTY here on purpose: `@fougere/schema` names no adapter and depends on none.
+ * Each adapter augments this from its OWN package via declaration merging —
+ *
+ * ```ts
+ * declare module '@fougere/schema' {
+ *   interface FougereHints<K extends string> {
+ *     sql?: Partial<Record<K, { columnType?: string; index?: string }>>;
+ *   }
+ * }
+ * ```
+ *
+ * `K` is the entity's field-key union, so a hint's inner keys are constrained to
+ * real fields. Until an adapter augments it the registry is `{}` — there is simply
+ * nothing to hint against, and the constraint materialises once an adapter is in
+ * the compilation. No dependency inversion: schema never names an adapter.
+ */
+export interface FougereHints<K extends string> {
+}
+/**
+ * Per-consumer hints for an entity, keyed by registered adapter. Only adapters
+ * present in {@link FougereHints} are accepted; unknown adapters, unknown fields
+ * and unknown options are all rejected at the call site.
+ */
+export type Hints<TFields extends Fields> = {
+    [A in keyof FougereHints<Extract<keyof TFields, string>>]?: FougereHints<Extract<keyof TFields, string>>[A];
+};
+//# sourceMappingURL=hints.d.ts.map

package/dist/hints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hints.d.ts","sourceRoot":"","sources":["../src/hints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS,MAAM;CAAI;AAElD;;;;GAIG;AACH,MAAM,MAAM,KAAK,CAAC,OAAO,SAAS,MAAM,IAAI;KACzC,CAAC,IAAI,MAAM,YAAY,CAAC,OAAO,CAAC,MAAM,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,YAAY,CACtE,OAAO,CAAC,MAAM,OAAO,EAAE,MAAM,CAAC,CAC/B,CAAC,CAAC,CAAC;CACL,CAAC"}

package/dist/hints.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=hints.js.map

package/dist/hints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hints.js","sourceRoot":"","sources":["../src/hints.ts"],"names":[],"mappings":""}

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+export { type Field, type AnyField, type Fields, type Shape, type ShapeType, type BaseShape, type ShapeAnatomy, type StringFormat, type Role, type Relation, type Lifecycle, type GeneratorRef, type SchemaLike, type Boundary, type BoundaryRef, type Decoder, type Encoder, type Meta, isField, cloneField, nullableShape, anatomy, uniqueMembers, isNullable, registerGenerator, resolveCustomGenerator, resolveBoundary, declaredBoundary, boundaryOf, registerDecoder, registerEncoder, registerBoundaryAlias, type EntityConstructor, } from './field/index.js';
+export { entity, compose, createSchemaConstructor, ANONYMOUS_SCHEMA_NAME, type SchemaConstructor, type SchemaViewInfer as InferView, type CtorInput, } from './entity.js';
+export { type FougereHints, type Hints } from './hints.js';
+export { type CompositeUnique, type EntityDeclarations } from './unique.js';
+export { primary } from './vocabulary/primary.js';
+export { text, type TextOptions } from './vocabulary/text.js';
+export { email } from './vocabulary/email.js';
+export { url } from './vocabulary/url.js';
+export { list, type ListOptions } from './vocabulary/list.js';
+export { number } from './vocabulary/number.js';
+export { bool } from './vocabulary/bool.js';
+export { date } from './vocabulary/date.js';
+export { auto } from './vocabulary/auto.js';
+export { updated } from './vocabulary/updated.js';
+export { oneOf } from './vocabulary/oneOf.js';
+export { ref } from './vocabulary/ref.js';
+export { many } from './vocabulary/many.js';
+export { optional } from './vocabulary/optional.js';
+export { nullable } from './vocabulary/nullable.js';
+export { immutable } from './vocabulary/immutable.js';
+export { unique } from './vocabulary/unique.js';
+export { indexed } from './vocabulary/indexed.js';
+export { readOnly } from './vocabulary/readOnly.js';
+export { writeOnly } from './vocabulary/writeOnly.js';
+export { json } from './vocabulary/json.js';
+export { applyCreate, applyUpdate } from './projections/lifecycle.js';
+export { type ValidationResult, type ValidationError, type Checked, validateFields, checkValue } from './projections/validation.js';
+export { encodeFields } from './projections/encode.js';
+export { inputFields, outputFields } from './projections/io.js';
+export { describe, describeSet, sourceNameOf } from './projections/describe.js';
+export { reconstruct, reconstructSet } from './projections/reconstruct.js';
+export { shapeTypeOf, entitySourceOf, facadeTypeSourceOf, type TypeSourceOptions, type OpDescriptor } from './projections/typescript.js';
+export { type SchemaBundle, type SchemaDescriptor, type FieldDescriptor, type FieldExtension, type RoleDescriptor, type RelationDescriptor, type JsonSchemaType, } from './projections/card.js';
+export { type SchemaSource, schemaOf, fieldsOf, uniqueOf } from './projections/source.js';
+export type { StandardSchemaV1 } from './projections/standard.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}