doxum 0.1.23 → 0.1.25

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

@@ -1,7 +1,7 @@
-//#region core/src/schema.d.ts
+//#region core/src/schema/model.d.ts
 type DocumentAddress = readonly string[];
 /** Pure synchronous validation. Successful output is ignored; input is never transformed. */
-type Validator<T> = ((value: unknown) => T) | {
+type Validator<T> = ((value: unknown) => value is T) | ((value: unknown) => asserts value is T) | {
   readonly '~standard': {
     readonly version: 1;
     readonly vendor: string;
@@ -84,11 +84,24 @@ type TreeNode<TValue, ValueOptional extends boolean = false> = BaseNode<'tree'>
   readonly value: FieldNode<TValue, ValueOptional>;
 };
 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;
+};
+type ObjectSchema<T extends object = object> = Schema<T> & {
+  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 SchemaObject<T> = { [K in keyof T]: T[K] } & {};
 /** Infer a document or node value, including optional node presence. */
-type Infer<T extends DocumentNode> = T extends {
+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 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>>>;
@@ -98,6 +111,7 @@ type OptionalKeys<S extends ObjectShape> = { [K in keyof S]: S[K] extends {
 } ? K : never }[keyof S];
 type RequiredKeys<S extends ObjectShape> = Exclude<keyof S, OptionalKeys<S>>;
 type ShapeValue<S extends ObjectShape> = SchemaObject<{ readonly [K in RequiredKeys<S>]: NodeValue<S[K]> } & { readonly [K in OptionalKeys<S>]?: NodeValue<S[K]> }>;
+type RootNodeOf<S extends ObjectSchema<object>> = Extract<SchemaNodeOf<S>, ObjectNode>;
 type EntitySchemaNode = ObjectNode<ObjectShape> | VariantNode<string, VariantShape>;
 type ValueSchemaNode = EntitySchemaNode | FieldNode<unknown, boolean>;
 type DocumentAnchor<K extends string = string> = {
@@ -107,6 +121,58 @@ 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?: {
+  readonly key: Validator<K>;
+}) => SchemaHandle<TableNode<EntityNodeOf<V>, K>>;
+declare const map: <V extends ValueSchemaHandle, 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>>;
+//#endregion
+//#region core/src/schema/path.d.ts
 declare const pathValue: unique symbol;
 declare const collectionEntry: unique symbol;
 declare const collectionKey: unique symbol;
@@ -122,8 +188,8 @@ type NodeAbsent<N extends DocumentNode, ParentAbsent extends boolean> = Or<Paren
 } ? true : false>;
 type PathResult<N extends DocumentNode, ParentAbsent extends boolean> = Infer<N> | (ParentAbsent extends true ? undefined : never);
 type SchemaPathFor<S extends ObjectShape = ObjectShape, TValue = unknown, Absent extends boolean = false> = { readonly [K in keyof S]: PathValue<S[K], Absent> } & PathMarker<TValue | (Absent extends true ? undefined : never)>;
-type SchemaPath<S extends ObjectShape = ObjectShape> = SchemaPathFor<S, ShapeValue<S>>;
-type PathPick<S extends ObjectNode = ObjectNode> = (path: SchemaPath<S['shape']>) => PathMarker<unknown>;
+type SchemaPath<S extends ObjectSchema<object> = ObjectSchema<object>> = RootNodeOf<S> extends ObjectNode<infer Shape> ? SchemaPathFor<Shape, Infer<S>> : never;
+type PathPick<S extends ObjectSchema<object> = ObjectSchema<object>> = (path: SchemaPath<S>) => PathMarker<unknown>;
 type VariantKeys<V extends VariantShape> = { [K in keyof V & string]: keyof (V[K] extends ObjectNode<infer S> ? S : {}) }[keyof V & string] & string;
 type VariantFieldMissing<V extends VariantShape, K extends string> = { [P in keyof V & string]: V[P] extends ObjectNode<infer S> ? (K extends keyof S ? never : P) : P }[keyof V & string] extends never ? false : true;
 type VariantFieldPath<V extends VariantShape, K extends string, Absent extends boolean> = { [P in keyof V & string]: V[P] extends ObjectNode<infer S> ? K extends keyof S ? PathValue<S[K], Or<Absent, VariantFieldMissing<V, K>>> : never : never }[keyof V & string];
@@ -152,19 +218,6 @@ type CollectionId<T> = CollectionInfo<T> extends {
 type CollectionEntry<T> = CollectionInfo<T> extends {
   readonly entry: infer TEntry;
 } ? TEntry : unknown;
-declare const field: <T>(validator?: Validator<T>) => FieldNode<T>;
-type OptionalLeaf = FieldNode<unknown, boolean> | VariantNode<string, VariantShape> | MapNode<ValueSchemaNode> | ListNode<unknown> | TreeNode<unknown, false> | TreeNode<unknown, true>;
-declare const optional: <T extends OptionalLeaf>(value: T) => OptionalNode<T>;
-declare const object: <S extends ObjectShape>(shape: S) => ObjectNode<S>;
-declare const variant: <T extends string, V extends VariantShape>(tag: T, variants: V) => VariantNode<T, V>;
-declare const table: <V extends EntitySchemaNode, K extends string = string>(value: V, options?: {
-  readonly key: Validator<K>;
-}) => TableNode<V, K>;
-declare const map: <V extends ValueSchemaNode, K extends string = string>(value: V, options?: {
-  readonly key: Validator<K>;
-}) => MapNode<V, K>;
-declare const list: <TItem>(value: FieldNode<TItem, false>, config: DocumentListConfig<TItem>) => ListNode<TItem>;
-declare const tree: <TValue, ValueOptional extends boolean>(value: FieldNode<TValue, ValueOptional>) => TreeNode<TValue, ValueOptional>;
 //#endregion
 //#region core/src/schema/value.d.ts
 type ParseIssue = {
@@ -176,7 +229,7 @@ declare class ParseError extends TypeError {
   readonly issues: readonly ParseIssue[];
   constructor(issue: ParseIssue);
 }
-declare const parse: <N extends DocumentNode>(node: N, input: unknown) => Infer<N>;
+declare const parse: <S extends Schema<unknown>>(schema: S, input: unknown) => Infer<S>;
 //#endregion
 //#region core/src/changes.d.ts
 type ValueTransition<T = unknown> = {
@@ -288,8 +341,9 @@ type NodeAccess<N extends DocumentNode, W extends boolean> = N extends FieldNode
 type Access<N extends DocumentNode, W extends boolean> = N extends {
   readonly optional: true;
 } ? NodeAccess<N, W> | undefined : NodeAccess<N, W>;
-type Read<N extends DocumentNode> = Access<N, false>;
-type Draft<N extends DocumentNode> = Access<N, true>;
+type AccessNode<S extends Schema<unknown> | DocumentNode> = S extends Schema<unknown> ? SchemaNodeOf<S> : Extract<S, DocumentNode>;
+type Read<S extends Schema<unknown> | DocumentNode> = Access<AccessNode<S>, false>;
+type Draft<S extends Schema<unknown> | DocumentNode> = Access<AccessNode<S>, true>;
 type Snapshot<T> = T extends {
   readonly [scopeValue]?: readonly [DocumentNode, boolean, infer V];
 } ? V : ReadonlyValue<T>;
@@ -312,10 +366,10 @@ type CollectionImpact<K> = {
   readonly updated: ReadonlySet<K>;
   readonly orderChanged: boolean;
 };
-type DocumentImpact<S extends ObjectNode> = {
+type DocumentImpact<S extends ObjectSchema<object>> = {
   readonly kind: 'incremental' | 'reset';
   affects(pick: PathPick<S>): boolean;
-  collection<P extends CollectionPath>(pick: (path: SchemaPath<S['shape']>) => P): CollectionImpact<CollectionId<P>>;
+  collection<P extends CollectionPath>(pick: (path: SchemaPath<S>) => P): CollectionImpact<CollectionId<P>>;
 };
 //#endregion
 //#region core/src/mutation/issue.d.ts
@@ -357,7 +411,7 @@ declare class TransactionRejected extends Error {
   readonly issues: readonly DocumentDiagnostic[];
   constructor(input: DiagnosticInput | readonly DiagnosticInput[]);
 }
-type DocumentCommit<S extends ObjectNode> = {
+type DocumentCommit<S extends ObjectSchema<object>> = {
   readonly revision: number;
   readonly source: CommitSource;
   readonly changes: ChangeSet;
@@ -406,22 +460,27 @@ type LocalHistory<C> = Readable<HistoryState> & {
     cancel(): OperationResult<C>;
   };
 };
-type CommitListener<S extends ObjectNode> = (commit: DocumentCommit<S>) => void;
-type DocumentReadable<S extends ObjectNode> = {
+type CommitListener<S extends ObjectSchema<object>> = (commit: DocumentCommit<S>) => void;
+type ReadonlyDocument<S extends ObjectSchema<object>> = {
   revision(): number;
   subscribe(listener: CommitListener<S>): Unsubscribe;
   subscribe(pick: PathPick<S> | readonly [PathPick<S>, ...PathPick<S>[]], listener: CommitListener<S>): Unsubscribe;
 };
-type DocumentRuntime<S extends ObjectNode> = DocumentReadable<S> & {
+type DocumentRuntime<S extends ObjectSchema<object>> = ReadonlyDocument<S> & {
   readonly schema: S;
+  readonly(): ReadonlyDocument<S>;
   update<V>(run: (draft: Draft<S>) => Synchronous<V>, options?: {
     readonly source?: Extract<CommitSource, 'local' | 'system'>;
     readonly history?: boolean;
   }): TransactionResult<V, DocumentCommit<S>>;
   apply(changes: unknown, options: {
     readonly expectedRevision: number;
-    readonly source?: Exclude<CommitSource, 'history'>;
+    readonly source?: Extract<CommitSource, 'local' | 'system'>;
     readonly history?: boolean;
+  } | {
+    readonly expectedRevision: number;
+    readonly source: 'remote';
+    readonly history?: never;
   }): OperationResult<DocumentCommit<S>>;
   replace(value: Infer<S>, options?: {
     readonly source?: Extract<CommitSource, 'system' | 'remote'>;
@@ -431,5 +490,5 @@ type DocumentRuntime<S extends ObjectNode> = DocumentReadable<S> & {
   dispose(): void;
 };
 //#endregion
-export { TreeNode as $, ParseError as A, DocumentTreeNode as B, Read as C, ChangeSet as D, Change as E, CollectionPath as F, MapNode as G, FieldNode as H, DocumentAddress as I, OptionalNode as J, ObjectNode as K, DocumentAnchor as L, parse as M, CollectionEntry as N, MemberChange as O, CollectionId as P, TableNode as Q, DocumentListConfig as R, Draft as S, snapshot as T, Infer as U, DocumentTreeValue as V, ListNode as W, ReadonlyValue as X, PathValueOf as Y, SchemaPath as Z, Unsubscribe as _, DocumentProblem as a, map as at, CollectionImpact as b, DocumentRuntime as c, table as ct, ObserverError as d, Validator as et, OperationResult as f, Readable as g, TransactionResult as h, DocumentDisposedError as i, list as it, ParseIssue as j, ValueTransition as k, HistoryState as l, tree as lt, TransactionRejected as m, DocumentCommit as n, VariantShape as nt, DocumentReadable as o, object as ot, Synchronous as p, ObjectShape as q, DocumentDiagnostic as r, field as rt, DocumentReentrancyError as s, optional as st, CommitSource as t, VariantNode as tt, LocalHistory as u, variant as ut, MutationIssue as v, replace as w, DocumentImpact as x, MutationIssueCode as y, DocumentNode as z };
-//# sourceMappingURL=contract-ULPQmiEs.d.ts.map
+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

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

@@ -1,7 +1,7 @@
-//#region core/src/schema.d.ts
+//#region core/src/schema/model.d.ts
 type DocumentAddress = readonly string[];
 /** Pure synchronous validation. Successful output is ignored; input is never transformed. */
-type Validator<T> = ((value: unknown) => T) | {
+type Validator<T> = ((value: unknown) => value is T) | ((value: unknown) => asserts value is T) | {
   readonly '~standard': {
     readonly version: 1;
     readonly vendor: string;
@@ -84,11 +84,24 @@ type TreeNode<TValue, ValueOptional extends boolean = false> = BaseNode<'tree'>
   readonly value: FieldNode<TValue, ValueOptional>;
 };
 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;
+};
+type ObjectSchema<T extends object = object> = Schema<T> & {
+  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 SchemaObject<T> = { [K in keyof T]: T[K] } & {};
 /** Infer a document or node value, including optional node presence. */
-type Infer<T extends DocumentNode> = T extends {
+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 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>>>;
@@ -98,6 +111,7 @@ type OptionalKeys<S extends ObjectShape> = { [K in keyof S]: S[K] extends {
 } ? K : never }[keyof S];
 type RequiredKeys<S extends ObjectShape> = Exclude<keyof S, OptionalKeys<S>>;
 type ShapeValue<S extends ObjectShape> = SchemaObject<{ readonly [K in RequiredKeys<S>]: NodeValue<S[K]> } & { readonly [K in OptionalKeys<S>]?: NodeValue<S[K]> }>;
+type RootNodeOf<S extends ObjectSchema<object>> = Extract<SchemaNodeOf<S>, ObjectNode>;
 type EntitySchemaNode = ObjectNode<ObjectShape> | VariantNode<string, VariantShape>;
 type ValueSchemaNode = EntitySchemaNode | FieldNode<unknown, boolean>;
 type DocumentAnchor<K extends string = string> = {
@@ -107,6 +121,58 @@ 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?: {
+  readonly key: Validator<K>;
+}) => SchemaHandle<TableNode<EntityNodeOf<V>, K>>;
+declare const map: <V extends ValueSchemaHandle, 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>>;
+//#endregion
+//#region core/src/schema/path.d.ts
 declare const pathValue: unique symbol;
 declare const collectionEntry: unique symbol;
 declare const collectionKey: unique symbol;
@@ -122,8 +188,8 @@ type NodeAbsent<N extends DocumentNode, ParentAbsent extends boolean> = Or<Paren
 } ? true : false>;
 type PathResult<N extends DocumentNode, ParentAbsent extends boolean> = Infer<N> | (ParentAbsent extends true ? undefined : never);
 type SchemaPathFor<S extends ObjectShape = ObjectShape, TValue = unknown, Absent extends boolean = false> = { readonly [K in keyof S]: PathValue<S[K], Absent> } & PathMarker<TValue | (Absent extends true ? undefined : never)>;
-type SchemaPath<S extends ObjectShape = ObjectShape> = SchemaPathFor<S, ShapeValue<S>>;
-type PathPick<S extends ObjectNode = ObjectNode> = (path: SchemaPath<S['shape']>) => PathMarker<unknown>;
+type SchemaPath<S extends ObjectSchema<object> = ObjectSchema<object>> = RootNodeOf<S> extends ObjectNode<infer Shape> ? SchemaPathFor<Shape, Infer<S>> : never;
+type PathPick<S extends ObjectSchema<object> = ObjectSchema<object>> = (path: SchemaPath<S>) => PathMarker<unknown>;
 type VariantKeys<V extends VariantShape> = { [K in keyof V & string]: keyof (V[K] extends ObjectNode<infer S> ? S : {}) }[keyof V & string] & string;
 type VariantFieldMissing<V extends VariantShape, K extends string> = { [P in keyof V & string]: V[P] extends ObjectNode<infer S> ? (K extends keyof S ? never : P) : P }[keyof V & string] extends never ? false : true;
 type VariantFieldPath<V extends VariantShape, K extends string, Absent extends boolean> = { [P in keyof V & string]: V[P] extends ObjectNode<infer S> ? K extends keyof S ? PathValue<S[K], Or<Absent, VariantFieldMissing<V, K>>> : never : never }[keyof V & string];
@@ -152,19 +218,6 @@ type CollectionId<T> = CollectionInfo<T> extends {
 type CollectionEntry<T> = CollectionInfo<T> extends {
   readonly entry: infer TEntry;
 } ? TEntry : unknown;
-declare const field: <T>(validator?: Validator<T>) => FieldNode<T>;
-type OptionalLeaf = FieldNode<unknown, boolean> | VariantNode<string, VariantShape> | MapNode<ValueSchemaNode> | ListNode<unknown> | TreeNode<unknown, false> | TreeNode<unknown, true>;
-declare const optional: <T extends OptionalLeaf>(value: T) => OptionalNode<T>;
-declare const object: <S extends ObjectShape>(shape: S) => ObjectNode<S>;
-declare const variant: <T extends string, V extends VariantShape>(tag: T, variants: V) => VariantNode<T, V>;
-declare const table: <V extends EntitySchemaNode, K extends string = string>(value: V, options?: {
-  readonly key: Validator<K>;
-}) => TableNode<V, K>;
-declare const map: <V extends ValueSchemaNode, K extends string = string>(value: V, options?: {
-  readonly key: Validator<K>;
-}) => MapNode<V, K>;
-declare const list: <TItem>(value: FieldNode<TItem, false>, config: DocumentListConfig<TItem>) => ListNode<TItem>;
-declare const tree: <TValue, ValueOptional extends boolean>(value: FieldNode<TValue, ValueOptional>) => TreeNode<TValue, ValueOptional>;
 //#endregion
 //#region core/src/schema/value.d.ts
 type ParseIssue = {
@@ -176,7 +229,7 @@ declare class ParseError extends TypeError {
   readonly issues: readonly ParseIssue[];
   constructor(issue: ParseIssue);
 }
-declare const parse: <N extends DocumentNode>(node: N, input: unknown) => Infer<N>;
+declare const parse: <S extends Schema<unknown>>(schema: S, input: unknown) => Infer<S>;
 //#endregion
 //#region core/src/changes.d.ts
 type ValueTransition<T = unknown> = {
@@ -288,8 +341,9 @@ type NodeAccess<N extends DocumentNode, W extends boolean> = N extends FieldNode
 type Access<N extends DocumentNode, W extends boolean> = N extends {
   readonly optional: true;
 } ? NodeAccess<N, W> | undefined : NodeAccess<N, W>;
-type Read<N extends DocumentNode> = Access<N, false>;
-type Draft<N extends DocumentNode> = Access<N, true>;
+type AccessNode<S extends Schema<unknown> | DocumentNode> = S extends Schema<unknown> ? SchemaNodeOf<S> : Extract<S, DocumentNode>;
+type Read<S extends Schema<unknown> | DocumentNode> = Access<AccessNode<S>, false>;
+type Draft<S extends Schema<unknown> | DocumentNode> = Access<AccessNode<S>, true>;
 type Snapshot<T> = T extends {
   readonly [scopeValue]?: readonly [DocumentNode, boolean, infer V];
 } ? V : ReadonlyValue<T>;
@@ -312,10 +366,10 @@ type CollectionImpact<K> = {
   readonly updated: ReadonlySet<K>;
   readonly orderChanged: boolean;
 };
-type DocumentImpact<S extends ObjectNode> = {
+type DocumentImpact<S extends ObjectSchema<object>> = {
   readonly kind: 'incremental' | 'reset';
   affects(pick: PathPick<S>): boolean;
-  collection<P extends CollectionPath>(pick: (path: SchemaPath<S['shape']>) => P): CollectionImpact<CollectionId<P>>;
+  collection<P extends CollectionPath>(pick: (path: SchemaPath<S>) => P): CollectionImpact<CollectionId<P>>;
 };
 //#endregion
 //#region core/src/mutation/issue.d.ts
@@ -357,7 +411,7 @@ declare class TransactionRejected extends Error {
   readonly issues: readonly DocumentDiagnostic[];
   constructor(input: DiagnosticInput | readonly DiagnosticInput[]);
 }
-type DocumentCommit<S extends ObjectNode> = {
+type DocumentCommit<S extends ObjectSchema<object>> = {
   readonly revision: number;
   readonly source: CommitSource;
   readonly changes: ChangeSet;
@@ -406,22 +460,27 @@ type LocalHistory<C> = Readable<HistoryState> & {
     cancel(): OperationResult<C>;
   };
 };
-type CommitListener<S extends ObjectNode> = (commit: DocumentCommit<S>) => void;
-type DocumentReadable<S extends ObjectNode> = {
+type CommitListener<S extends ObjectSchema<object>> = (commit: DocumentCommit<S>) => void;
+type ReadonlyDocument<S extends ObjectSchema<object>> = {
   revision(): number;
   subscribe(listener: CommitListener<S>): Unsubscribe;
   subscribe(pick: PathPick<S> | readonly [PathPick<S>, ...PathPick<S>[]], listener: CommitListener<S>): Unsubscribe;
 };
-type DocumentRuntime<S extends ObjectNode> = DocumentReadable<S> & {
+type DocumentRuntime<S extends ObjectSchema<object>> = ReadonlyDocument<S> & {
   readonly schema: S;
+  readonly(): ReadonlyDocument<S>;
   update<V>(run: (draft: Draft<S>) => Synchronous<V>, options?: {
     readonly source?: Extract<CommitSource, 'local' | 'system'>;
     readonly history?: boolean;
   }): TransactionResult<V, DocumentCommit<S>>;
   apply(changes: unknown, options: {
     readonly expectedRevision: number;
-    readonly source?: Exclude<CommitSource, 'history'>;
+    readonly source?: Extract<CommitSource, 'local' | 'system'>;
     readonly history?: boolean;
+  } | {
+    readonly expectedRevision: number;
+    readonly source: 'remote';
+    readonly history?: never;
   }): OperationResult<DocumentCommit<S>>;
   replace(value: Infer<S>, options?: {
     readonly source?: Extract<CommitSource, 'system' | 'remote'>;
@@ -431,5 +490,5 @@ type DocumentRuntime<S extends ObjectNode> = DocumentReadable<S> & {
   dispose(): void;
 };
 //#endregion
-export { TreeNode as $, ParseError as A, DocumentTreeNode as B, Read as C, ChangeSet as D, Change as E, CollectionPath as F, MapNode as G, FieldNode as H, DocumentAddress as I, OptionalNode as J, ObjectNode as K, DocumentAnchor as L, parse as M, CollectionEntry as N, MemberChange as O, CollectionId as P, TableNode as Q, DocumentListConfig as R, Draft as S, snapshot as T, Infer as U, DocumentTreeValue as V, ListNode as W, ReadonlyValue as X, PathValueOf as Y, SchemaPath as Z, Unsubscribe as _, DocumentProblem as a, map as at, CollectionImpact as b, DocumentRuntime as c, table as ct, ObserverError as d, Validator as et, OperationResult as f, Readable as g, TransactionResult as h, DocumentDisposedError as i, list as it, ParseIssue as j, ValueTransition as k, HistoryState as l, tree as lt, TransactionRejected as m, DocumentCommit as n, VariantShape as nt, DocumentReadable as o, object as ot, Synchronous as p, ObjectShape as q, DocumentDiagnostic as r, field as rt, DocumentReentrancyError as s, optional as st, CommitSource as t, VariantNode as tt, LocalHistory as u, variant as ut, MutationIssue as v, replace as w, DocumentImpact as x, MutationIssueCode as y, DocumentNode as z };
-//# sourceMappingURL=contract-SYJFP0lM.d.cts.map
+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

package/dist/definition-CHVS-RDY.d.cts

@@ -0,0 +1,110 @@
+import { _ as Unsubscribe, b as CollectionImpact } from "./contract-DB8XvNt0.cjs";
+
+//#region core/src/projection/contract.d.ts
+/** The one processor-facing collection transition protocol. */
+type CollectionChange<K extends string, V> = {
+  readonly kind: 'reset';
+} | {
+  readonly kind: 'incremental';
+  readonly added: readonly {
+    readonly key: K;
+    readonly after: V;
+  }[];
+  readonly updated: readonly {
+    readonly key: K;
+    readonly before: V;
+    readonly after: V;
+  }[];
+  readonly removed: readonly {
+    readonly key: K;
+    readonly before: V;
+  }[];
+  readonly order?: {
+    readonly before: readonly K[];
+    readonly after: readonly K[];
+  };
+};
+type CollectionRead<K extends string, V> = {
+  get(key: K): V | undefined;
+  has(key: K): boolean;
+  ids(): readonly K[];
+};
+type ExternalCollectionRead<K extends string, V> = {
+  readonly get: (key: K) => V | undefined;
+  readonly has: (key: K) => boolean;
+  readonly ids: () => readonly K[];
+};
+type ExternalValueSource<T> = {
+  readonly kind: 'value';
+  current(): T;
+  revision(): number;
+  subscribe(listener: (event: ExternalValueEvent<T>) => void): Unsubscribe;
+};
+type ExternalCollectionSource<K extends string, V> = {
+  readonly kind: 'collection';
+  current(): ExternalCollectionRead<K, V>;
+  revision(): number;
+  subscribe(listener: (event: ExternalCollectionEvent<K, V>) => void): Unsubscribe;
+};
+type ExternalValueEvent<T> = {
+  readonly value: T;
+  readonly revision: number;
+  readonly reset?: boolean;
+  readonly cause?: unknown;
+};
+type ExternalCollectionEvent<K extends string, V> = {
+  /** Stable read from the source before this event or external batch. */readonly previous: ExternalCollectionRead<K, V>;
+  readonly revision: number; /** Optional document-style hint; the adapter resolves the canonical change. */
+  readonly impact?: CollectionImpact<K>;
+  readonly cause?: unknown;
+};
+type CollectionDraft<K extends string, V> = {
+  set(key: K, value: V): void;
+  remove(key: K): void;
+  order(ids: readonly K[]): void;
+};
+declare class ProjectionError extends Error {
+  readonly phase: 'processor' | 'listener' | 'source' | 'blocked';
+  readonly cause: unknown;
+  constructor(phase: 'processor' | 'listener' | 'source' | 'blocked', cause: unknown);
+}
+declare class ProjectionDisposedError extends Error {
+  constructor();
+}
+//#endregion
+//#region core/src/projection/definition.d.ts
+declare const projectionDefinition: unique symbol;
+declare const projectionChanges: 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 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>> & {
+  readonly [writableCollectionInput]: {
+    readonly key: K;
+    readonly value: V;
+  };
+  readonly [projectionChanges]: CollectionChange<K, V>;
+};
+type CollectionInputDraft<K extends string, V> = {
+  get(key: K): V | undefined;
+  has(key: K): boolean;
+  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;
+//#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