doxum 0.1.22 → 0.1.25

package/dist/{contract-CRrZ-3sF.d.cts → contract-DB8XvNt0.d.cts}

@@ -1,6 +1,7 @@
-//#region core/src/schema-value.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;
@@ -21,19 +22,6 @@ type Validator<T> = ((value: unknown) => T) | {
     } | PromiseLike<unknown>;
   };
 };
-type ParseIssue = {
-  readonly address: DocumentAddress;
-  readonly code: 'invalid-value' | 'invalid-key' | 'missing-validator' | 'invalid-tree';
-  readonly message: string;
-};
-declare class ParseError extends TypeError {
-  readonly issues: readonly ParseIssue[];
-  constructor(issue: ParseIssue);
-}
-declare const parse: <N extends DocumentNode>(node: N, input: unknown) => Infer<N>;
-//#endregion
-//#region core/src/schema.d.ts
-type DocumentAddress = readonly string[];
 /** Shared payloads are immutable through every alias, including builtin methods. */
 type ReadonlyValue<T> = T extends ((...args: never[]) => unknown) ? T : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<ReadonlyValue<K>, ReadonlyValue<V>> : T extends ReadonlySet<infer V> ? ReadonlySet<ReadonlyValue<V>> : T extends Date ? Omit<Date, `set${string}`> : T extends object ? { readonly [K in keyof T]: ReadonlyValue<T[K]> } : T;
 type DocumentListConfig<TItem> = {
@@ -96,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>>>;
@@ -110,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> = {
@@ -119,43 +121,58 @@ type DocumentAnchor<K extends string = string> = {
 } | {
   readonly after: K;
 };
-type TreeTarget = {
-  readonly kind: 'root';
-} | {
-  readonly kind: 'nodes';
-} | {
-  readonly kind: 'node';
-  readonly id: string;
-};
-type TreeValueTarget = Exclude<TreeTarget, {
-  readonly kind: 'nodes';
-}>;
-type TreeCollectionTarget = Extract<TreeTarget, {
-  readonly kind: 'nodes';
-}>;
-type CollectionSelector<TId extends string = string> = {
-  readonly kind: 'collection';
-  readonly schema: ObjectNode;
-  readonly address: DocumentAddress;
-  readonly tree?: TreeCollectionTarget;
-  readonly __id?: TId;
+type SchemaHandle<N extends DocumentNode> = Schema<InferNode<N>> & {
+  readonly [schemaNode]: N;
 };
-type ValueSelector<TResult = unknown> = {
-  readonly kind: 'value';
-  readonly schema: ObjectNode;
-  readonly address: DocumentAddress;
-  readonly tree?: TreeValueTarget;
-  readonly __value?: TResult;
+type PublicSchemaShape = {
+  readonly [key: string]: Schema<unknown>;
 };
-type ImpactTarget<T = unknown> = {
-  readonly kind: 'value';
-  readonly at: DocumentAddress;
-  readonly tree?: TreeValueTarget;
-} | ValueSelector<T> | {
-  readonly kind: 'collection';
-  readonly at: DocumentAddress;
-  readonly id?: string;
-} | CollectionSelector<string>;
+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;
@@ -171,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];
@@ -201,19 +218,18 @@ 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 = {
+  readonly address: DocumentAddress;
+  readonly code: 'invalid-value' | 'invalid-key' | 'missing-validator' | 'invalid-tree';
+  readonly message: string;
+};
+declare class ParseError extends TypeError {
+  readonly issues: readonly ParseIssue[];
+  constructor(issue: ParseIssue);
+}
+declare const parse: <S extends Schema<unknown>>(schema: S, input: unknown) => Infer<S>;
 //#endregion
 //#region core/src/changes.d.ts
 type ValueTransition<T = unknown> = {
@@ -256,24 +272,12 @@ type ChangeSet = {
   readonly changes: readonly Change[];
 };
 //#endregion
-//#region core/src/mutation/tree.d.ts
+//#region core/src/tree/topology.d.ts
 type TreePosition = {
   readonly parentId?: string;
   readonly index?: number;
 };
 //#endregion
-//#region core/src/address.d.ts
-/** The only resolved address representation used inside the runtime. */
-type AddressRef = {
-  readonly path: number;
-  readonly address: DocumentAddress;
-};
-declare const resolveAddress: (schema: ObjectNode, address: DocumentAddress, document?: unknown) => AddressRef | undefined;
-declare const read: (root: unknown, address: DocumentAddress, schema: DocumentNode) => unknown;
-declare const contains: (parent: DocumentAddress, child: DocumentAddress) => boolean;
-declare const overlaps: (a: DocumentAddress, b: DocumentAddress) => boolean;
-declare const debugKey: (address: DocumentAddress) => string;
-//#endregion
 //#region core/src/access/scope.d.ts
 declare const scopeValue: unique symbol;
 type Scoped<N extends DocumentNode, W extends boolean, V = Infer<N>> = {
@@ -337,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>;
@@ -361,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
@@ -376,7 +381,8 @@ type MutationIssue = {
   readonly message: string;
 };
 //#endregion
-//#region core/src/projection/readable.d.ts
+//#region core/src/readable.d.ts
+type Unsubscribe = () => void;
 type Readable<TValue> = {
   current(): TValue;
   revision(): number;
@@ -384,7 +390,6 @@ type Readable<TValue> = {
 };
 //#endregion
 //#region core/src/runtime/contract.d.ts
-type Unsubscribe = () => void;
 type Synchronous<T> = T extends PromiseLike<unknown> ? never : T;
 type CommitSource = 'local' | 'system' | 'history' | 'remote';
 declare class DocumentReentrancyError extends Error {
@@ -406,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;
@@ -455,29 +460,27 @@ type LocalHistory<C> = Readable<HistoryState> & {
     cancel(): OperationResult<C>;
   };
 };
-type CommitListener<S extends ObjectNode> = (commit: DocumentCommit<S>) => void;
-type DocumentReadable<S extends ObjectNode> = {
-  readonly address: {
-    resolve(address: DocumentAddress): AddressRef | undefined;
-    read(address: DocumentAddress): unknown;
-    contains(parent: DocumentAddress, child: DocumentAddress): boolean;
-    overlaps(left: DocumentAddress, right: DocumentAddress): boolean;
-    debugKey(address: DocumentAddress): string;
-  };
+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'>;
@@ -487,5 +490,5 @@ type DocumentRuntime<S extends ObjectNode> = DocumentReadable<S> & {
   dispose(): void;
 };
 //#endregion
-export { OptionalNode as $, overlaps as A, DocumentAddress as B, Draft as C, AddressRef as D, snapshot as E, MemberChange as F, DocumentTreeValue as G, DocumentListConfig as H, ValueTransition as I, Infer as J, FieldNode as K, CollectionEntry as L, resolveAddress as M, Change as N, contains as O, ChangeSet as P, ObjectShape as Q, CollectionId as R, DocumentImpact as S, replace as T, DocumentNode as U, DocumentAnchor as V, DocumentTreeNode as W, MapNode as X, ListNode as Y, ObjectNode as Z, Unsubscribe as _, Validator as _t, DocumentDisposedError as a, VariantNode as at, MutationIssueCode as b, DocumentReentrancyError as c, list as ct, LocalHistory as d, optional as dt, PathValueOf as et, ObserverError as f, table as ft, TransactionResult as g, ParseIssue as gt, TransactionRejected as h, ParseError as ht, DocumentDiagnostic as i, TreeNode as it, read as j, debugKey as k, DocumentRuntime as l, map as lt, Synchronous as m, variant as mt, CommitSource as n, SchemaPath as nt, DocumentProblem as o, VariantShape as ot, OperationResult as p, tree as pt, ImpactTarget as q, DocumentCommit as r, TableNode as rt, DocumentReadable as s, field as st, CommitListener as t, ReadonlyValue as tt, HistoryState as u, object as ut, Readable as v, parse as vt, Read as w, CollectionImpact as x, MutationIssue as y, CollectionPath as z };
-//# sourceMappingURL=contract-CRrZ-3sF.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-DB8XvNt0.d.cts.map