doxum 0.1.7 → 0.1.9

package/dist/contract-j3SLGAwh.d.cts

@@ -1,563 +0,0 @@
-//#region core/src/schema.d.ts
-type DocumentAddress = readonly string[];
-type DocumentListConfig<TItem> = {
-  readonly keyOf: (item: TItem) => string;
-};
-type DocumentTreeNode<TValue> = {
-  readonly parentId?: string;
-  readonly children: readonly string[];
-  readonly value?: TValue;
-};
-type DocumentTreeValue<TValue> = {
-  readonly rootId?: string;
-  readonly nodes: Readonly<Record<string, DocumentTreeNode<TValue>>>;
-};
-type BaseNode<K extends string> = {
-  readonly kind: K;
-  readonly optional?: boolean;
-};
-type FieldNode<T, Optional extends boolean = false> = BaseNode<'field'> & {
-  readonly __value?: T;
-} & (Optional extends true ? {
-  readonly optional: true;
-} : {
-  readonly optional?: false;
-});
-/** A node with optional presence. The marker replaces, rather than intersects, a field marker. */
-type OptionalNode<TNode extends DocumentNode> = TNode extends FieldNode<infer TValue, boolean> ? FieldNode<TValue, true> : TNode & {
-  readonly optional: true;
-};
-interface ObjectShape {
-  readonly [key: string]: DocumentNode;
-}
-type ObjectNode<TShape extends ObjectShape> = BaseNode<'object'> & {
-  readonly shape: TShape;
-};
-interface VariantShape {
-  readonly [key: string]: ObjectNode<ObjectShape>;
-}
-type VariantNode<TTag extends string, TVariants extends VariantShape> = BaseNode<'variant'> & {
-  readonly tag: TTag;
-  readonly variants: TVariants;
-};
-type TableNode<TValue extends ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> = BaseNode<'table'> & {
-  readonly value: TValue;
-};
-type MapNode<TValue extends ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> = BaseNode<'map'> & {
-  readonly value: TValue;
-};
-type DictNode<TKey extends string, TValue> = BaseNode<'dict'> & {
-  readonly __key?: TKey;
-  readonly __value?: TValue;
-};
-type ListNode<TItem> = BaseNode<'list'> & {
-  readonly __item?: TItem;
-  keyOf(item: TItem): string;
-};
-type TreeNode<TValue> = BaseNode<'tree'> & {
-  readonly __value?: TValue;
-};
-type DocumentNode = FieldNode<unknown, false> | FieldNode<unknown, true> | ObjectNode<ObjectShape> | VariantNode<string, VariantShape> | TableNode<ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> | MapNode<ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> | DictNode<string, unknown> | ListNode<unknown> | TreeNode<unknown>;
-type EntityValue<N extends ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> = N extends ObjectNode<infer S> ? DocumentValueOfShape<S> : N extends VariantNode<infer T, infer V> ? { [K in keyof V & string]: { [P in T]: K } & DocumentValueOfShape<V[K] extends ObjectNode<infer S> ? S : never> }[keyof V & string] : never;
-type DocumentValueOfNode<N> = N extends FieldNode<infer T, infer O> ? O extends true ? T | undefined : T : N extends ObjectNode<infer S> ? DocumentValueOfShape<S> : N extends VariantNode<infer T, infer V> ? EntityValue<VariantNode<T, V>> : N extends TableNode<infer V> ? {
-  readonly ids: readonly string[];
-  readonly byId: Readonly<Record<string, EntityValue<V>>>;
-} : N extends MapNode<infer V> ? Readonly<Record<string, EntityValue<V>>> : N extends DictNode<infer K, infer T> ? Readonly<Partial<Record<K, T>>> : N extends ListNode<infer I> ? readonly I[] : N extends TreeNode<infer T> ? DocumentTreeValue<T> : never;
-type OptionalKeys<S extends ObjectShape> = { [K in keyof S]: S[K] extends {
-  readonly optional: true;
-} ? K : never }[keyof S];
-type RequiredKeys<S extends ObjectShape> = Exclude<keyof S, OptionalKeys<S>>;
-type DocumentValueOfShape<S extends ObjectShape> = { readonly [K in RequiredKeys<S>]: DocumentValueOfNode<S[K]> } & { readonly [K in OptionalKeys<S>]?: DocumentValueOfNode<S[K]> };
-type ReadonlyDocument<S extends DocumentSchema> = DocumentValueOfShape<S['shape']>;
-type EntitySchemaNode = ObjectNode<ObjectShape> | VariantNode<string, VariantShape>;
-type CollectionSelector<TId extends string = string, TNode extends EntitySchemaNode = EntitySchemaNode> = {
-  readonly kind: 'collection';
-  readonly schema: DocumentSchema;
-  readonly address: DocumentAddress;
-  readonly __id?: TId; /** Compile-time entry schema carried by schema selectors. */
-  readonly __node?: TNode;
-};
-type ValueSelector<TResult = unknown> = {
-  readonly kind: 'value';
-  readonly schema: DocumentSchema;
-  readonly address: DocumentAddress;
-  readonly __value?: TResult;
-};
-type ImpactTarget<T = unknown> = {
-  readonly kind: 'value';
-  readonly at: DocumentAddress;
-} | ValueSelector<T> | {
-  readonly kind: 'collection';
-  readonly at: DocumentAddress;
-  readonly id?: string;
-} | CollectionSelector<string>;
-declare const pathValue: unique symbol;
-declare const collectionNode: unique symbol;
-type PathMarker<TValue> = {
-  readonly [pathValue]: TValue;
-};
-type SchemaPathFor<S extends ObjectShape = ObjectShape, TValue = unknown> = { readonly [K in keyof S]: PathValue<S[K]> } & PathMarker<TValue>;
-type DocumentSchema<TShape extends ObjectShape = {}> = {
-  readonly kind: 'schema';
-  readonly shape: TShape;
-  collection<TPath extends CollectionPath>(pick: (path: SchemaPath<TShape>) => TPath): CollectionSelector<CollectionId<TPath>, CollectionNode<TPath>>;
-  value<TPath extends PathMarker<unknown>>(pick: (path: SchemaPath<TShape>) => TPath): ValueSelector<PathValueResult<TPath>>;
-};
-type SchemaPath<S extends ObjectShape = {}> = SchemaPathFor<S, DocumentValueOfShape<S>>;
-type VariantKeys<V extends VariantShape> = { [K in keyof V & string]: keyof (V[K] extends ObjectNode<infer S> ? S : {}) }[keyof V & string] & string;
-type VariantFieldPath<V extends VariantShape, K extends string> = { [P in keyof V & string]: V[P] extends ObjectNode<infer S> ? K extends keyof S ? PathValue<S[K]> : never : never }[keyof V & string];
-type VariantPath<T extends string, V extends VariantShape> = { readonly [K in VariantKeys<V>]: VariantFieldPath<V, K> } & { readonly [K in T]: PathMarker<keyof V & string> } & PathMarker<EntityValue<VariantNode<T, V>>>;
-type PathNodeValue<N extends DocumentNode> = N extends {
-  readonly optional: true;
-} ? DocumentValueOfNode<N> | undefined : DocumentValueOfNode<N>;
-type EntityPath<N extends ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> = N extends ObjectNode<infer S> ? SchemaPathFor<S, PathNodeValue<N>> : N extends VariantNode<infer T, infer V> ? VariantPath<T, V> : never;
-type CollectionPath<N extends EntitySchemaNode = EntitySchemaNode, TValue = unknown> = PathMarker<TValue> & {
-  readonly item: (id: string) => EntityPath<N>;
-  readonly [collectionNode]: N;
-};
-type PathValue<N extends DocumentNode> = N extends ObjectNode<infer S> ? SchemaPathFor<S, PathNodeValue<N>> : N extends VariantNode<infer TTag, infer V> ? VariantPath<TTag, V> : N extends TableNode<infer V> | MapNode<infer V> ? CollectionPath<V, PathNodeValue<N>> : PathMarker<PathNodeValue<N>>;
-type CollectionInfo<T> = T extends {
-  readonly [collectionNode]: infer TNode extends EntitySchemaNode;
-} ? {
-  readonly id: string;
-  readonly node: TNode;
-} : never;
-type CollectionId<T> = CollectionInfo<T> extends {
-  readonly id: infer TId extends string;
-} ? TId : string;
-type CollectionNode<T> = CollectionInfo<T> extends {
-  readonly node: infer TNode extends EntitySchemaNode;
-} ? TNode : EntitySchemaNode;
-type PathValueResult<T> = T extends PathMarker<infer TValue> ? TValue : unknown;
-declare const field: <T>() => FieldNode<T>;
-type OptionalLeaf = FieldNode<unknown, boolean> | VariantNode<string, VariantShape> | DictNode<string, unknown> | ListNode<unknown> | TreeNode<unknown>;
-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 ObjectNode<ObjectShape> | VariantNode<string, VariantShape>>(value: V) => TableNode<V>;
-declare const map: <V extends ObjectNode<ObjectShape> | VariantNode<string, VariantShape>>(value: V) => MapNode<V>;
-declare const dict: <TKey extends string = string, TValue = unknown>() => DictNode<TKey, TValue>;
-declare const list: <TItem>(config: DocumentListConfig<TItem>) => ListNode<TItem>;
-declare const tree: <TValue = unknown>() => TreeNode<TValue>;
-declare const schema: <S extends ObjectShape>(shape: S) => DocumentSchema<S>;
-//#endregion
-//#region core/src/operations.d.ts
-type DocumentAnchor = {
-  readonly before: string;
-} | {
-  readonly after: string;
-} | {
-  readonly at: 'start' | 'end';
-};
-type OperationBase = {
-  readonly at: DocumentAddress;
-};
-type FieldSetOperation = OperationBase & {
-  readonly type: 'field.set';
-  readonly value: unknown;
-};
-type FieldClearOperation = OperationBase & {
-  readonly type: 'field.clear';
-};
-type ValueClearOperation = OperationBase & {
-  readonly type: 'value.clear';
-};
-type VariantReplaceOperation = OperationBase & {
-  readonly type: 'variant.replace';
-  readonly value: unknown;
-};
-type DictSetOperation = OperationBase & {
-  readonly type: 'dict.set';
-  readonly key: string;
-  readonly value: unknown;
-};
-type DictDeleteOperation = OperationBase & {
-  readonly type: 'dict.delete';
-  readonly key: string;
-};
-type DictReplaceOperation = OperationBase & {
-  readonly type: 'dict.replace';
-  readonly value: Readonly<Record<string, unknown>>;
-};
-type EntityCreateOperation = OperationBase & {
-  readonly type: 'entity.create';
-  readonly entries: readonly EntityEntry[];
-  readonly anchor?: DocumentAnchor; /** Generated inverse metadata with strictly increasing final indices. Normal creates omit it. */
-  readonly positions?: readonly number[];
-};
-type EntityEntry = {
-  readonly id: string;
-  readonly value: unknown;
-};
-type EntityRemoveOperation = OperationBase & {
-  readonly type: 'entity.remove';
-  readonly ids: readonly string[];
-};
-type EntityMoveOperation = OperationBase & {
-  readonly type: 'entity.move';
-  readonly id: string;
-  readonly anchor?: DocumentAnchor;
-};
-type ListInsertOperation = OperationBase & {
-  readonly type: 'list.insert';
-  readonly key: string;
-  readonly value: unknown;
-  readonly anchor?: DocumentAnchor;
-};
-type ListMoveOperation = OperationBase & {
-  readonly type: 'list.move';
-  readonly key: string;
-  readonly anchor?: DocumentAnchor;
-};
-type ListRemoveOperation = OperationBase & {
-  readonly type: 'list.remove';
-  readonly key: string;
-};
-type ListReplaceOperation = OperationBase & {
-  readonly type: 'list.replace';
-  readonly value: readonly unknown[];
-  readonly keys: readonly string[];
-};
-type TreeInsertOperation = OperationBase & {
-  readonly type: 'tree.insert';
-  readonly treeNodeId: string;
-  readonly parentId?: string;
-  readonly index?: number;
-  readonly value?: unknown;
-};
-type TreeMoveOperation = OperationBase & {
-  readonly type: 'tree.move';
-  readonly treeNodeId: string;
-  readonly parentId?: string;
-  readonly index?: number;
-};
-type TreeRemoveOperation = OperationBase & {
-  readonly type: 'tree.remove';
-  readonly treeNodeId: string;
-};
-type TreeSetOperation = OperationBase & {
-  readonly type: 'tree.set';
-  readonly treeNodeId: string;
-  readonly value: unknown;
-};
-type TreeReplaceOperation = OperationBase & {
-  readonly type: 'tree.replace';
-  readonly value: unknown;
-};
-type DocumentOperation = FieldSetOperation | FieldClearOperation | ValueClearOperation | VariantReplaceOperation | DictSetOperation | DictDeleteOperation | DictReplaceOperation | EntityCreateOperation | EntityRemoveOperation | EntityMoveOperation | ListInsertOperation | ListMoveOperation | ListRemoveOperation | ListReplaceOperation | TreeInsertOperation | TreeMoveOperation | TreeRemoveOperation | TreeSetOperation | TreeReplaceOperation;
-//#endregion
-//#region core/src/access/reader.d.ts
-type FieldReader<T> = {
-  readonly get: () => T;
-};
-type DictionaryReader<K extends string, V> = {
-  get(key: K): V | undefined;
-  has(key: K): boolean;
-  keys(): readonly K[];
-  values(): Readonly<Partial<Record<K, V>>>;
-};
-type CollectionReader<TId, TNode extends EntitySchemaNode> = {
-  readonly ids: () => readonly TId[];
-  readonly has: (id: TId) => boolean;
-  readonly get: (id: TId) => ReaderOfNode<TNode> | undefined;
-};
-type ListReader<T> = {
-  readonly get: (key: string) => T | undefined;
-  readonly has: (key: string) => boolean;
-  readonly values: () => readonly T[];
-  readonly length: () => number;
-  readonly at: (index: number) => T | undefined;
-};
-type TreeReader<T> = {
-  readonly rootId: () => string | undefined;
-  readonly has: (id: string) => boolean;
-  readonly value: (id: string) => T | undefined;
-  readonly parent: (id: string) => string | undefined;
-  readonly children: (id: string) => readonly string[];
-};
-type ReaderOfNode<TNode extends DocumentNode> = TNode extends {
-  kind: 'field';
-} ? FieldReader<DocumentValueOfNode<TNode>> : TNode extends ObjectNode<infer TShape> ? { readonly [K in keyof TShape]: ReaderOfNode<TShape[K]> } : TNode extends VariantNode<string, infer _TVariants> ? FieldReader<DocumentValueOfNode<TNode> | (TNode extends {
-  readonly optional: true;
-} ? undefined : never)> : TNode extends TableNode<infer TValue> ? CollectionReader<string, TValue> : TNode extends MapNode<infer TValue> ? CollectionReader<string, TValue> : TNode extends DictNode<infer TKey, infer TValue> ? DictionaryReader<TKey, TValue> : TNode extends ListNode<infer TItem> ? ListReader<TItem> : TNode extends TreeNode<infer TValue> ? TreeReader<TValue> : FieldReader<DocumentValueOfNode<TNode>>;
-type DocumentReader<TSchema extends DocumentSchema> = ReaderOfNode<ObjectNode<TSchema['shape']>>;
-//#endregion
-//#region core/src/access/writer.d.ts
-type FieldWriter<T, Optional extends boolean = false> = {
-  readonly set: (value: T) => void;
-} & (Optional extends true ? {
-  readonly clear: () => void;
-} : {});
-type DictionaryWriter<TKey extends string, TValue> = {
-  readonly set: (key: TKey, value: TValue) => void;
-  readonly delete: (key: TKey) => void;
-  readonly replace: (value: Readonly<Partial<Record<TKey, TValue>>>) => void;
-};
-type CollectionWriter<TId, TNode extends EntitySchemaNode> = {
-  readonly create: (entry: {
-    readonly id: TId;
-    readonly value: DocumentValueOfNode<TNode>;
-  } | readonly {
-    readonly id: TId;
-    readonly value: DocumentValueOfNode<TNode>;
-  }[], anchor?: DocumentAnchor) => void;
-  readonly item: (id: TId) => WriterOfNode<TNode>;
-  readonly remove: (id: TId | readonly TId[]) => void;
-  readonly move: (id: TId, anchor?: DocumentAnchor) => void;
-};
-type MapWriter<TId, TNode extends EntitySchemaNode> = {
-  readonly create: (entry: {
-    readonly id: TId;
-    readonly value: DocumentValueOfNode<TNode>;
-  } | readonly {
-    readonly id: TId;
-    readonly value: DocumentValueOfNode<TNode>;
-  }[]) => void;
-  readonly item: (id: TId) => WriterOfNode<TNode>;
-  readonly remove: (id: TId | readonly TId[]) => void;
-};
-type ListWriter<T> = {
-  readonly insert: (value: T, anchor?: DocumentAnchor) => void;
-  readonly move: (key: string, anchor?: DocumentAnchor) => void;
-  readonly remove: (key: string) => void;
-  readonly replace: (value: readonly T[]) => void;
-};
-type TreeWriter<T> = {
-  readonly insert: (id: string, value: T, position?: {
-    readonly parentId?: string;
-    readonly index?: number;
-  }) => void;
-  readonly move: (id: string, position?: {
-    readonly parentId?: string;
-    readonly index?: number;
-  }) => void;
-  readonly remove: (id: string) => void;
-  readonly set: (id: string, value: T) => void;
-  readonly replace: (value: DocumentTreeValue<T>) => void;
-};
-type OptionalClear<TNode extends DocumentNode, TWriter> = TNode extends {
-  readonly optional: true;
-} ? TWriter & {
-  readonly clear: () => void;
-} : TWriter;
-type WriterOfNode<TNode extends DocumentNode> = TNode extends {
-  kind: 'field';
-} ? TNode extends {
-  readonly optional: true;
-} ? FieldWriter<DocumentValueOfNode<TNode>, true> : FieldWriter<DocumentValueOfNode<TNode>> : TNode extends ObjectNode<infer TShape> ? { readonly [K in keyof TShape]: WriterOfNode<TShape[K]> } : TNode extends VariantNode<string, infer _TVariants> ? OptionalClear<TNode, {
-  readonly replace: (value: DocumentValueOfNode<TNode>) => void;
-}> : TNode extends TableNode<infer TValue> ? CollectionWriter<string, TValue> : TNode extends MapNode<infer TValue> ? MapWriter<string, TValue> : TNode extends DictNode<infer TKey, infer TValue> ? OptionalClear<TNode, DictionaryWriter<TKey, TValue>> : TNode extends ListNode<infer TItem> ? OptionalClear<TNode, ListWriter<TItem>> : TNode extends TreeNode<infer TValue> ? OptionalClear<TNode, TreeWriter<TValue>> : FieldWriter<DocumentValueOfNode<TNode>>;
-type DocumentWriter<TSchema extends DocumentSchema> = WriterOfNode<ObjectNode<TSchema['shape']>>;
-//#endregion
-//#region core/src/mutation/issue.d.ts
-type MutationIssueCode = 'invalid-address' | 'invalid-operation' | 'unknown-operation' | 'required-field' | 'invalid-anchor' | 'duplicate-entity' | 'missing-entity' | 'invalid-collection' | 'invalid-list-keys' | 'invalid-list-key' | 'duplicate-list-item' | 'missing-list-item' | 'invalid-tree' | 'duplicate-tree-node' | 'missing-tree-parent' | 'invalid-tree-index' | 'missing-tree-node' | 'tree-cycle';
-type MutationIssue = {
-  readonly source: 'mutation';
-  readonly code: MutationIssueCode;
-  readonly address: DocumentAddress;
-  readonly message: string;
-  readonly operation?: DocumentOperation['type'];
-};
-//#endregion
-//#region core/src/impact.d.ts
-type CollectionImpact<TId> = {
-  readonly kind: 'reset';
-} | {
-  readonly kind: 'incremental';
-  readonly added: ReadonlySet<TId>;
-  readonly removed: ReadonlySet<TId>;
-  readonly updated: ReadonlySet<TId>;
-  readonly orderChanged: boolean;
-};
-type DocumentImpact<TSchema extends DocumentSchema> = {
-  readonly kind: 'incremental' | 'reset';
-  readonly affects: (target: ImpactTarget<unknown>) => boolean;
-  readonly collection: <TId extends string>(selector: CollectionSelector<TId>) => CollectionImpact<TId>;
-  readonly operations: readonly DocumentOperation[];
-};
-//#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: DocumentSchema, address: DocumentAddress, document?: unknown) => AddressRef | undefined;
-declare const read: (root: unknown, address: DocumentAddress) => 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/mutation/footprint.d.ts
-type CommandFootprintTarget = {
-  readonly kind: 'value';
-  readonly at: DocumentAddress;
-} | {
-  readonly kind: 'dictionary';
-  readonly at: DocumentAddress;
-} | {
-  readonly kind: 'dictionary-key';
-  readonly at: DocumentAddress;
-  readonly key: string;
-} | {
-  readonly kind: 'collection';
-  readonly at: DocumentAddress;
-} | {
-  readonly kind: 'entity';
-  readonly at: DocumentAddress;
-  readonly id: string;
-} | {
-  readonly kind: 'list';
-  readonly at: DocumentAddress;
-} | {
-  readonly kind: 'list-item';
-  readonly at: DocumentAddress;
-  readonly key: string;
-} | {
-  readonly kind: 'tree';
-  readonly at: DocumentAddress;
-} | {
-  readonly kind: 'tree-node';
-  readonly at: DocumentAddress;
-  readonly id: string;
-};
-type CommandFootprint = readonly CommandFootprintTarget[];
-declare const commandFootprint: (operations: readonly DocumentOperation[]) => CommandFootprint;
-declare const footprintsOverlap: (left: CommandFootprint, right: CommandFootprint) => boolean;
-declare const decodeCommandFootprint: (value: unknown) => CommandFootprint | undefined;
-//#endregion
-//#region core/src/projection/readable.d.ts
-type Readable<TValue> = {
-  current(): TValue;
-  revision(): number;
-  subscribe(listener: () => void): Unsubscribe;
-};
-//#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 {
-  constructor();
-}
-declare class DocumentDisposedError extends Error {
-  constructor();
-}
-type DocumentCommit<TSchema extends DocumentSchema> = {
-  readonly revision: number;
-  readonly kind: 'operations' | 'replace';
-  readonly source: CommitSource;
-  readonly operations: readonly DocumentOperation[];
-  readonly inverse: readonly DocumentOperation[];
-  readonly impact: DocumentImpact<TSchema>;
-};
-type DiagnosticInput = {
-  readonly code: string;
-  readonly message: string;
-  readonly address?: DocumentAddress;
-};
-type DocumentDiagnostic = DiagnosticInput & {
-  readonly source: 'application';
-};
-type DocumentProblem = DocumentDiagnostic | MutationIssue;
-type ObserverError = {
-  readonly phase: 'processor' | 'flush' | 'listener';
-  readonly error: unknown;
-};
-type TransactionResult<TValue, TCommit> = {
-  readonly status: 'committed';
-  readonly value: TValue;
-  readonly commit: TCommit;
-  readonly reports: readonly DocumentDiagnostic[];
-  readonly observerErrors: readonly ObserverError[];
-} | {
-  readonly status: 'unchanged';
-  readonly value: TValue;
-  readonly revision: number;
-  readonly reports: readonly DocumentDiagnostic[];
-} | {
-  readonly status: 'rejected';
-  readonly issues: readonly DocumentProblem[];
-  readonly revision: number;
-};
-type PreparedUpdateResult<TValue, TSchema extends DocumentSchema> = {
-  readonly status: 'prepared';
-  readonly value: TValue;
-  readonly operations: readonly DocumentOperation[];
-  readonly inverse: readonly DocumentOperation[];
-  readonly impact: DocumentImpact<TSchema>;
-  readonly footprint: CommandFootprint;
-  readonly reports: readonly DocumentDiagnostic[];
-} | {
-  readonly status: 'unchanged';
-  readonly value: TValue;
-  readonly reports: readonly DocumentDiagnostic[];
-} | {
-  readonly status: 'rejected';
-  readonly issues: readonly DocumentProblem[];
-};
-type OperationResult<TCommit> = {
-  readonly status: 'committed';
-  readonly commit: TCommit;
-  readonly observerErrors: readonly ObserverError[];
-} | {
-  readonly status: 'unchanged';
-  readonly revision: number;
-} | {
-  readonly status: 'rejected';
-  readonly issues: readonly MutationIssue[];
-  readonly revision: number;
-};
-type HistoryState = {
-  readonly undoDepth: number;
-  readonly redoDepth: number;
-};
-type LocalHistory<TCommit> = Readable<HistoryState> & {
-  undo(): OperationResult<TCommit>;
-  redo(): OperationResult<TCommit>;
-  clear(): void;
-  group(): {
-    end(): void;
-    cancel(): OperationResult<TCommit>;
-  };
-};
-type DocumentTransaction<TSchema extends DocumentSchema> = {
-  readonly read: DocumentReader<TSchema>;
-  readonly write: DocumentWriter<TSchema>;
-  readonly reject: (issue: DiagnosticInput | readonly DiagnosticInput[]) => never;
-  readonly report: (issue: DiagnosticInput) => void;
-};
-type CommitListener<TSchema extends DocumentSchema> = (commit: DocumentCommit<TSchema>) => void;
-type DocumentReadable<TSchema extends DocumentSchema> = {
-  readonly address: {
-    readonly resolve: (address: DocumentAddress) => AddressRef | undefined;
-    readonly read: (address: DocumentAddress) => unknown;
-    readonly contains: (parent: DocumentAddress, child: DocumentAddress) => boolean;
-    readonly overlaps: (left: DocumentAddress, right: DocumentAddress) => boolean;
-    readonly debugKey: (address: DocumentAddress) => string;
-  };
-  revision(): number;
-  subscribe(listener: CommitListener<TSchema>): Unsubscribe;
-  subscribe(target: ImpactTarget<unknown> | readonly [ImpactTarget<unknown>, ...ImpactTarget<unknown>[]], listener: CommitListener<TSchema>): Unsubscribe;
-};
-type DocumentRuntime<TSchema extends DocumentSchema> = DocumentReadable<TSchema> & {
-  /** Schema configuration captured when this runtime was created. */readonly schema: TSchema;
-  update<TResult>(run: (transaction: DocumentTransaction<TSchema>) => Synchronous<TResult>, options?: {
-    readonly source?: Extract<CommitSource, 'local' | 'system'>;
-    readonly history?: boolean;
-  }): TransactionResult<TResult, DocumentCommit<TSchema>>;
-  prepare<TResult>(run: (transaction: DocumentTransaction<TSchema>) => Synchronous<TResult>): PreparedUpdateResult<TResult, TSchema>;
-  apply(operations: unknown, options?: {
-    readonly source?: Exclude<CommitSource, 'history'>;
-    readonly history?: boolean;
-  }): OperationResult<DocumentCommit<TSchema>>;
-  replace(document: ReadonlyDocument<TSchema>, options?: {
-    readonly source?: Extract<CommitSource, 'system' | 'remote'>;
-  }): OperationResult<DocumentCommit<TSchema>>;
-  snapshot(): ReadonlyDocument<TSchema>;
-  readonly history: LocalHistory<DocumentCommit<TSchema>>;
-  dispose(): void;
-};
-//#endregion
-export { DocumentOperation as $, variant as $t, CollectionImpact as A, FieldNode as At, TreeWriter as B, TreeNode as Bt, footprintsOverlap as C, DocumentNode as Ct, overlaps as D, DocumentValueOfNode as Dt, debugKey as E, DocumentTreeValue as Et, DictionaryWriter as F, ObjectShape as Ft, FieldReader as G, field as Gt, CollectionReader as H, VariantNode as Ht, DocumentWriter as I, OptionalNode as It, TreeReader as J, object as Jt, ListReader as K, list as Kt, FieldWriter as L, ReadonlyDocument as Lt, MutationIssue as M, ListNode as Mt, MutationIssueCode as N, MapNode as Nt, read as O, DocumentValueOfShape as Ot, CollectionWriter as P, ObjectNode as Pt, DocumentAnchor as Q, tree as Qt, ListWriter as R, SchemaPath as Rt, decodeCommandFootprint as S, DocumentListConfig as St, contains as T, DocumentTreeNode as Tt, DictionaryReader as U, VariantShape as Ut, WriterOfNode as V, ValueSelector as Vt, DocumentReader as W, dict as Wt, DictReplaceOperation as X, schema as Xt, DictDeleteOperation as Y, optional as Yt, DictSetOperation as Z, table as Zt, Unsubscribe as _, CollectionNode as _t, DocumentProblem as a, FieldSetOperation as at, CommandFootprintTarget as b, DictNode as bt, DocumentRuntime as c, ListRemoveOperation as ct, LocalHistory as d, TreeMoveOperation as dt, EntityCreateOperation as et, ObserverError as f, TreeRemoveOperation as ft, TransactionResult as g, VariantReplaceOperation as gt, Synchronous as h, ValueClearOperation as ht, DocumentDisposedError as i, FieldClearOperation as it, DocumentImpact as j, ImpactTarget as jt, resolveAddress as k, EntitySchemaNode as kt, DocumentTransaction as l, ListReplaceOperation as lt, PreparedUpdateResult as m, TreeSetOperation as mt, DocumentCommit as n, EntityMoveOperation as nt, DocumentReadable as o, ListInsertOperation as ot, OperationResult as p, TreeReplaceOperation as pt, ReaderOfNode as q, map as qt, DocumentDiagnostic as r, EntityRemoveOperation as rt, DocumentReentrancyError as s, ListMoveOperation as st, CommitSource as t, EntityEntry as tt, HistoryState as u, TreeInsertOperation as ut, Readable as v, CollectionPath as vt, AddressRef as w, DocumentSchema as wt, commandFootprint as x, DocumentAddress as xt, CommandFootprint as y, CollectionSelector as yt, MapWriter as z, TableNode as zt };
-//# sourceMappingURL=contract-j3SLGAwh.d.cts.map

package/dist/driver-CNxqMVFH.cjs

@@ -1,69 +0,0 @@
-//#region core/src/runtime/driver.ts
-const states = /* @__PURE__ */ new WeakMap();
-const stateOf = (runtime) => {
-	const state = states.get(runtime);
-	if (!state) throw new Error("Unknown Doxum runtime.");
-	return state;
-};
-const bindRuntimeDriver = (runtime) => {
-	states.set(runtime, {
-		driver: void 0,
-		bypassDepth: 0
-	});
-};
-const assertRuntimeWritable = (runtime, intent) => {
-	const state = stateOf(runtime);
-	if (state.bypassDepth === 0) state.driver?.assertWritable(intent);
-};
-const installRuntimeWriteDriver = (runtime, driver) => {
-	const state = stateOf(runtime);
-	if (state.driver) throw new Error("Doxum runtime already has a write driver.");
-	state.driver = driver;
-	let active = true;
-	return Object.freeze({
-		run: (run) => {
-			if (!active) throw new Error("Doxum runtime write driver is no longer active.");
-			state.bypassDepth += 1;
-			try {
-				return run();
-			} finally {
-				state.bypassDepth -= 1;
-			}
-		},
-		dispose: () => {
-			if (!active) return;
-			active = false;
-			if (state.driver === driver) state.driver = void 0;
-		}
-	});
-};
-const disposeRuntimeDriver = (runtime) => {
-	states.delete(runtime);
-};
-//#endregion
-Object.defineProperty(exports, "assertRuntimeWritable", {
-	enumerable: true,
-	get: function() {
-		return assertRuntimeWritable;
-	}
-});
-Object.defineProperty(exports, "bindRuntimeDriver", {
-	enumerable: true,
-	get: function() {
-		return bindRuntimeDriver;
-	}
-});
-Object.defineProperty(exports, "disposeRuntimeDriver", {
-	enumerable: true,
-	get: function() {
-		return disposeRuntimeDriver;
-	}
-});
-Object.defineProperty(exports, "installRuntimeWriteDriver", {
-	enumerable: true,
-	get: function() {
-		return installRuntimeWriteDriver;
-	}
-});
-
-//# sourceMappingURL=driver-CNxqMVFH.cjs.map

package/dist/driver-CNxqMVFH.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"driver-CNxqMVFH.cjs","names":[],"sources":["../core/src/runtime/driver.ts"],"sourcesContent":["import type { CommitSource, DocumentRuntime } from './contract';\nimport type { DocumentSchema } from '../schema';\n\nexport type RuntimeWriteIntent =\n  | { readonly kind: 'update'; readonly source: Extract<CommitSource, 'local' | 'system'> }\n  | { readonly kind: 'prepare' }\n  | { readonly kind: 'apply'; readonly source: CommitSource }\n  | { readonly kind: 'replace'; readonly source: Extract<CommitSource, 'system' | 'remote'> };\n\nexport type RuntimeWriteDriver = {\n  readonly assertWritable: (intent: RuntimeWriteIntent) => void;\n};\n\nexport type RuntimeWriteDriverLease = {\n  readonly run: <TResult>(run: () => TResult) => TResult;\n  readonly dispose: () => void;\n};\n\ntype RuntimeDriverState = {\n  driver: RuntimeWriteDriver | undefined;\n  bypassDepth: number;\n};\n\nconst states = new WeakMap<object, RuntimeDriverState>();\n\nconst stateOf = (runtime: object): RuntimeDriverState => {\n  const state = states.get(runtime);\n  if (!state) throw new Error('Unknown Doxum runtime.');\n  return state;\n};\n\nexport const bindRuntimeDriver = (runtime: object): void => {\n  states.set(runtime, { driver: undefined, bypassDepth: 0 });\n};\n\nexport const assertRuntimeWritable = (runtime: object, intent: RuntimeWriteIntent): void => {\n  const state = stateOf(runtime);\n  if (state.bypassDepth === 0) state.driver?.assertWritable(intent);\n};\n\nexport const installRuntimeWriteDriver = <TSchema extends DocumentSchema>(\n  runtime: DocumentRuntime<TSchema>,\n  driver: RuntimeWriteDriver\n): RuntimeWriteDriverLease => {\n  const state = stateOf(runtime);\n  if (state.driver) throw new Error('Doxum runtime already has a write driver.');\n  state.driver = driver;\n  let active = true;\n  return Object.freeze({\n    run: <TResult>(run: () => TResult): TResult => {\n      if (!active) throw new Error('Doxum runtime write driver is no longer active.');\n      state.bypassDepth += 1;\n      try {\n        return run();\n      } finally {\n        state.bypassDepth -= 1;\n      }\n    },\n    dispose: (): void => {\n      if (!active) return;\n      active = false;\n      if (state.driver === driver) state.driver = undefined;\n    },\n  });\n};\n\nexport const disposeRuntimeDriver = (runtime: object): void => {\n  states.delete(runtime);\n};\n"],"mappings":";AAuBA,MAAM,yBAAS,IAAI,SAAqC;AAExD,MAAM,WAAW,YAAwC;CACvD,MAAM,QAAQ,OAAO,IAAI,QAAQ;AACjC,KAAI,CAAC,MAAO,OAAM,IAAI,MAAM,yBAAyB;AACrD,QAAO;;AAGT,MAAa,qBAAqB,YAA0B;AAC1D,QAAO,IAAI,SAAS;EAAE,QAAQ,KAAA;EAAW,aAAa;EAAG,CAAC;;AAG5D,MAAa,yBAAyB,SAAiB,WAAqC;CAC1F,MAAM,QAAQ,QAAQ,QAAQ;AAC9B,KAAI,MAAM,gBAAgB,EAAG,OAAM,QAAQ,eAAe,OAAO;;AAGnE,MAAa,6BACX,SACA,WAC4B;CAC5B,MAAM,QAAQ,QAAQ,QAAQ;AAC9B,KAAI,MAAM,OAAQ,OAAM,IAAI,MAAM,4CAA4C;AAC9E,OAAM,SAAS;CACf,IAAI,SAAS;AACb,QAAO,OAAO,OAAO;EACnB,MAAe,QAAgC;AAC7C,OAAI,CAAC,OAAQ,OAAM,IAAI,MAAM,kDAAkD;AAC/E,SAAM,eAAe;AACrB,OAAI;AACF,WAAO,KAAK;aACJ;AACR,UAAM,eAAe;;;EAGzB,eAAqB;AACnB,OAAI,CAAC,OAAQ;AACb,YAAS;AACT,OAAI,MAAM,WAAW,OAAQ,OAAM,SAAS,KAAA;;EAE/C,CAAC;;AAGJ,MAAa,wBAAwB,YAA0B;AAC7D,QAAO,OAAO,QAAQ"}