doxum 0.1.23 → 0.1.26

package/dist/{contract-SYJFP0lM.d.cts → contract-COgxO5sv.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,66 @@ 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 objectSchema: unique symbol;
+/** 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, Shape extends PublicSchemaShape = PublicSchemaShape> = Schema<T, {
+  readonly kind: 'object';
+  readonly shape: Shape;
+}> & {
+  readonly [objectSchema]: true;
+};
+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 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, 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>>>;
@@ -98,6 +153,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 +163,143 @@ type DocumentAnchor<K extends string = string> = {
 } | {
   readonly after: K;
 };
+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 PublicVariantShape = {
+  readonly [key: string]: ObjectSchema<object>;
+};
+type VariantNodeShapeOf<V extends PublicVariantShape> = { readonly [K in keyof V]: Extract<SchemaNodeOf<V[K]>, ObjectNode> };
+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>;
+}) => 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>;
+}) => 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;
 declare const collectionEntry: unique symbol;
 declare const collectionKey: unique symbol;
@@ -122,8 +315,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 +345,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 +356,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 +468,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 +493,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 +538,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 +587,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 +617,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-COgxO5sv.d.ts.map

package/dist/definition-CDOuvb5C.d.cts

@@ -0,0 +1,111 @@
+import { _ as Unsubscribe, b as CollectionImpact } from "./contract-CNR6BS75.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 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> = KeyedProjection<K, V> & {
+  readonly [writableCollectionInput]: {
+    readonly key: K;
+    readonly value: 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 ProjectionChange<P> = P extends KeyedProjection<infer K, infer V> ? CollectionChange<K, V> : undefined;
+//#endregion
+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-xgk3YNBp.d.ts

@@ -0,0 +1,111 @@
+import { _ as Unsubscribe, b as CollectionImpact } from "./contract-COgxO5sv.js";
+
+//#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 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> = KeyedProjection<K, V> & {
+  readonly [writableCollectionInput]: {
+    readonly key: K;
+    readonly value: 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 ProjectionChange<P> = P extends KeyedProjection<infer K, infer V> ? CollectionChange<K, V> : undefined;
+//#endregion
+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

package/dist/{driver-yFfvDMX5.js → driver-B5vdPohL.js}

@@ -1,4 +1,49 @@
-import { n as contextOf, s as validNode, u as isPlainObject } from "./context-DFEaDUv5.js";
+import { n as isPlainObject, r as isRecord } from "./record-B2yRhYsc.js";
+//#region core/src/tree/topology.ts
+const node = (tree, id) => Object.hasOwn(tree.nodes, id) ? tree.nodes[id] : void 0;
+const is = (value) => isRecord(value) && isRecord(value.nodes);
+const validNode = (value) => {
+	if (!isRecord(value) || !Array.isArray(value.children)) return false;
+	if (value.parentId !== void 0 && typeof value.parentId !== "string") return false;
+	const children = /* @__PURE__ */ new Set();
+	for (const id of value.children) {
+		if (typeof id !== "string" || children.has(id)) return false;
+		children.add(id);
+	}
+	return true;
+};
+const contains = (tree, id) => Object.hasOwn(tree.nodes, id);
+const parent = (tree, id) => node(tree, id)?.parentId;
+const children = (tree, id) => node(tree, id)?.children;
+const validate = (value) => {
+	if (!is(value)) return false;
+	const ids = Object.keys(value.nodes);
+	if (ids.length === 0) return value.rootId === void 0;
+	if (typeof value.rootId !== "string" || !Object.hasOwn(value.nodes, value.rootId)) return false;
+	for (const id of ids) {
+		const entry = value.nodes[id];
+		if (!validNode(entry)) return false;
+		if (id === value.rootId) {
+			if (entry.parentId !== void 0) return false;
+		} else if (entry.parentId === void 0 || !Object.hasOwn(value.nodes, entry.parentId)) return false;
+		for (const child of entry.children) {
+			const childNode = value.nodes[child];
+			if (!childNode || childNode.parentId !== id) return false;
+		}
+	}
+	const seen = /* @__PURE__ */ new Set();
+	const stack = [value.rootId];
+	while (stack.length) {
+		const id = stack.pop();
+		if (seen.has(id)) return false;
+		seen.add(id);
+		const entry = value.nodes[id];
+		if (!entry) return false;
+		for (const child of entry.children) stack.push(child);
+	}
+	return seen.size === ids.length;
+};
+//#endregion
 //#region core/src/mutation/issue.ts
 const at = (address, code, message) => Object.freeze({
 	source: "mutation",
@@ -296,6 +341,17 @@ const changeCount = (changes) => {
 	return count;
 };
 //#endregion
+//#region core/src/runtime/context.ts
+const contexts = /* @__PURE__ */ new WeakMap();
+const bindContext = (subject, context) => {
+	contexts.set(subject, context);
+};
+function contextOf(subject, required = true) {
+	const context = contexts.get(subject);
+	if (!context && required) throw new Error("Unknown Doxum runtime.");
+	return context;
+}
+//#endregion
 //#region core/src/runtime/driver.ts
 const assertRuntimeWritable = (runtime, intent) => {
 	const context = contextOf(runtime);
@@ -324,6 +380,6 @@ const installRuntimeWriteDriver = (runtime, driver) => {
 	});
 };
 //#endregion
-export { sealChanges as a, fail as c, decodeChanges as i, invalidValue as l, installRuntimeWriteDriver as n, AddressIndex as o, changeCount as r, MutationRejected as s, assertRuntimeWritable as t };
+export { changeCount as a, AddressIndex as c, invalidValue as d, children as f, validate as g, parent as h, contextOf as i, MutationRejected as l, is as m, installRuntimeWriteDriver as n, decodeChanges as o, contains as p, bindContext as r, sealChanges as s, assertRuntimeWritable as t, fail as u };
 
-//# sourceMappingURL=driver-yFfvDMX5.js.map
+//# sourceMappingURL=driver-B5vdPohL.js.map