doxum 0.1.7 → 0.1.8

package/README.md

@@ -61,7 +61,7 @@ Define the document shape once. Doxum infers the immutable document value and
 the reader and writer APIs from that schema.
 
 ```ts
-import { createDocument, field, object, schema, table } from 'doxum';
+import { createDocument, field, object, schema, table, type Infer } from 'doxum';
 
 const task = object({
   title: field<string>(),
@@ -73,6 +73,9 @@ const taskSchema = schema({
   tasks: table(task),
 });
 
+type Task = Infer<typeof task>;
+type TaskDocument = Infer<typeof taskSchema>;
+
 const runtime = createDocument({
   schema: taskSchema,
   initial: {
@@ -103,6 +106,31 @@ application validation, use `tx.report` or `tx.reject` with a
 diagnostic `{ code, message, address? }`; Doxum adds `source: 'application'`.
 Published diagnostic arrays and addresses are copied and frozen.
 
+## Infer Value Types
+
+Use `Infer<typeof node>` or `Infer<typeof documentSchema>` for value types.
+Schema-generated objects are flattened, with readonly properties and optional
+presence preserved. Variants produce a discriminated union of flat branches:
+
+```ts
+import { field, object, variant, type Infer } from 'doxum';
+
+const outcome = variant('kind', {
+  victory: object({ reason: field<'sealed' | 'destroyed'>() }),
+  defeat: object({ reason: field<'deadline' | 'collapse'>() }),
+});
+
+type Outcome = Infer<typeof outcome>;
+// { readonly kind: 'victory'; readonly reason: 'sealed' | 'destroyed' }
+// | { readonly kind: 'defeat'; readonly reason: 'deadline' | 'collapse' }
+```
+
+`Infer` includes `undefined` for an optional node; in a containing object its
+property is optional. User-supplied types in `field<T>`, dict, list and tree
+values retain their original type structure. Flattening does not recursively
+rewrite those types or apply deep readonly to them. TypeScript controls the
+exact alias presentation in editor hovers.
+
 ## Read And Subscribe
 
 Use `select` for a one-off typed read. Use schema selectors and `subscribe`

package/dist/{contract-DNZ4D53r.d.ts → contract-CIcftgR3.d.ts}

@@ -58,17 +58,20 @@ 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> ? {
+type SchemaObject<T> = { [K in keyof T]: T[K] } & {};
+/** Infer a document or node value, including optional node presence. */
+type Infer<T extends DocumentNode | DocumentSchema> = T extends DocumentSchema<infer S> ? ShapeValue<S> : T extends {
+  readonly optional: true;
+} ? NodeValue<T> | undefined : NodeValue<T>;
+type NodeValue<N> = N extends FieldNode<infer T, infer O> ? O extends true ? T | undefined : 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> ? {
   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;
+  readonly byId: Readonly<Record<string, NodeValue<V>>>;
+} : N extends MapNode<infer V> ? Readonly<Record<string, NodeValue<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 ShapeValue<S extends ObjectShape> = SchemaObject<{ readonly [K in RequiredKeys<S>]: NodeValue<S[K]> } & { readonly [K in OptionalKeys<S>]?: NodeValue<S[K]> }>;
 type EntitySchemaNode = ObjectNode<ObjectShape> | VariantNode<string, VariantShape>;
 type CollectionSelector<TId extends string = string, TNode extends EntitySchemaNode = EntitySchemaNode> = {
   readonly kind: 'collection';
@@ -103,19 +106,16 @@ type DocumentSchema<TShape extends ObjectShape = {}> = {
   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 SchemaPath<S extends ObjectShape = {}> = SchemaPathFor<S, ShapeValue<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 VariantPath<T extends string, V extends VariantShape, TValue> = { readonly [K in VariantKeys<V>]: VariantFieldPath<V, K> } & { readonly [K in T]: PathMarker<keyof V & string> } & PathMarker<TValue>;
+type EntityPath<N extends ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> = N extends ObjectNode<infer S> ? SchemaPathFor<S, Infer<N>> : N extends VariantNode<infer T, infer V> ? VariantPath<T, V, Infer<N>> : 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 PathValue<N extends DocumentNode> = N extends ObjectNode<infer S> ? SchemaPathFor<S, Infer<N>> : N extends VariantNode<infer TTag, infer V> ? VariantPath<TTag, V, Infer<N>> : N extends TableNode<infer V> | MapNode<infer V> ? CollectionPath<V, Infer<N>> : PathMarker<Infer<N>>;
 type CollectionInfo<T> = T extends {
   readonly [collectionNode]: infer TNode extends EntitySchemaNode;
 } ? {
@@ -277,9 +277,7 @@ type TreeReader<T> = {
 };
 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>>;
+} ? FieldReader<Infer<TNode>> : TNode extends ObjectNode<infer TShape> ? { readonly [K in keyof TShape]: ReaderOfNode<TShape[K]> } : TNode extends VariantNode<string, infer _TVariants> ? FieldReader<Infer<TNode>> : 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<Infer<TNode>>;
 type DocumentReader<TSchema extends DocumentSchema> = ReaderOfNode<ObjectNode<TSchema['shape']>>;
 //#endregion
 //#region core/src/access/writer.d.ts
@@ -296,10 +294,10 @@ type DictionaryWriter<TKey extends string, TValue> = {
 type CollectionWriter<TId, TNode extends EntitySchemaNode> = {
   readonly create: (entry: {
     readonly id: TId;
-    readonly value: DocumentValueOfNode<TNode>;
+    readonly value: Exclude<Infer<TNode>, undefined>;
   } | readonly {
     readonly id: TId;
-    readonly value: DocumentValueOfNode<TNode>;
+    readonly value: Exclude<Infer<TNode>, undefined>;
   }[], anchor?: DocumentAnchor) => void;
   readonly item: (id: TId) => WriterOfNode<TNode>;
   readonly remove: (id: TId | readonly TId[]) => void;
@@ -308,10 +306,10 @@ type CollectionWriter<TId, TNode extends EntitySchemaNode> = {
 type MapWriter<TId, TNode extends EntitySchemaNode> = {
   readonly create: (entry: {
     readonly id: TId;
-    readonly value: DocumentValueOfNode<TNode>;
+    readonly value: Exclude<Infer<TNode>, undefined>;
   } | readonly {
     readonly id: TId;
-    readonly value: DocumentValueOfNode<TNode>;
+    readonly value: Exclude<Infer<TNode>, undefined>;
   }[]) => void;
   readonly item: (id: TId) => WriterOfNode<TNode>;
   readonly remove: (id: TId | readonly TId[]) => void;
@@ -344,9 +342,9 @@ 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>>;
+} ? FieldWriter<Infer<TNode>, true> : FieldWriter<Infer<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: Exclude<Infer<TNode>, undefined>) => 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<Infer<TNode>>;
 type DocumentWriter<TSchema extends DocumentSchema> = WriterOfNode<ObjectNode<TSchema['shape']>>;
 //#endregion
 //#region core/src/mutation/issue.d.ts
@@ -551,13 +549,13 @@ type DocumentRuntime<TSchema extends DocumentSchema> = DocumentReadable<TSchema>
     readonly source?: Exclude<CommitSource, 'history'>;
     readonly history?: boolean;
   }): OperationResult<DocumentCommit<TSchema>>;
-  replace(document: ReadonlyDocument<TSchema>, options?: {
+  replace(document: Infer<TSchema>, options?: {
     readonly source?: Extract<CommitSource, 'system' | 'remote'>;
   }): OperationResult<DocumentCommit<TSchema>>;
-  snapshot(): ReadonlyDocument<TSchema>;
+  snapshot(): Infer<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-DNZ4D53r.d.ts.map
+export { DocumentOperation as $, CollectionImpact as A, Infer as At, TreeWriter as B, VariantNode as Bt, footprintsOverlap as C, DocumentNode as Ct, overlaps as D, EntitySchemaNode as Dt, debugKey as E, DocumentTreeValue as Et, DictionaryWriter as F, OptionalNode as Ft, FieldReader as G, map as Gt, CollectionReader as H, dict as Ht, DocumentWriter as I, SchemaPath as It, TreeReader as J, schema as Jt, ListReader as K, object as Kt, FieldWriter as L, TableNode as Lt, MutationIssue as M, MapNode as Mt, MutationIssueCode as N, ObjectNode as Nt, read as O, FieldNode as Ot, CollectionWriter as P, ObjectShape as Pt, DocumentAnchor as Q, ListWriter as R, TreeNode as Rt, decodeCommandFootprint as S, DocumentListConfig as St, contains as T, DocumentTreeNode as Tt, DictionaryReader as U, field as Ut, WriterOfNode as V, VariantShape as Vt, DocumentReader as W, list as Wt, DictReplaceOperation as X, tree as Xt, DictDeleteOperation as Y, table as Yt, DictSetOperation as Z, variant 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, ListNode as jt, resolveAddress as k, ImpactTarget 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, optional 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, ValueSelector as zt };
+//# sourceMappingURL=contract-CIcftgR3.d.ts.map

package/dist/{contract-j3SLGAwh.d.cts → contract-b87yPRDp.d.cts}

@@ -58,17 +58,20 @@ 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> ? {
+type SchemaObject<T> = { [K in keyof T]: T[K] } & {};
+/** Infer a document or node value, including optional node presence. */
+type Infer<T extends DocumentNode | DocumentSchema> = T extends DocumentSchema<infer S> ? ShapeValue<S> : T extends {
+  readonly optional: true;
+} ? NodeValue<T> | undefined : NodeValue<T>;
+type NodeValue<N> = N extends FieldNode<infer T, infer O> ? O extends true ? T | undefined : 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> ? {
   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;
+  readonly byId: Readonly<Record<string, NodeValue<V>>>;
+} : N extends MapNode<infer V> ? Readonly<Record<string, NodeValue<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 ShapeValue<S extends ObjectShape> = SchemaObject<{ readonly [K in RequiredKeys<S>]: NodeValue<S[K]> } & { readonly [K in OptionalKeys<S>]?: NodeValue<S[K]> }>;
 type EntitySchemaNode = ObjectNode<ObjectShape> | VariantNode<string, VariantShape>;
 type CollectionSelector<TId extends string = string, TNode extends EntitySchemaNode = EntitySchemaNode> = {
   readonly kind: 'collection';
@@ -103,19 +106,16 @@ type DocumentSchema<TShape extends ObjectShape = {}> = {
   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 SchemaPath<S extends ObjectShape = {}> = SchemaPathFor<S, ShapeValue<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 VariantPath<T extends string, V extends VariantShape, TValue> = { readonly [K in VariantKeys<V>]: VariantFieldPath<V, K> } & { readonly [K in T]: PathMarker<keyof V & string> } & PathMarker<TValue>;
+type EntityPath<N extends ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> = N extends ObjectNode<infer S> ? SchemaPathFor<S, Infer<N>> : N extends VariantNode<infer T, infer V> ? VariantPath<T, V, Infer<N>> : 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 PathValue<N extends DocumentNode> = N extends ObjectNode<infer S> ? SchemaPathFor<S, Infer<N>> : N extends VariantNode<infer TTag, infer V> ? VariantPath<TTag, V, Infer<N>> : N extends TableNode<infer V> | MapNode<infer V> ? CollectionPath<V, Infer<N>> : PathMarker<Infer<N>>;
 type CollectionInfo<T> = T extends {
   readonly [collectionNode]: infer TNode extends EntitySchemaNode;
 } ? {
@@ -277,9 +277,7 @@ type TreeReader<T> = {
 };
 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>>;
+} ? FieldReader<Infer<TNode>> : TNode extends ObjectNode<infer TShape> ? { readonly [K in keyof TShape]: ReaderOfNode<TShape[K]> } : TNode extends VariantNode<string, infer _TVariants> ? FieldReader<Infer<TNode>> : 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<Infer<TNode>>;
 type DocumentReader<TSchema extends DocumentSchema> = ReaderOfNode<ObjectNode<TSchema['shape']>>;
 //#endregion
 //#region core/src/access/writer.d.ts
@@ -296,10 +294,10 @@ type DictionaryWriter<TKey extends string, TValue> = {
 type CollectionWriter<TId, TNode extends EntitySchemaNode> = {
   readonly create: (entry: {
     readonly id: TId;
-    readonly value: DocumentValueOfNode<TNode>;
+    readonly value: Exclude<Infer<TNode>, undefined>;
   } | readonly {
     readonly id: TId;
-    readonly value: DocumentValueOfNode<TNode>;
+    readonly value: Exclude<Infer<TNode>, undefined>;
   }[], anchor?: DocumentAnchor) => void;
   readonly item: (id: TId) => WriterOfNode<TNode>;
   readonly remove: (id: TId | readonly TId[]) => void;
@@ -308,10 +306,10 @@ type CollectionWriter<TId, TNode extends EntitySchemaNode> = {
 type MapWriter<TId, TNode extends EntitySchemaNode> = {
   readonly create: (entry: {
     readonly id: TId;
-    readonly value: DocumentValueOfNode<TNode>;
+    readonly value: Exclude<Infer<TNode>, undefined>;
   } | readonly {
     readonly id: TId;
-    readonly value: DocumentValueOfNode<TNode>;
+    readonly value: Exclude<Infer<TNode>, undefined>;
   }[]) => void;
   readonly item: (id: TId) => WriterOfNode<TNode>;
   readonly remove: (id: TId | readonly TId[]) => void;
@@ -344,9 +342,9 @@ 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>>;
+} ? FieldWriter<Infer<TNode>, true> : FieldWriter<Infer<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: Exclude<Infer<TNode>, undefined>) => 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<Infer<TNode>>;
 type DocumentWriter<TSchema extends DocumentSchema> = WriterOfNode<ObjectNode<TSchema['shape']>>;
 //#endregion
 //#region core/src/mutation/issue.d.ts
@@ -551,13 +549,13 @@ type DocumentRuntime<TSchema extends DocumentSchema> = DocumentReadable<TSchema>
     readonly source?: Exclude<CommitSource, 'history'>;
     readonly history?: boolean;
   }): OperationResult<DocumentCommit<TSchema>>;
-  replace(document: ReadonlyDocument<TSchema>, options?: {
+  replace(document: Infer<TSchema>, options?: {
     readonly source?: Extract<CommitSource, 'system' | 'remote'>;
   }): OperationResult<DocumentCommit<TSchema>>;
-  snapshot(): ReadonlyDocument<TSchema>;
+  snapshot(): Infer<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
+export { DocumentOperation as $, CollectionImpact as A, Infer as At, TreeWriter as B, VariantNode as Bt, footprintsOverlap as C, DocumentNode as Ct, overlaps as D, EntitySchemaNode as Dt, debugKey as E, DocumentTreeValue as Et, DictionaryWriter as F, OptionalNode as Ft, FieldReader as G, map as Gt, CollectionReader as H, dict as Ht, DocumentWriter as I, SchemaPath as It, TreeReader as J, schema as Jt, ListReader as K, object as Kt, FieldWriter as L, TableNode as Lt, MutationIssue as M, MapNode as Mt, MutationIssueCode as N, ObjectNode as Nt, read as O, FieldNode as Ot, CollectionWriter as P, ObjectShape as Pt, DocumentAnchor as Q, ListWriter as R, TreeNode as Rt, decodeCommandFootprint as S, DocumentListConfig as St, contains as T, DocumentTreeNode as Tt, DictionaryReader as U, field as Ut, WriterOfNode as V, VariantShape as Vt, DocumentReader as W, list as Wt, DictReplaceOperation as X, tree as Xt, DictDeleteOperation as Y, table as Yt, DictSetOperation as Z, variant 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, ListNode as jt, resolveAddress as k, ImpactTarget 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, optional 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, ValueSelector as zt };
+//# sourceMappingURL=contract-b87yPRDp.d.cts.map