@fougere/schema 0.2.0-alpha.1 → 0.3.0-alpha.0

package/dist/field/boundary.js

@@ -1,94 +0,0 @@
-import { anatomy } from './shape.js';
-// ─── Registries (open, extensible — same spirit as FougereHints) ──
-const decoders = new Map();
-const encoders = new Map();
-const aliases = new Map();
-export function registerDecoder(name, fn) {
-    decoders.set(name, fn);
-}
-export function registerEncoder(name, fn) {
-    encoders.set(name, fn);
-}
-/** Register a named boundary — the alias a field can reference. */
-export function registerBoundaryAlias(name, boundary) {
-    aliases.set(name, boundary);
-}
-// ─── Built-ins ───────────────────────────────────────
-const identityDecoder = (value) => ({ value });
-const identityEncoder = (value) => value;
-// `isoDate`: the only non-identity built-in. Inbound accepts a Date or an ISO-ish
-// string and yields a Date; outbound yields an ISO string. Validity is already
-// guaranteed by `shape` (the date predicate) before decode runs.
-registerDecoder('isoDate', (value) => {
-    if (value instanceof Date)
-        return { value };
-    if (typeof value === 'string') {
-        const d = new Date(value);
-        return Number.isNaN(d.getTime()) ? { error: 'Invalid date' } : { value: d };
-    }
-    return { error: 'Expected a date' };
-});
-registerEncoder('isoDate', (value) => value instanceof Date ? value.toISOString() : value);
-registerBoundaryAlias('isoDate', { in: { decode: 'isoDate' }, out: { encode: 'isoDate' } });
-/** Default boundary derived from a field's shape. A date-time string → isoDate, else identity. */
-function defaultBoundaryForShape(shape) {
-    const base = anatomy(shape).base;
-    if (base && base.type === 'string' && base.format === 'date-time')
-        return aliases.get('isoDate');
-    return {};
-}
-// ─── Resolution ──────────────────────────────────────
-/** The field's DECLARED boundary in normal form (alias resolved) — no derived default. */
-export function declaredBoundary(field) {
-    const ref = field.boundary;
-    if (ref === undefined)
-        return {};
-    if (typeof ref === 'string') {
-        const alias = aliases.get(ref);
-        if (!alias)
-            throw new Error(`Unknown boundary alias: '${ref}'`);
-        return alias;
-    }
-    return ref;
-}
-/**
- * The field's EFFECTIVE boundary: declared rules win per direction, the
- * shape-derived default fills the rest. This is the reader every consumer of
- * the axis goes through — `boundaryOf(f).in === 'closed'` is the read-only
- * test, `.out === 'closed'` the write-only one.
- */
-export function boundaryOf(field) {
-    const declared = declaredBoundary(field);
-    const derived = defaultBoundaryForShape(field.shape);
-    return { in: declared.in ?? derived.in, out: declared.out ?? derived.out };
-}
-/**
- * A field's effective conversion functions. The permission facet is not read
- * here: a `'closed'` direction converts as identity — its rejection/omission
- * happens in the readers (validation, encode) BEFORE any conversion.
- *
- * A NAMED codec that no one registered throws, exactly like an unknown alias
- * (`declaredBoundary`). It used to fall back to identity: a frond declared
- * `{ decode: 'celsius' }`, the consumer never called `registerDecoder`, and the
- * value arrived unconverted while the card said it had been converted — the same
- * silent loss this repo measured on Remult (`validate: [null, null]`) and on
- * zod v4 (a computed default frozen at export). One axis, two spellings, one
- * failure mode.
- *
- * It throws where the conversion is needed, not at boot: nothing walks every
- * field at startup. Loud and late beats silent and never.
- */
-export function resolveBoundary(field) {
-    const boundary = boundaryOf(field);
-    return {
-        decode: typeof boundary.in === 'object' ? named(decoders, boundary.in.decode, 'decoder') : identityDecoder,
-        encode: typeof boundary.out === 'object' ? named(encoders, boundary.out.encode, 'encoder') : identityEncoder,
-    };
-}
-function named(registry, name, kind) {
-    const fn = registry.get(name);
-    if (!fn)
-        throw new Error(`Unknown boundary ${kind}: '${name}'. Register it with register${kind[0].toUpperCase()}${kind.slice(1)}('${name}', …).`);
-    return fn;
-}
-//# sourceMappingURL=boundary.js.map

package/dist/field/boundary.js.map

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

package/dist/field/field.d.ts

@@ -1,64 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,28 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,7 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,9 +0,0 @@
-// 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

@@ -1 +0,0 @@
-{"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

@@ -1,40 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,27 +0,0 @@
-// ─── 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

@@ -1 +0,0 @@
-{"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

@@ -1,9 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,7 +0,0 @@
-// ─── 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

@@ -1 +0,0 @@
-{"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

@@ -1,54 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,55 +0,0 @@
-// ─── 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

@@ -1 +0,0 @@
-{"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

@@ -1,77 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,49 +0,0 @@
-// ─── 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

@@ -1 +0,0 @@
-{"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

@@ -1,33 +0,0 @@
-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