doxum 0.1.25 → 0.1.26

package/dist/{contract-Dawq6LKS.d.ts → contract-CNR6BS75.d.cts}

@@ -85,23 +85,65 @@ type TreeNode<TValue, ValueOptional extends boolean = false> = BaseNode<'tree'>
 };
 type DocumentNode = FieldNode<unknown, false> | FieldNode<unknown, true> | ObjectNode<ObjectShape> | VariantNode<string, VariantShape> | TableNode<ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> | MapNode<ValueSchemaNode> | ListNode<unknown> | TreeNode<unknown, false> | TreeNode<unknown, true>;
 declare const schemaType: unique symbol;
-declare const schemaNode: unique symbol;
 declare const objectSchema: unique symbol;
-type Schema<T = unknown> = {
-  readonly [schemaType]: T;
+/** Portable public schema handle. The definition parameter carries compile-time shape only. */
+type Schema<T = unknown, Definition = unknown> = {
+  readonly [schemaType]: {
+    readonly value: T;
+    readonly definition: Definition;
+  };
+};
+type PublicSchemaShape = {
+  readonly [key: string]: Schema<unknown, unknown>;
 };
-type ObjectSchema<T extends object = object> = Schema<T> & {
+type ObjectSchema<T extends object = object, Shape extends PublicSchemaShape = PublicSchemaShape> = Schema<T, {
+  readonly kind: 'object';
+  readonly shape: Shape;
+}> & {
   readonly [objectSchema]: true;
 };
-type SchemaNodeOf<S extends Schema<unknown>> = S extends {
-  readonly [schemaNode]: infer N extends DocumentNode;
-} ? N : S extends ObjectSchema<object> ? ObjectNode : DocumentNode;
+type SchemaDefinitionOf<S extends Schema<unknown, unknown>> = S extends Schema<unknown, infer Definition> ? Definition : unknown;
+type Optionalized<N extends DocumentNode, Optional extends boolean> = Optional extends true ? OptionalNode<N> : N;
+type FieldNodeFor<TValue, Optional extends boolean> = Optional extends true ? FieldNode<TValue, true> : FieldNode<TValue, false>;
+type TreeNodeFor<TValue, ValueOptional extends boolean> = ValueOptional extends true ? TreeNode<TValue, true> : TreeNode<TValue, false>;
+type SchemaNodeFromDefinition<Definition> = Definition extends {
+  readonly kind: 'field';
+  readonly value: infer TValue;
+  readonly optional: infer Optional extends boolean;
+} ? FieldNodeFor<TValue, Optional> : Definition extends {
+  readonly kind: 'object';
+  readonly shape: infer Shape extends PublicSchemaShape;
+} ? ObjectNode<NodeShapeOf<Shape>> : Definition extends {
+  readonly kind: 'variant';
+  readonly tag: infer Tag extends string;
+  readonly variants: infer Variants extends PublicVariantShape;
+  readonly optional: infer Optional extends boolean;
+} ? Optionalized<VariantNode<Tag, VariantNodeShapeOf<Variants>>, Optional> : Definition extends {
+  readonly kind: 'table';
+  readonly value: infer Value extends Schema<unknown, unknown>;
+  readonly key: infer Key extends string;
+} ? TableNode<Extract<SchemaNodeOf<Value>, EntitySchemaNode>, Key> : Definition extends {
+  readonly kind: 'map';
+  readonly value: infer Value extends Schema<unknown, unknown>;
+  readonly key: infer Key extends string;
+  readonly optional: infer Optional extends boolean;
+} ? Optionalized<MapNode<Extract<SchemaNodeOf<Value>, ValueSchemaNode>, Key>, Optional> : Definition extends {
+  readonly kind: 'list';
+  readonly value: infer TValue;
+  readonly optional: infer Optional extends boolean;
+} ? Optionalized<ListNode<TValue>, Optional> : Definition extends {
+  readonly kind: 'tree';
+  readonly value: infer TValue;
+  readonly valueOptional: infer ValueOptional extends boolean;
+  readonly optional: infer Optional extends boolean;
+} ? Optionalized<TreeNodeFor<TValue, ValueOptional>, Optional> : DocumentNode;
+type SchemaNodeOf<S extends Schema<unknown, unknown>> = SchemaNodeFromDefinition<SchemaDefinitionOf<S>>;
 type SchemaObject<T> = { [K in keyof T]: T[K] } & {};
 /** Infer a document or node value, including optional node presence. */
 type InferNode<T extends DocumentNode> = T extends {
   readonly optional: true;
 } ? NodeValue<T> | undefined : NodeValue<T>;
-type Infer<T extends Schema<unknown> | DocumentNode> = T extends Schema<infer TValue> ? TValue : T extends DocumentNode ? InferNode<T> : never;
+type Infer<T extends Schema<unknown, unknown> | DocumentNode> = T extends Schema<infer TValue, unknown> ? TValue : T extends DocumentNode ? InferNode<T> : never;
 type NodeValue<N> = N extends FieldNode<infer T, infer O> ? O extends true ? ReadonlyValue<T> | undefined : ReadonlyValue<T> : N extends ObjectNode<infer S> ? ShapeValue<S> : N extends VariantNode<infer T, infer V> ? { [K in keyof V & string]: SchemaObject<{ readonly [P in T]: K } & NodeValue<V[K]>> }[keyof V & string] : N extends TableNode<infer V, infer K> ? {
   readonly ids: readonly K[];
   readonly byId: Readonly<Record<K, NodeValue<V>>>;
@@ -121,56 +163,141 @@ type DocumentAnchor<K extends string = string> = {
 } | {
   readonly after: K;
 };
-type SchemaHandle<N extends DocumentNode> = Schema<InferNode<N>> & {
-  readonly [schemaNode]: N;
-};
-type PublicSchemaShape = {
-  readonly [key: string]: Schema<unknown>;
-};
 type NodeShapeOf<S extends PublicSchemaShape> = { readonly [K in keyof S]: SchemaNodeOf<S[K]> };
 type PublicOptionalKeys<S extends PublicSchemaShape> = { [K in keyof S]: SchemaNodeOf<S[K]> extends {
   readonly optional: true;
 } ? K : never }[keyof S];
 type PublicRequiredKeys<S extends PublicSchemaShape> = Exclude<keyof S, PublicOptionalKeys<S>>;
 type PublicShapeValue<S extends PublicSchemaShape> = SchemaObject<{ readonly [K in PublicRequiredKeys<S>]: Infer<S[K]> } & { readonly [K in PublicOptionalKeys<S>]?: Infer<S[K]> }>;
-type ObjectSchemaHandle<S extends PublicSchemaShape> = ObjectSchema<PublicShapeValue<S>> & {
-  readonly [schemaNode]: ObjectNode<NodeShapeOf<S>>;
-};
-type FieldSchemaHandle<T> = SchemaHandle<FieldNode<T, false>>;
-type OptionalFieldSchemaHandle<T> = SchemaHandle<FieldNode<T, true>>;
-type OptionalSchemaHandle = Schema<unknown> & {
-  readonly [schemaNode]: OptionalLeaf;
-};
-type EntitySchemaHandle = Schema<unknown> & {
-  readonly [schemaNode]: EntitySchemaNode;
-};
-type ValueSchemaHandle = Schema<unknown> & {
-  readonly [schemaNode]: ValueSchemaNode;
-};
 type PublicVariantShape = {
   readonly [key: string]: ObjectSchema<object>;
 };
 type VariantNodeShapeOf<V extends PublicVariantShape> = { readonly [K in keyof V]: Extract<SchemaNodeOf<V[K]>, ObjectNode> };
-type VariantSchemaHandle<T extends string, V extends PublicVariantShape> = Schema<{ [K in keyof V & string]: SchemaObject<{ readonly [P in T]: K } & Infer<V[K]>> }[keyof V & string]> & {
-  readonly [schemaNode]: VariantNode<T, VariantNodeShapeOf<V>>;
-};
-type OptionalLeaf = FieldNode<unknown, boolean> | VariantNode<string, VariantShape> | MapNode<ValueSchemaNode> | ListNode<unknown> | TreeNode<unknown, false> | TreeNode<unknown, true>;
-type OptionalResult<T extends OptionalSchemaHandle> = SchemaHandle<OptionalNode<Extract<SchemaNodeOf<T>, OptionalLeaf>>>;
-type EntityNodeOf<V extends EntitySchemaHandle> = Extract<SchemaNodeOf<V>, EntitySchemaNode>;
-type ValueNodeOf<V extends ValueSchemaHandle> = Extract<SchemaNodeOf<V>, ValueSchemaNode>;
-declare const field: <T>(validator?: Validator<T>) => FieldSchemaHandle<T>;
-declare const optional: <T extends OptionalSchemaHandle>(value: T) => OptionalResult<T>;
-declare const object: <S extends PublicSchemaShape>(shape: S) => ObjectSchemaHandle<S>;
-declare const variant: <T extends string, V extends PublicVariantShape>(tag: T, variants: V) => VariantSchemaHandle<T, V>;
-declare const table: <V extends EntitySchemaHandle, K extends string = string>(value: V, options?: {
+type FieldSchema<T, Optional extends boolean = boolean> = Schema<ReadonlyValue<T> | (Optional extends true ? undefined : never), {
+  readonly kind: 'field';
+  readonly value: T;
+  readonly optional: Optional;
+}>;
+type VariantSchema = Schema<unknown, {
+  readonly kind: 'variant';
+  readonly tag: string;
+  readonly variants: PublicVariantShape;
+  readonly optional: boolean;
+}>;
+type EntitySchema = ObjectSchema<object> | VariantSchema;
+type ValueSchema = EntitySchema | FieldSchema<unknown>;
+declare const field: <T>(validator?: Validator<T>) => Schema<ReadonlyValue<T>, {
+  readonly kind: "field";
+  readonly value: T;
+  readonly optional: false;
+}>;
+declare function optional<T, Optional extends boolean>(value: Schema<ReadonlyValue<T> | (Optional extends true ? undefined : never), {
+  readonly kind: 'field';
+  readonly value: T;
+  readonly optional: Optional;
+}>): Schema<ReadonlyValue<T> | undefined, {
+  readonly kind: 'field';
+  readonly value: T;
+  readonly optional: true;
+}>;
+declare function optional<TValue, Tag extends string, Variants extends PublicVariantShape, Optional extends boolean>(value: Schema<TValue, {
+  readonly kind: 'variant';
+  readonly tag: Tag;
+  readonly variants: Variants;
+  readonly optional: Optional;
+}>): Schema<TValue | undefined, {
+  readonly kind: 'variant';
+  readonly tag: Tag;
+  readonly variants: Variants;
+  readonly optional: true;
+}>;
+declare function optional<TValue, Value extends Schema<unknown, unknown>, Key extends string, Optional extends boolean>(value: Schema<TValue, {
+  readonly kind: 'map';
+  readonly value: Value;
+  readonly key: Key;
+  readonly optional: Optional;
+}>): Schema<TValue | undefined, {
+  readonly kind: 'map';
+  readonly value: Value;
+  readonly key: Key;
+  readonly optional: true;
+}>;
+declare function optional<TValue, TItem, Optional extends boolean>(value: Schema<TValue, {
+  readonly kind: 'list';
+  readonly value: TItem;
+  readonly optional: Optional;
+}>): Schema<TValue | undefined, {
+  readonly kind: 'list';
+  readonly value: TItem;
+  readonly optional: true;
+}>;
+declare function optional<TValue, TNodeValue, ValueOptional extends boolean, Optional extends boolean>(value: Schema<TValue, {
+  readonly kind: 'tree';
+  readonly value: TNodeValue;
+  readonly valueOptional: ValueOptional;
+  readonly optional: Optional;
+}>): Schema<TValue | undefined, {
+  readonly kind: 'tree';
+  readonly value: TNodeValue;
+  readonly valueOptional: ValueOptional;
+  readonly optional: true;
+}>;
+declare const object: <S extends PublicSchemaShape>(shape: S) => ObjectSchema<PublicShapeValue<S>, S>;
+declare const variant: <T extends string, V extends PublicVariantShape>(tag: T, variants: V) => Schema<{ [K in keyof V & string]: SchemaObject<{ readonly [P in T]: K } & Infer<V[K]>> }[keyof V & string], {
+  readonly kind: "variant";
+  readonly tag: T;
+  readonly variants: V;
+  readonly optional: false;
+}>;
+declare const table: <V extends EntitySchema, K extends string = string>(value: V, options?: {
   readonly key: Validator<K>;
-}) => SchemaHandle<TableNode<EntityNodeOf<V>, K>>;
-declare const map: <V extends ValueSchemaHandle, K extends string = string>(value: V, options?: {
+}) => Schema<{
+  readonly ids: readonly K[];
+  readonly byId: Readonly<Record<K, Exclude<Infer<V>, undefined>>>;
+}, {
+  readonly kind: "table";
+  readonly value: V;
+  readonly key: K;
+}>;
+declare const map: <V extends ValueSchema, K extends string = string>(value: V, options?: {
   readonly key: Validator<K>;
-}) => SchemaHandle<MapNode<ValueNodeOf<V>, K>>;
-declare const list: <TItem>(value: FieldSchemaHandle<TItem>, config: DocumentListConfig<TItem>) => SchemaHandle<ListNode<TItem>>;
-declare function tree<TValue>(value: FieldSchemaHandle<TValue>): SchemaHandle<TreeNode<TValue, false>>;
-declare function tree<TValue>(value: OptionalFieldSchemaHandle<TValue>): SchemaHandle<TreeNode<TValue, true>>;
+}) => Schema<Readonly<Record<K, V extends Schema<infer TValue, infer Definition> ? Definition extends {
+  readonly kind: "field";
+} ? TValue : Exclude<TValue, undefined> : never>>, {
+  readonly kind: "map";
+  readonly value: V;
+  readonly key: K;
+  readonly optional: false;
+}>;
+declare const list: <TItem>(value: Schema<ReadonlyValue<TItem>, {
+  readonly kind: "field";
+  readonly value: TItem;
+  readonly optional: false;
+}>, config: DocumentListConfig<TItem>) => Schema<readonly ReadonlyValue<TItem>[], {
+  readonly kind: "list";
+  readonly value: TItem;
+  readonly optional: false;
+}>;
+declare function tree<TValue>(value: Schema<ReadonlyValue<TValue>, {
+  readonly kind: 'field';
+  readonly value: TValue;
+  readonly optional: false;
+}>): Schema<DocumentTreeValue<TValue, false>, {
+  readonly kind: 'tree';
+  readonly value: TValue;
+  readonly valueOptional: false;
+  readonly optional: false;
+}>;
+declare function tree<TValue>(value: Schema<ReadonlyValue<TValue> | undefined, {
+  readonly kind: 'field';
+  readonly value: TValue;
+  readonly optional: true;
+}>): Schema<DocumentTreeValue<TValue, true>, {
+  readonly kind: 'tree';
+  readonly value: TValue;
+  readonly valueOptional: true;
+  readonly optional: false;
+}>;
 //#endregion
 //#region core/src/schema/path.d.ts
 declare const pathValue: unique symbol;
@@ -491,4 +618,4 @@ type DocumentRuntime<S extends ObjectSchema<object>> = ReadonlyDocument<S> & {
 };
 //#endregion
 export { table as $, ParseError as A, DocumentListConfig as B, Read as C, ChangeSet as D, Change as E, CollectionPath as F, ReadonlyValue as G, DocumentTreeValue as H, PathValueOf as I, field as J, Schema as K, SchemaPath as L, parse as M, CollectionEntry as N, MemberChange as O, CollectionId as P, optional as Q, DocumentAddress as R, Draft as S, snapshot as T, Infer as U, DocumentTreeNode as V, ObjectSchema as W, map as X, list as Y, object as Z, Unsubscribe as _, DocumentProblem as a, CollectionImpact as b, HistoryState as c, OperationResult as d, tree as et, ReadonlyDocument as f, Readable as g, TransactionResult as h, DocumentDisposedError as i, ParseIssue as j, ValueTransition as k, LocalHistory as l, TransactionRejected as m, DocumentCommit as n, DocumentReentrancyError as o, Synchronous as p, Validator as q, DocumentDiagnostic as r, DocumentRuntime as s, CommitSource as t, variant as tt, ObserverError as u, MutationIssue as v, replace as w, DocumentImpact as x, MutationIssueCode as y, DocumentAnchor as z };
-//# sourceMappingURL=contract-Dawq6LKS.d.ts.map
+//# sourceMappingURL=contract-CNR6BS75.d.cts.map

package/dist/{contract-DB8XvNt0.d.cts → contract-COgxO5sv.d.ts}

@@ -85,23 +85,65 @@ type TreeNode<TValue, ValueOptional extends boolean = false> = BaseNode<'tree'>
 };
 type DocumentNode = FieldNode<unknown, false> | FieldNode<unknown, true> | ObjectNode<ObjectShape> | VariantNode<string, VariantShape> | TableNode<ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> | MapNode<ValueSchemaNode> | ListNode<unknown> | TreeNode<unknown, false> | TreeNode<unknown, true>;
 declare const schemaType: unique symbol;
-declare const schemaNode: unique symbol;
 declare const objectSchema: unique symbol;
-type Schema<T = unknown> = {
-  readonly [schemaType]: T;
+/** Portable public schema handle. The definition parameter carries compile-time shape only. */
+type Schema<T = unknown, Definition = unknown> = {
+  readonly [schemaType]: {
+    readonly value: T;
+    readonly definition: Definition;
+  };
+};
+type PublicSchemaShape = {
+  readonly [key: string]: Schema<unknown, unknown>;
 };
-type ObjectSchema<T extends object = object> = Schema<T> & {
+type ObjectSchema<T extends object = object, Shape extends PublicSchemaShape = PublicSchemaShape> = Schema<T, {
+  readonly kind: 'object';
+  readonly shape: Shape;
+}> & {
   readonly [objectSchema]: true;
 };
-type SchemaNodeOf<S extends Schema<unknown>> = S extends {
-  readonly [schemaNode]: infer N extends DocumentNode;
-} ? N : S extends ObjectSchema<object> ? ObjectNode : DocumentNode;
+type SchemaDefinitionOf<S extends Schema<unknown, unknown>> = S extends Schema<unknown, infer Definition> ? Definition : unknown;
+type Optionalized<N extends DocumentNode, Optional extends boolean> = Optional extends true ? OptionalNode<N> : N;
+type FieldNodeFor<TValue, Optional extends boolean> = Optional extends true ? FieldNode<TValue, true> : FieldNode<TValue, false>;
+type TreeNodeFor<TValue, ValueOptional extends boolean> = ValueOptional extends true ? TreeNode<TValue, true> : TreeNode<TValue, false>;
+type SchemaNodeFromDefinition<Definition> = Definition extends {
+  readonly kind: 'field';
+  readonly value: infer TValue;
+  readonly optional: infer Optional extends boolean;
+} ? FieldNodeFor<TValue, Optional> : Definition extends {
+  readonly kind: 'object';
+  readonly shape: infer Shape extends PublicSchemaShape;
+} ? ObjectNode<NodeShapeOf<Shape>> : Definition extends {
+  readonly kind: 'variant';
+  readonly tag: infer Tag extends string;
+  readonly variants: infer Variants extends PublicVariantShape;
+  readonly optional: infer Optional extends boolean;
+} ? Optionalized<VariantNode<Tag, VariantNodeShapeOf<Variants>>, Optional> : Definition extends {
+  readonly kind: 'table';
+  readonly value: infer Value extends Schema<unknown, unknown>;
+  readonly key: infer Key extends string;
+} ? TableNode<Extract<SchemaNodeOf<Value>, EntitySchemaNode>, Key> : Definition extends {
+  readonly kind: 'map';
+  readonly value: infer Value extends Schema<unknown, unknown>;
+  readonly key: infer Key extends string;
+  readonly optional: infer Optional extends boolean;
+} ? Optionalized<MapNode<Extract<SchemaNodeOf<Value>, ValueSchemaNode>, Key>, Optional> : Definition extends {
+  readonly kind: 'list';
+  readonly value: infer TValue;
+  readonly optional: infer Optional extends boolean;
+} ? Optionalized<ListNode<TValue>, Optional> : Definition extends {
+  readonly kind: 'tree';
+  readonly value: infer TValue;
+  readonly valueOptional: infer ValueOptional extends boolean;
+  readonly optional: infer Optional extends boolean;
+} ? Optionalized<TreeNodeFor<TValue, ValueOptional>, Optional> : DocumentNode;
+type SchemaNodeOf<S extends Schema<unknown, unknown>> = SchemaNodeFromDefinition<SchemaDefinitionOf<S>>;
 type SchemaObject<T> = { [K in keyof T]: T[K] } & {};
 /** Infer a document or node value, including optional node presence. */
 type InferNode<T extends DocumentNode> = T extends {
   readonly optional: true;
 } ? NodeValue<T> | undefined : NodeValue<T>;
-type Infer<T extends Schema<unknown> | DocumentNode> = T extends Schema<infer TValue> ? TValue : T extends DocumentNode ? InferNode<T> : never;
+type Infer<T extends Schema<unknown, unknown> | DocumentNode> = T extends Schema<infer TValue, unknown> ? TValue : T extends DocumentNode ? InferNode<T> : never;
 type NodeValue<N> = N extends FieldNode<infer T, infer O> ? O extends true ? ReadonlyValue<T> | undefined : ReadonlyValue<T> : N extends ObjectNode<infer S> ? ShapeValue<S> : N extends VariantNode<infer T, infer V> ? { [K in keyof V & string]: SchemaObject<{ readonly [P in T]: K } & NodeValue<V[K]>> }[keyof V & string] : N extends TableNode<infer V, infer K> ? {
   readonly ids: readonly K[];
   readonly byId: Readonly<Record<K, NodeValue<V>>>;
@@ -121,56 +163,141 @@ type DocumentAnchor<K extends string = string> = {
 } | {
   readonly after: K;
 };
-type SchemaHandle<N extends DocumentNode> = Schema<InferNode<N>> & {
-  readonly [schemaNode]: N;
-};
-type PublicSchemaShape = {
-  readonly [key: string]: Schema<unknown>;
-};
 type NodeShapeOf<S extends PublicSchemaShape> = { readonly [K in keyof S]: SchemaNodeOf<S[K]> };
 type PublicOptionalKeys<S extends PublicSchemaShape> = { [K in keyof S]: SchemaNodeOf<S[K]> extends {
   readonly optional: true;
 } ? K : never }[keyof S];
 type PublicRequiredKeys<S extends PublicSchemaShape> = Exclude<keyof S, PublicOptionalKeys<S>>;
 type PublicShapeValue<S extends PublicSchemaShape> = SchemaObject<{ readonly [K in PublicRequiredKeys<S>]: Infer<S[K]> } & { readonly [K in PublicOptionalKeys<S>]?: Infer<S[K]> }>;
-type ObjectSchemaHandle<S extends PublicSchemaShape> = ObjectSchema<PublicShapeValue<S>> & {
-  readonly [schemaNode]: ObjectNode<NodeShapeOf<S>>;
-};
-type FieldSchemaHandle<T> = SchemaHandle<FieldNode<T, false>>;
-type OptionalFieldSchemaHandle<T> = SchemaHandle<FieldNode<T, true>>;
-type OptionalSchemaHandle = Schema<unknown> & {
-  readonly [schemaNode]: OptionalLeaf;
-};
-type EntitySchemaHandle = Schema<unknown> & {
-  readonly [schemaNode]: EntitySchemaNode;
-};
-type ValueSchemaHandle = Schema<unknown> & {
-  readonly [schemaNode]: ValueSchemaNode;
-};
 type PublicVariantShape = {
   readonly [key: string]: ObjectSchema<object>;
 };
 type VariantNodeShapeOf<V extends PublicVariantShape> = { readonly [K in keyof V]: Extract<SchemaNodeOf<V[K]>, ObjectNode> };
-type VariantSchemaHandle<T extends string, V extends PublicVariantShape> = Schema<{ [K in keyof V & string]: SchemaObject<{ readonly [P in T]: K } & Infer<V[K]>> }[keyof V & string]> & {
-  readonly [schemaNode]: VariantNode<T, VariantNodeShapeOf<V>>;
-};
-type OptionalLeaf = FieldNode<unknown, boolean> | VariantNode<string, VariantShape> | MapNode<ValueSchemaNode> | ListNode<unknown> | TreeNode<unknown, false> | TreeNode<unknown, true>;
-type OptionalResult<T extends OptionalSchemaHandle> = SchemaHandle<OptionalNode<Extract<SchemaNodeOf<T>, OptionalLeaf>>>;
-type EntityNodeOf<V extends EntitySchemaHandle> = Extract<SchemaNodeOf<V>, EntitySchemaNode>;
-type ValueNodeOf<V extends ValueSchemaHandle> = Extract<SchemaNodeOf<V>, ValueSchemaNode>;
-declare const field: <T>(validator?: Validator<T>) => FieldSchemaHandle<T>;
-declare const optional: <T extends OptionalSchemaHandle>(value: T) => OptionalResult<T>;
-declare const object: <S extends PublicSchemaShape>(shape: S) => ObjectSchemaHandle<S>;
-declare const variant: <T extends string, V extends PublicVariantShape>(tag: T, variants: V) => VariantSchemaHandle<T, V>;
-declare const table: <V extends EntitySchemaHandle, K extends string = string>(value: V, options?: {
+type FieldSchema<T, Optional extends boolean = boolean> = Schema<ReadonlyValue<T> | (Optional extends true ? undefined : never), {
+  readonly kind: 'field';
+  readonly value: T;
+  readonly optional: Optional;
+}>;
+type VariantSchema = Schema<unknown, {
+  readonly kind: 'variant';
+  readonly tag: string;
+  readonly variants: PublicVariantShape;
+  readonly optional: boolean;
+}>;
+type EntitySchema = ObjectSchema<object> | VariantSchema;
+type ValueSchema = EntitySchema | FieldSchema<unknown>;
+declare const field: <T>(validator?: Validator<T>) => Schema<ReadonlyValue<T>, {
+  readonly kind: "field";
+  readonly value: T;
+  readonly optional: false;
+}>;
+declare function optional<T, Optional extends boolean>(value: Schema<ReadonlyValue<T> | (Optional extends true ? undefined : never), {
+  readonly kind: 'field';
+  readonly value: T;
+  readonly optional: Optional;
+}>): Schema<ReadonlyValue<T> | undefined, {
+  readonly kind: 'field';
+  readonly value: T;
+  readonly optional: true;
+}>;
+declare function optional<TValue, Tag extends string, Variants extends PublicVariantShape, Optional extends boolean>(value: Schema<TValue, {
+  readonly kind: 'variant';
+  readonly tag: Tag;
+  readonly variants: Variants;
+  readonly optional: Optional;
+}>): Schema<TValue | undefined, {
+  readonly kind: 'variant';
+  readonly tag: Tag;
+  readonly variants: Variants;
+  readonly optional: true;
+}>;
+declare function optional<TValue, Value extends Schema<unknown, unknown>, Key extends string, Optional extends boolean>(value: Schema<TValue, {
+  readonly kind: 'map';
+  readonly value: Value;
+  readonly key: Key;
+  readonly optional: Optional;
+}>): Schema<TValue | undefined, {
+  readonly kind: 'map';
+  readonly value: Value;
+  readonly key: Key;
+  readonly optional: true;
+}>;
+declare function optional<TValue, TItem, Optional extends boolean>(value: Schema<TValue, {
+  readonly kind: 'list';
+  readonly value: TItem;
+  readonly optional: Optional;
+}>): Schema<TValue | undefined, {
+  readonly kind: 'list';
+  readonly value: TItem;
+  readonly optional: true;
+}>;
+declare function optional<TValue, TNodeValue, ValueOptional extends boolean, Optional extends boolean>(value: Schema<TValue, {
+  readonly kind: 'tree';
+  readonly value: TNodeValue;
+  readonly valueOptional: ValueOptional;
+  readonly optional: Optional;
+}>): Schema<TValue | undefined, {
+  readonly kind: 'tree';
+  readonly value: TNodeValue;
+  readonly valueOptional: ValueOptional;
+  readonly optional: true;
+}>;
+declare const object: <S extends PublicSchemaShape>(shape: S) => ObjectSchema<PublicShapeValue<S>, S>;
+declare const variant: <T extends string, V extends PublicVariantShape>(tag: T, variants: V) => Schema<{ [K in keyof V & string]: SchemaObject<{ readonly [P in T]: K } & Infer<V[K]>> }[keyof V & string], {
+  readonly kind: "variant";
+  readonly tag: T;
+  readonly variants: V;
+  readonly optional: false;
+}>;
+declare const table: <V extends EntitySchema, K extends string = string>(value: V, options?: {
   readonly key: Validator<K>;
-}) => SchemaHandle<TableNode<EntityNodeOf<V>, K>>;
-declare const map: <V extends ValueSchemaHandle, K extends string = string>(value: V, options?: {
+}) => Schema<{
+  readonly ids: readonly K[];
+  readonly byId: Readonly<Record<K, Exclude<Infer<V>, undefined>>>;
+}, {
+  readonly kind: "table";
+  readonly value: V;
+  readonly key: K;
+}>;
+declare const map: <V extends ValueSchema, K extends string = string>(value: V, options?: {
   readonly key: Validator<K>;
-}) => SchemaHandle<MapNode<ValueNodeOf<V>, K>>;
-declare const list: <TItem>(value: FieldSchemaHandle<TItem>, config: DocumentListConfig<TItem>) => SchemaHandle<ListNode<TItem>>;
-declare function tree<TValue>(value: FieldSchemaHandle<TValue>): SchemaHandle<TreeNode<TValue, false>>;
-declare function tree<TValue>(value: OptionalFieldSchemaHandle<TValue>): SchemaHandle<TreeNode<TValue, true>>;
+}) => Schema<Readonly<Record<K, V extends Schema<infer TValue, infer Definition> ? Definition extends {
+  readonly kind: "field";
+} ? TValue : Exclude<TValue, undefined> : never>>, {
+  readonly kind: "map";
+  readonly value: V;
+  readonly key: K;
+  readonly optional: false;
+}>;
+declare const list: <TItem>(value: Schema<ReadonlyValue<TItem>, {
+  readonly kind: "field";
+  readonly value: TItem;
+  readonly optional: false;
+}>, config: DocumentListConfig<TItem>) => Schema<readonly ReadonlyValue<TItem>[], {
+  readonly kind: "list";
+  readonly value: TItem;
+  readonly optional: false;
+}>;
+declare function tree<TValue>(value: Schema<ReadonlyValue<TValue>, {
+  readonly kind: 'field';
+  readonly value: TValue;
+  readonly optional: false;
+}>): Schema<DocumentTreeValue<TValue, false>, {
+  readonly kind: 'tree';
+  readonly value: TValue;
+  readonly valueOptional: false;
+  readonly optional: false;
+}>;
+declare function tree<TValue>(value: Schema<ReadonlyValue<TValue> | undefined, {
+  readonly kind: 'field';
+  readonly value: TValue;
+  readonly optional: true;
+}>): Schema<DocumentTreeValue<TValue, true>, {
+  readonly kind: 'tree';
+  readonly value: TValue;
+  readonly valueOptional: true;
+  readonly optional: false;
+}>;
 //#endregion
 //#region core/src/schema/path.d.ts
 declare const pathValue: unique symbol;
@@ -491,4 +618,4 @@ type DocumentRuntime<S extends ObjectSchema<object>> = ReadonlyDocument<S> & {
 };
 //#endregion
 export { table as $, ParseError as A, DocumentListConfig as B, Read as C, ChangeSet as D, Change as E, CollectionPath as F, ReadonlyValue as G, DocumentTreeValue as H, PathValueOf as I, field as J, Schema as K, SchemaPath as L, parse as M, CollectionEntry as N, MemberChange as O, CollectionId as P, optional as Q, DocumentAddress as R, Draft as S, snapshot as T, Infer as U, DocumentTreeNode as V, ObjectSchema as W, map as X, list as Y, object as Z, Unsubscribe as _, DocumentProblem as a, CollectionImpact as b, HistoryState as c, OperationResult as d, tree as et, ReadonlyDocument as f, Readable as g, TransactionResult as h, DocumentDisposedError as i, ParseIssue as j, ValueTransition as k, LocalHistory as l, TransactionRejected as m, DocumentCommit as n, DocumentReentrancyError as o, Synchronous as p, Validator as q, DocumentDiagnostic as r, DocumentRuntime as s, CommitSource as t, variant as tt, ObserverError as u, MutationIssue as v, replace as w, DocumentImpact as x, MutationIssueCode as y, DocumentAnchor as z };
-//# sourceMappingURL=contract-DB8XvNt0.d.cts.map
+//# sourceMappingURL=contract-COgxO5sv.d.ts.map

package/dist/{definition-DT1NpMul.d.ts → definition-CDOuvb5C.d.cts}

@@ -1,4 +1,4 @@
-import { _ as Unsubscribe, b as CollectionImpact } from "./contract-Dawq6LKS.js";
+import { _ as Unsubscribe, b as CollectionImpact } from "./contract-CNR6BS75.cjs";
 
 //#region core/src/projection/contract.d.ts
 /** The one processor-facing collection transition protocol. */
@@ -74,24 +74,30 @@ declare class ProjectionDisposedError extends Error {
 //#endregion
 //#region core/src/projection/definition.d.ts
 declare const projectionDefinition: unique symbol;
-declare const projectionChanges: unique symbol;
+declare const keyedProjection: unique symbol;
 declare const writableInput: unique symbol;
 declare const writableCollectionInput: unique symbol;
 /** A lazy output reference with no materialized Runtime state. */
 type Projection<T> = {
   readonly [projectionDefinition]: T;
 };
+/** A projection whose output is a keyed collection with per-key change semantics. */
+type KeyedProjection<K extends string, V> = Projection<ReadonlyMap<K, V>> & {
+  readonly [keyedProjection]: {
+    readonly key: K;
+    readonly value: V;
+  };
+};
 /** A writable source projection. */
 type Input<T> = Projection<T> & {
   readonly [writableInput]: true;
 };
 /** A writable keyed collection source projection. */
-type CollectionInput<K extends string, V> = Projection<ReadonlyMap<K, V>> & {
+type CollectionInput<K extends string, V> = KeyedProjection<K, V> & {
   readonly [writableCollectionInput]: {
     readonly key: K;
     readonly value: V;
   };
-  readonly [projectionChanges]: CollectionChange<K, V>;
 };
 type CollectionInputDraft<K extends string, V> = {
   get(key: K): V | undefined;
@@ -99,12 +105,7 @@ type CollectionInputDraft<K extends string, V> = {
   set(key: K, value: V): void;
   remove(key: K): void;
 };
-type ProjectionWithChange<T, C> = Projection<T> & {
-  readonly [projectionChanges]: C;
-};
-type ProjectionChange<P> = P extends {
-  readonly [projectionChanges]: infer C;
-} ? C : undefined;
+type ProjectionChange<P> = P extends KeyedProjection<infer K, infer V> ? CollectionChange<K, V> : undefined;
 //#endregion
-export { ProjectionChange as a, CollectionDraft as c, ExternalCollectionRead as d, ExternalCollectionSource as f, ProjectionError as g, ProjectionDisposedError as h, Projection as i, CollectionRead as l, ExternalValueSource as m, CollectionInputDraft as n, ProjectionWithChange as o, ExternalValueEvent as p, Input as r, CollectionChange as s, CollectionInput as t, ExternalCollectionEvent as u };
-//# sourceMappingURL=definition-DT1NpMul.d.ts.map
+export { Projection as a, CollectionDraft as c, ExternalCollectionRead as d, ExternalCollectionSource as f, ProjectionError as g, ProjectionDisposedError as h, KeyedProjection as i, CollectionRead as l, ExternalValueSource as m, CollectionInputDraft as n, ProjectionChange as o, ExternalValueEvent as p, Input as r, CollectionChange as s, CollectionInput as t, ExternalCollectionEvent as u };
+//# sourceMappingURL=definition-CDOuvb5C.d.cts.map

package/dist/{definition-CHVS-RDY.d.cts → definition-xgk3YNBp.d.ts}

@@ -1,4 +1,4 @@
-import { _ as Unsubscribe, b as CollectionImpact } from "./contract-DB8XvNt0.cjs";
+import { _ as Unsubscribe, b as CollectionImpact } from "./contract-COgxO5sv.js";
 
 //#region core/src/projection/contract.d.ts
 /** The one processor-facing collection transition protocol. */
@@ -74,24 +74,30 @@ declare class ProjectionDisposedError extends Error {
 //#endregion
 //#region core/src/projection/definition.d.ts
 declare const projectionDefinition: unique symbol;
-declare const projectionChanges: unique symbol;
+declare const keyedProjection: unique symbol;
 declare const writableInput: unique symbol;
 declare const writableCollectionInput: unique symbol;
 /** A lazy output reference with no materialized Runtime state. */
 type Projection<T> = {
   readonly [projectionDefinition]: T;
 };
+/** A projection whose output is a keyed collection with per-key change semantics. */
+type KeyedProjection<K extends string, V> = Projection<ReadonlyMap<K, V>> & {
+  readonly [keyedProjection]: {
+    readonly key: K;
+    readonly value: V;
+  };
+};
 /** A writable source projection. */
 type Input<T> = Projection<T> & {
   readonly [writableInput]: true;
 };
 /** A writable keyed collection source projection. */
-type CollectionInput<K extends string, V> = Projection<ReadonlyMap<K, V>> & {
+type CollectionInput<K extends string, V> = KeyedProjection<K, V> & {
   readonly [writableCollectionInput]: {
     readonly key: K;
     readonly value: V;
   };
-  readonly [projectionChanges]: CollectionChange<K, V>;
 };
 type CollectionInputDraft<K extends string, V> = {
   get(key: K): V | undefined;
@@ -99,12 +105,7 @@ type CollectionInputDraft<K extends string, V> = {
   set(key: K, value: V): void;
   remove(key: K): void;
 };
-type ProjectionWithChange<T, C> = Projection<T> & {
-  readonly [projectionChanges]: C;
-};
-type ProjectionChange<P> = P extends {
-  readonly [projectionChanges]: infer C;
-} ? C : undefined;
+type ProjectionChange<P> = P extends KeyedProjection<infer K, infer V> ? CollectionChange<K, V> : undefined;
 //#endregion
-export { ProjectionChange as a, CollectionDraft as c, ExternalCollectionRead as d, ExternalCollectionSource as f, ProjectionError as g, ProjectionDisposedError as h, Projection as i, CollectionRead as l, ExternalValueSource as m, CollectionInputDraft as n, ProjectionWithChange as o, ExternalValueEvent as p, Input as r, CollectionChange as s, CollectionInput as t, ExternalCollectionEvent as u };
-//# sourceMappingURL=definition-CHVS-RDY.d.cts.map
+export { Projection as a, CollectionDraft as c, ExternalCollectionRead as d, ExternalCollectionSource as f, ProjectionError as g, ProjectionDisposedError as h, KeyedProjection as i, CollectionRead as l, ExternalValueSource as m, CollectionInputDraft as n, ProjectionChange as o, ExternalValueEvent as p, Input as r, CollectionChange as s, CollectionInput as t, ExternalCollectionEvent as u };
+//# sourceMappingURL=definition-xgk3YNBp.d.ts.map