doxum 0.1.3 → 0.1.5

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { $ as DocumentOperationUnion, $t as variant, A as MutationIssue, At as ObjectNode, B as WriterOfNode, Bt as VariantNode, C as contains, Ct as DocumentTreeValue, D as resolveAddress, Dt as ImpactTarget, E as read, Et as FieldNode, F as EntityWriter, Ft as SchemaPath, G as ListReader, Gt as map, H as DocumentReader, Ht as dict, I as FieldWriter, It as SingleNode, J as DictDeleteOperation, Jt as record, K as ReaderOfNode, Kt as object, L as ListWriter, Lt as TableNode, M as CollectionWriter, Mt as OptionalNode, N as DictionaryWriter, Nt as ReadonlyDocument, O as CollectionImpact, Ot as ListNode, P as DocumentWriter, Pt as RecordNode, Q as DocumentOperation, Qt as tree, R as MapWriter, Rt as TreeNode, S as AddressRef, St as DocumentTreeNode, T as overlaps, Tt as DocumentValueOfShape, U as EntityReader, Ut as field, V as CollectionReader, Vt as VariantShape, W as FieldReader, Wt as list, X as DictSetOperation, Xt as single, Y as DictReplaceOperation, Yt as schema, Z as DocumentAnchor, Zt as table, _ as CommandFootprint, _t as DictNode, a as DocumentProblem, at as FieldSetOperation, b as decodeCommandFootprint, bt as DocumentNode, c as DocumentRuntime, ct as ListRemoveOperation, d as LocalHistory, dt as TreeMoveOperation, et as EntityCreateOperation, f as ObserverError, ft as TreeRemoveOperation, g as Unsubscribe, gt as CollectionSelector, h as TransactionResult, ht as VariantReplaceOperation, i as DocumentDisposedError, it as FieldClearOperation, j as MutationIssueCode, jt as ObjectShape, k as DocumentImpact, kt as MapNode, l as DocumentTransaction, lt as ListReplaceOperation, m as PreparedUpdateResult, mt as TreeSetOperation, n as DocumentCommit, nt as EntityMoveOperation, o as DocumentReadable, ot as ListInsertOperation, p as OperationResult, pt as TreeReplaceOperation, q as TreeReader, qt as optional, r as DocumentDiagnostic, rt as EntityRemoveOperation, s as DocumentReentrancyError, st as ListMoveOperation, t as CommitSource, tt as EntityEntry, u as HistoryState, ut as TreeInsertOperation, v as CommandFootprintTarget, vt as DocumentAddress, w as debugKey, wt as DocumentValueOfNode, x as footprintsOverlap, xt as DocumentSchema, y as commandFootprint, yt as DocumentListConfig, z as TreeWriter, zt as ValueSelector } from "./contract-D8kjdfqT.cjs";
+import { $ as EntityEntry, $t as tree, A as MutationIssue, At as MapNode, B as CollectionReader, Bt as ValueSelector, C as contains, Ct as DocumentTreeValue, D as resolveAddress, Dt as FieldNode, E as read, Et as EntitySchemaNode, F as FieldWriter, Ft as RecordNode, G as TreeReader, Gt as list, H as FieldReader, Ht as VariantShape, I as ListWriter, It as SchemaPath, J as DictSetOperation, Jt as optional, K as DictDeleteOperation, Kt as map, L as MapWriter, Lt as SingleNode, M as CollectionWriter, Mt as ObjectShape, N as DictionaryWriter, Nt as OptionalNode, O as CollectionImpact, Ot as ImpactTarget, P as DocumentWriter, Pt as ReadonlyDocument, Q as EntityCreateOperation, Qt as table, R as TreeWriter, Rt as TableNode, S as AddressRef, St as DocumentTreeNode, T as overlaps, Tt as DocumentValueOfShape, U as ListReader, Ut as dict, V as DocumentReader, Vt as VariantNode, W as ReaderOfNode, Wt as field, X as DocumentOperation, Xt as schema, Y as DocumentAnchor, Yt as record, Z as DocumentOperationUnion, Zt as single, _ as CommandFootprint, _t as DictNode, a as DocumentProblem, at as ListMoveOperation, b as decodeCommandFootprint, bt as DocumentNode, c as DocumentRuntime, ct as TreeInsertOperation, d as LocalHistory, dt as TreeReplaceOperation, en as variant, et as EntityMoveOperation, f as ObserverError, ft as TreeSetOperation, g as Unsubscribe, gt as CollectionSelector, h as TransactionResult, ht as CollectionNode, i as DocumentDisposedError, it as ListInsertOperation, j as MutationIssueCode, jt as ObjectNode, k as DocumentImpact, kt as ListNode, l as DocumentTransaction, lt as TreeMoveOperation, m as PreparedUpdateResult, mt as VariantReplaceOperation, n as DocumentCommit, nt as FieldClearOperation, o as DocumentReadable, ot as ListRemoveOperation, p as OperationResult, pt as ValueClearOperation, q as DictReplaceOperation, qt as object, r as DocumentDiagnostic, rt as FieldSetOperation, s as DocumentReentrancyError, st as ListReplaceOperation, t as CommitSource, tt as EntityRemoveOperation, u as HistoryState, ut as TreeRemoveOperation, v as CommandFootprintTarget, vt as DocumentAddress, w as debugKey, wt as DocumentValueOfNode, x as footprintsOverlap, xt as DocumentSchema, y as commandFootprint, yt as DocumentListConfig, z as WriterOfNode, zt as TreeNode } from "./contract-uYJTmT8o.cjs";
 
 //#region \0rolldown/runtime.js
 //#endregion
@@ -41,10 +41,10 @@ type CollectionView<TId extends string, TValue> = {
   revision(): number;
   dispose(): void;
 };
-declare const createCollectionView: <TSchema extends DocumentSchema, TId extends string, TEntry, TValue>(input: {
+declare const createCollectionView: <TSchema extends DocumentSchema, TId extends string, TNode extends EntitySchemaNode, TValue>(input: {
   readonly runtime: DocumentReadable<TSchema>;
-  readonly source: CollectionSelector<TId, TEntry>;
-  readonly map: (id: TId, entry: EntityReader<TEntry>) => TValue;
+  readonly source: CollectionSelector<TId, TNode>;
+  readonly map: (id: TId, entry: ReaderOfNode<TNode>) => TValue;
   readonly isEqual?: (previous: TValue, next: TValue) => boolean;
 }) => CollectionView<TId, TValue>;
 //#endregion
@@ -88,5 +88,5 @@ type MaterializedView<TValue, TChange = void> = Readable<TValue> & {
 };
 declare const createMaterializedView: <TSchema extends DocumentSchema, TValue, TChange = void, TSources extends MaterializedSources = {}>(runtime: DocumentReadable<TSchema>, spec: MaterializedViewSpec<TSchema, TValue, TChange, TSources>) => MaterializedView<TValue, TChange>;
 //#endregion
-export { type AddressRef, type CollectionImpact, type CollectionReader, type CollectionSelector, type CollectionView, type CollectionWriter, type CommandFootprint, type CommandFootprintTarget, type CommitSource, type DictDeleteOperation, type DictNode, type DictReplaceOperation, type DictSetOperation, type DictionaryWriter, type DocumentAddress, type DocumentAnchor, type DocumentCommit, type DocumentDiagnostic, DocumentDisposedError, type DocumentImpact, type DocumentListConfig, type DocumentNode, type DocumentOperation, type DocumentOperationUnion, type DocumentProblem, type DocumentReadable, type DocumentReader, DocumentReentrancyError, type DocumentRuntime, type DocumentSchema, type DocumentSelector, type DocumentTransaction, type DocumentTreeNode, type DocumentTreeValue, type DocumentValueOfNode, type DocumentValueOfShape, type DocumentWriter, type EntityCreateOperation, type EntityEntry, type EntityMoveOperation, type EntityReader, type EntityRemoveOperation, type EntityWriter, type FieldClearOperation, type FieldNode, type FieldReader, type FieldSetOperation, type FieldWriter, type HistoryState, type ImpactTarget, type ListInsertOperation, type ListMoveOperation, type ListNode, type ListReader, type ListRemoveOperation, type ListReplaceOperation, type ListWriter, type LocalHistory, type MapNode, type MapWriter, type MaterializedSource, type MaterializedSourceValues, type MaterializedSources, type MaterializedUpdateResult, type MaterializedView, type MaterializedViewSpec, type MaterializedViewUpdate, type MutationIssue, type MutationIssueCode, type ObjectNode, type ObjectShape, type ObserverError, type OperationResult, type OptionalNode, type PreparedUpdateResult, type Readable, type ReaderOfNode, type ReadonlyDocument, type RecordNode, type SchemaPath, type SingleNode, type TableNode, type TransactionResult, type TreeInsertOperation, type TreeMoveOperation, type TreeNode, type TreeReader, type TreeRemoveOperation, type TreeReplaceOperation, type TreeSetOperation, type TreeWriter, type Unsubscribe, type ValueSelector, type VariantNode, type VariantReplaceOperation, type VariantShape, type WriterOfNode, asReadable, commandFootprint, contains, createCollectionView, createDocument, createMaterializedView, debugKey, decodeCommandFootprint, dict, field, footprintsOverlap, list, map, object, optional, overlaps, read as readAddress, record, resolveAddress, schema, select, single, table, impact_target_d_exports as target, tree, variant };
+export { type AddressRef, type CollectionImpact, type CollectionNode, type CollectionReader, type CollectionSelector, type CollectionView, type CollectionWriter, type CommandFootprint, type CommandFootprintTarget, type CommitSource, type DictDeleteOperation, type DictNode, type DictReplaceOperation, type DictSetOperation, type DictionaryWriter, type DocumentAddress, type DocumentAnchor, type DocumentCommit, type DocumentDiagnostic, DocumentDisposedError, type DocumentImpact, type DocumentListConfig, type DocumentNode, type DocumentOperation, type DocumentOperationUnion, type DocumentProblem, type DocumentReadable, type DocumentReader, DocumentReentrancyError, type DocumentRuntime, type DocumentSchema, type DocumentSelector, type DocumentTransaction, type DocumentTreeNode, type DocumentTreeValue, type DocumentValueOfNode, type DocumentValueOfShape, type DocumentWriter, type EntityCreateOperation, type EntityEntry, type EntityMoveOperation, type EntityRemoveOperation, type EntitySchemaNode, type FieldClearOperation, type FieldNode, type FieldReader, type FieldSetOperation, type FieldWriter, type HistoryState, type ImpactTarget, type ListInsertOperation, type ListMoveOperation, type ListNode, type ListReader, type ListRemoveOperation, type ListReplaceOperation, type ListWriter, type LocalHistory, type MapNode, type MapWriter, type MaterializedSource, type MaterializedSourceValues, type MaterializedSources, type MaterializedUpdateResult, type MaterializedView, type MaterializedViewSpec, type MaterializedViewUpdate, type MutationIssue, type MutationIssueCode, type ObjectNode, type ObjectShape, type ObserverError, type OperationResult, type OptionalNode, type PreparedUpdateResult, type Readable, type ReaderOfNode, type ReadonlyDocument, type RecordNode, type SchemaPath, type SingleNode, type TableNode, type TransactionResult, type TreeInsertOperation, type TreeMoveOperation, type TreeNode, type TreeReader, type TreeRemoveOperation, type TreeReplaceOperation, type TreeSetOperation, type TreeWriter, type Unsubscribe, type ValueClearOperation, type ValueSelector, type VariantNode, type VariantReplaceOperation, type VariantShape, type WriterOfNode, asReadable, commandFootprint, contains, createCollectionView, createDocument, createMaterializedView, debugKey, decodeCommandFootprint, dict, field, footprintsOverlap, list, map, object, optional, overlaps, read as readAddress, record, resolveAddress, schema, select, single, table, impact_target_d_exports as target, tree, variant };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { $ as DocumentOperationUnion, $t as variant, A as MutationIssue, At as ObjectNode, B as WriterOfNode, Bt as VariantNode, C as contains, Ct as DocumentTreeValue, D as resolveAddress, Dt as ImpactTarget, E as read, Et as FieldNode, F as EntityWriter, Ft as SchemaPath, G as ListReader, Gt as map, H as DocumentReader, Ht as dict, I as FieldWriter, It as SingleNode, J as DictDeleteOperation, Jt as record, K as ReaderOfNode, Kt as object, L as ListWriter, Lt as TableNode, M as CollectionWriter, Mt as OptionalNode, N as DictionaryWriter, Nt as ReadonlyDocument, O as CollectionImpact, Ot as ListNode, P as DocumentWriter, Pt as RecordNode, Q as DocumentOperation, Qt as tree, R as MapWriter, Rt as TreeNode, S as AddressRef, St as DocumentTreeNode, T as overlaps, Tt as DocumentValueOfShape, U as EntityReader, Ut as field, V as CollectionReader, Vt as VariantShape, W as FieldReader, Wt as list, X as DictSetOperation, Xt as single, Y as DictReplaceOperation, Yt as schema, Z as DocumentAnchor, Zt as table, _ as CommandFootprint, _t as DictNode, a as DocumentProblem, at as FieldSetOperation, b as decodeCommandFootprint, bt as DocumentNode, c as DocumentRuntime, ct as ListRemoveOperation, d as LocalHistory, dt as TreeMoveOperation, et as EntityCreateOperation, f as ObserverError, ft as TreeRemoveOperation, g as Unsubscribe, gt as CollectionSelector, h as TransactionResult, ht as VariantReplaceOperation, i as DocumentDisposedError, it as FieldClearOperation, j as MutationIssueCode, jt as ObjectShape, k as DocumentImpact, kt as MapNode, l as DocumentTransaction, lt as ListReplaceOperation, m as PreparedUpdateResult, mt as TreeSetOperation, n as DocumentCommit, nt as EntityMoveOperation, o as DocumentReadable, ot as ListInsertOperation, p as OperationResult, pt as TreeReplaceOperation, q as TreeReader, qt as optional, r as DocumentDiagnostic, rt as EntityRemoveOperation, s as DocumentReentrancyError, st as ListMoveOperation, t as CommitSource, tt as EntityEntry, u as HistoryState, ut as TreeInsertOperation, v as CommandFootprintTarget, vt as DocumentAddress, w as debugKey, wt as DocumentValueOfNode, x as footprintsOverlap, xt as DocumentSchema, y as commandFootprint, yt as DocumentListConfig, z as TreeWriter, zt as ValueSelector } from "./contract-BsY1XLiG.js";
+import { $ as EntityEntry, $t as tree, A as MutationIssue, At as MapNode, B as CollectionReader, Bt as ValueSelector, C as contains, Ct as DocumentTreeValue, D as resolveAddress, Dt as FieldNode, E as read, Et as EntitySchemaNode, F as FieldWriter, Ft as RecordNode, G as TreeReader, Gt as list, H as FieldReader, Ht as VariantShape, I as ListWriter, It as SchemaPath, J as DictSetOperation, Jt as optional, K as DictDeleteOperation, Kt as map, L as MapWriter, Lt as SingleNode, M as CollectionWriter, Mt as ObjectShape, N as DictionaryWriter, Nt as OptionalNode, O as CollectionImpact, Ot as ImpactTarget, P as DocumentWriter, Pt as ReadonlyDocument, Q as EntityCreateOperation, Qt as table, R as TreeWriter, Rt as TableNode, S as AddressRef, St as DocumentTreeNode, T as overlaps, Tt as DocumentValueOfShape, U as ListReader, Ut as dict, V as DocumentReader, Vt as VariantNode, W as ReaderOfNode, Wt as field, X as DocumentOperation, Xt as schema, Y as DocumentAnchor, Yt as record, Z as DocumentOperationUnion, Zt as single, _ as CommandFootprint, _t as DictNode, a as DocumentProblem, at as ListMoveOperation, b as decodeCommandFootprint, bt as DocumentNode, c as DocumentRuntime, ct as TreeInsertOperation, d as LocalHistory, dt as TreeReplaceOperation, en as variant, et as EntityMoveOperation, f as ObserverError, ft as TreeSetOperation, g as Unsubscribe, gt as CollectionSelector, h as TransactionResult, ht as CollectionNode, i as DocumentDisposedError, it as ListInsertOperation, j as MutationIssueCode, jt as ObjectNode, k as DocumentImpact, kt as ListNode, l as DocumentTransaction, lt as TreeMoveOperation, m as PreparedUpdateResult, mt as VariantReplaceOperation, n as DocumentCommit, nt as FieldClearOperation, o as DocumentReadable, ot as ListRemoveOperation, p as OperationResult, pt as ValueClearOperation, q as DictReplaceOperation, qt as object, r as DocumentDiagnostic, rt as FieldSetOperation, s as DocumentReentrancyError, st as ListReplaceOperation, t as CommitSource, tt as EntityRemoveOperation, u as HistoryState, ut as TreeRemoveOperation, v as CommandFootprintTarget, vt as DocumentAddress, w as debugKey, wt as DocumentValueOfNode, x as footprintsOverlap, xt as DocumentSchema, y as commandFootprint, yt as DocumentListConfig, z as WriterOfNode, zt as TreeNode } from "./contract-4E3moCbY.js";
 
 //#region core/src/runtime.d.ts
 declare const createDocument: <TSchema extends DocumentSchema>(input: {
@@ -39,10 +39,10 @@ type CollectionView<TId extends string, TValue> = {
   revision(): number;
   dispose(): void;
 };
-declare const createCollectionView: <TSchema extends DocumentSchema, TId extends string, TEntry, TValue>(input: {
+declare const createCollectionView: <TSchema extends DocumentSchema, TId extends string, TNode extends EntitySchemaNode, TValue>(input: {
   readonly runtime: DocumentReadable<TSchema>;
-  readonly source: CollectionSelector<TId, TEntry>;
-  readonly map: (id: TId, entry: EntityReader<TEntry>) => TValue;
+  readonly source: CollectionSelector<TId, TNode>;
+  readonly map: (id: TId, entry: ReaderOfNode<TNode>) => TValue;
   readonly isEqual?: (previous: TValue, next: TValue) => boolean;
 }) => CollectionView<TId, TValue>;
 //#endregion
@@ -86,5 +86,5 @@ type MaterializedView<TValue, TChange = void> = Readable<TValue> & {
 };
 declare const createMaterializedView: <TSchema extends DocumentSchema, TValue, TChange = void, TSources extends MaterializedSources = {}>(runtime: DocumentReadable<TSchema>, spec: MaterializedViewSpec<TSchema, TValue, TChange, TSources>) => MaterializedView<TValue, TChange>;
 //#endregion
-export { type AddressRef, type CollectionImpact, type CollectionReader, type CollectionSelector, type CollectionView, type CollectionWriter, type CommandFootprint, type CommandFootprintTarget, type CommitSource, type DictDeleteOperation, type DictNode, type DictReplaceOperation, type DictSetOperation, type DictionaryWriter, type DocumentAddress, type DocumentAnchor, type DocumentCommit, type DocumentDiagnostic, DocumentDisposedError, type DocumentImpact, type DocumentListConfig, type DocumentNode, type DocumentOperation, type DocumentOperationUnion, type DocumentProblem, type DocumentReadable, type DocumentReader, DocumentReentrancyError, type DocumentRuntime, type DocumentSchema, type DocumentSelector, type DocumentTransaction, type DocumentTreeNode, type DocumentTreeValue, type DocumentValueOfNode, type DocumentValueOfShape, type DocumentWriter, type EntityCreateOperation, type EntityEntry, type EntityMoveOperation, type EntityReader, type EntityRemoveOperation, type EntityWriter, type FieldClearOperation, type FieldNode, type FieldReader, type FieldSetOperation, type FieldWriter, type HistoryState, type ImpactTarget, type ListInsertOperation, type ListMoveOperation, type ListNode, type ListReader, type ListRemoveOperation, type ListReplaceOperation, type ListWriter, type LocalHistory, type MapNode, type MapWriter, type MaterializedSource, type MaterializedSourceValues, type MaterializedSources, type MaterializedUpdateResult, type MaterializedView, type MaterializedViewSpec, type MaterializedViewUpdate, type MutationIssue, type MutationIssueCode, type ObjectNode, type ObjectShape, type ObserverError, type OperationResult, type OptionalNode, type PreparedUpdateResult, type Readable, type ReaderOfNode, type ReadonlyDocument, type RecordNode, type SchemaPath, type SingleNode, type TableNode, type TransactionResult, type TreeInsertOperation, type TreeMoveOperation, type TreeNode, type TreeReader, type TreeRemoveOperation, type TreeReplaceOperation, type TreeSetOperation, type TreeWriter, type Unsubscribe, type ValueSelector, type VariantNode, type VariantReplaceOperation, type VariantShape, type WriterOfNode, asReadable, commandFootprint, contains, createCollectionView, createDocument, createMaterializedView, debugKey, decodeCommandFootprint, dict, field, footprintsOverlap, list, map, object, optional, overlaps, read as readAddress, record, resolveAddress, schema, select, single, table, impact_target_d_exports as target, tree, variant };
+export { type AddressRef, type CollectionImpact, type CollectionNode, type CollectionReader, type CollectionSelector, type CollectionView, type CollectionWriter, type CommandFootprint, type CommandFootprintTarget, type CommitSource, type DictDeleteOperation, type DictNode, type DictReplaceOperation, type DictSetOperation, type DictionaryWriter, type DocumentAddress, type DocumentAnchor, type DocumentCommit, type DocumentDiagnostic, DocumentDisposedError, type DocumentImpact, type DocumentListConfig, type DocumentNode, type DocumentOperation, type DocumentOperationUnion, type DocumentProblem, type DocumentReadable, type DocumentReader, DocumentReentrancyError, type DocumentRuntime, type DocumentSchema, type DocumentSelector, type DocumentTransaction, type DocumentTreeNode, type DocumentTreeValue, type DocumentValueOfNode, type DocumentValueOfShape, type DocumentWriter, type EntityCreateOperation, type EntityEntry, type EntityMoveOperation, type EntityRemoveOperation, type EntitySchemaNode, type FieldClearOperation, type FieldNode, type FieldReader, type FieldSetOperation, type FieldWriter, type HistoryState, type ImpactTarget, type ListInsertOperation, type ListMoveOperation, type ListNode, type ListReader, type ListRemoveOperation, type ListReplaceOperation, type ListWriter, type LocalHistory, type MapNode, type MapWriter, type MaterializedSource, type MaterializedSourceValues, type MaterializedSources, type MaterializedUpdateResult, type MaterializedView, type MaterializedViewSpec, type MaterializedViewUpdate, type MutationIssue, type MutationIssueCode, type ObjectNode, type ObjectShape, type ObserverError, type OperationResult, type OptionalNode, type PreparedUpdateResult, type Readable, type ReaderOfNode, type ReadonlyDocument, type RecordNode, type SchemaPath, type SingleNode, type TableNode, type TransactionResult, type TreeInsertOperation, type TreeMoveOperation, type TreeNode, type TreeReader, type TreeRemoveOperation, type TreeReplaceOperation, type TreeSetOperation, type TreeWriter, type Unsubscribe, type ValueClearOperation, type ValueSelector, type VariantNode, type VariantReplaceOperation, type VariantShape, type WriterOfNode, asReadable, commandFootprint, contains, createCollectionView, createDocument, createMaterializedView, debugKey, decodeCommandFootprint, dict, field, footprintsOverlap, list, map, object, optional, overlaps, read as readAddress, record, resolveAddress, schema, select, single, table, impact_target_d_exports as target, tree, variant };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -195,7 +195,11 @@ const writerFor = (node, inputAddress, sink) => {
 			type: "dict.replace",
 			at: address,
 			value
-		})
+		}),
+		...node.optional ? { clear: () => emit(sink, {
+			type: "value.clear",
+			at: address
+		}) } : {}
 	};
 	if (node.kind === "list") return {
 		insert: (value, anchor) => emit(sink, {
@@ -221,7 +225,11 @@ const writerFor = (node, inputAddress, sink) => {
 			at: address,
 			value,
 			keys: value.map(node.keyOf)
-		})
+		}),
+		...node.optional ? { clear: () => emit(sink, {
+			type: "value.clear",
+			at: address
+		}) } : {}
 	};
 	if (node.kind === "tree") return {
 		insert: (treeNodeId, value, parentId, index) => emit(sink, {
@@ -254,7 +262,11 @@ const writerFor = (node, inputAddress, sink) => {
 			type: "tree.replace",
 			at: address,
 			value
-		})
+		}),
+		...node.optional ? { clear: () => emit(sink, {
+			type: "value.clear",
+			at: address
+		}) } : {}
 	};
 	if (node.kind === "table") {
 		let items;
@@ -318,11 +330,17 @@ const writerFor = (node, inputAddress, sink) => {
 		};
 	}
 	if (node.kind === "single") return writerFor(node.value, address, sink);
-	if (node.kind === "variant") return { replace: (value) => emit(sink, {
-		type: "variant.replace",
-		at: address,
-		value
-	}) };
+	if (node.kind === "variant") return {
+		replace: (value) => emit(sink, {
+			type: "variant.replace",
+			at: address,
+			value
+		}),
+		...node.optional ? { clear: () => emit(sink, {
+			type: "value.clear",
+			at: address
+		}) } : {}
+	};
 	let children;
 	return new Proxy({}, { get: (_target, property) => {
 		if (typeof property !== "string" || !node.shape[property]) return void 0;
@@ -540,8 +558,11 @@ const rejected$3 = (operation, code, message) => ({
 	issue: from(operation, code, message)
 });
 const executeList = (target, operation, copyPayload) => {
-	if (!Array.isArray(target.value) || target.node.kind !== "list") return rejected$3(operation, "invalid-address", "List target is invalid.");
-	const list = target.value;
+	if (target.node.kind !== "list") return rejected$3(operation, "invalid-address", "List target is invalid.");
+	const absent = target.value === void 0 && "optional" in target.node && target.node.optional === true;
+	if (!Array.isArray(target.value) && !absent) return rejected$3(operation, "invalid-address", "List target is invalid.");
+	if (absent && operation.type !== "list.replace") return rejected$3(operation, "invalid-address", "Only list replacement can initialize an optional list.");
+	const list = Array.isArray(target.value) ? target.value : [];
 	const orderedKeys = keys(list, target.node.keyOf);
 	const own = (value) => copyPayload ? ownPayload(value) : value;
 	if (operation.type === "list.replace") {
@@ -552,18 +573,23 @@ const executeList = (target, operation, copyPayload) => {
 			if (seen.has(key) || target.node.keyOf(operation.value[index]) !== key) return rejected$3(operation, "invalid-list-keys", "List replacement keys are invalid.");
 			seen.add(key);
 		}
-		if (sameStructuralValue(list, operation.value)) return { status: "unchanged" };
-		const keys = new Array(list.length);
-		for (let index = 0; index < list.length; index += 1) keys[index] = target.node.keyOf(list[index]);
-		const inverse = {
+		if (!absent && sameStructuralValue(list, operation.value)) return { status: "unchanged" };
+		const keys = list.map(target.node.keyOf);
+		const inverse = absent ? {
+			type: "value.clear",
+			at: operation.at
+		} : {
 			type: "list.replace",
 			at: operation.at,
 			value: cloneValue(list, "inverse"),
 			keys
 		};
 		const owned = own(operation.value);
-		list.length = owned.length;
-		for (let index = 0; index < owned.length; index += 1) list[index] = owned[index];
+		if (absent) target.parent[target.key] = owned;
+		else {
+			list.length = owned.length;
+			for (let index = 0; index < owned.length; index += 1) list[index] = owned[index];
+		}
 		return {
 			status: "changed",
 			inverse: [inverse]
@@ -1023,16 +1049,39 @@ const outcome = (operation, value) => value.status === "rejected" ? {
 	issue: from(operation, value.code, value.message)
 } : value;
 const executeTree = (root, target, operation, copyPayload) => {
-	if (!is(target.value)) return {
+	if (target.node.kind !== "tree") return {
 		status: "rejected",
 		issue: from(operation, "invalid-address", "Tree target is invalid.")
 	};
 	const own = (value) => copyPayload ? ownPayload(value) : value;
+	const absent = target.value === void 0 && "optional" in target.node && target.node.optional === true;
 	if (operation.type === "tree.replace") {
+		if (absent) {
+			if (!validate(operation.value)) return {
+				status: "rejected",
+				issue: from(operation, "invalid-tree", "Tree replacement is malformed.")
+			};
+			target.parent[target.key] = own(operation.value);
+			return {
+				status: "changed",
+				inverse: [{
+					type: "value.clear",
+					at: operation.at
+				}]
+			};
+		}
+		if (!is(target.value)) return {
+			status: "rejected",
+			issue: from(operation, "invalid-address", "Tree target is invalid.")
+		};
 		const result = replace(target.value, operation);
 		if (result.status === "changed") set$1(root, operation.at, ownPayload(operation.value));
 		return outcome(operation, result);
 	}
+	if (!is(target.value)) return {
+		status: "rejected",
+		issue: from(operation, "invalid-address", "Tree target is invalid.")
+	};
 	if (operation.type === "tree.insert") return outcome(operation, insert(target.value, operation, own(operation.value)));
 	if (operation.type === "tree.set") return outcome(operation, set(target.value, operation, own(operation.value)));
 	if (operation.type === "tree.remove") return outcome(operation, remove(target.value, operation));
@@ -1090,6 +1139,18 @@ const executeValue = (target, operation, copyPayload) => {
 			inverse: [inverse]
 		};
 	}
+	if (operation.type === "dict.replace" && target.value === void 0) {
+		if (!("optional" in target.node) || !target.node.optional) return rejected$1(operation, "invalid-address", "Dictionary target is invalid.");
+		const inverse = {
+			type: "value.clear",
+			at: operation.at
+		};
+		target.parent[target.key] = own(operation.value);
+		return {
+			status: "changed",
+			inverse: [inverse]
+		};
+	}
 	if (!isRecord(target.value)) return rejected$1(operation, "invalid-address", "Dictionary target is invalid.");
 	if (operation.type === "dict.replace") {
 		if (sameStructuralValue(target.value, operation.value)) return { status: "unchanged" };
@@ -1138,11 +1199,67 @@ const executeValue = (target, operation, copyPayload) => {
 };
 //#endregion
 //#region core/src/mutation/execute.ts
+const hasOwn$1 = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+const executeClear = (target, operation) => {
+	if (!("optional" in target.node) || !target.node.optional) return {
+		status: "rejected",
+		issue: from(operation, "required-field", "Only optional values can be cleared.")
+	};
+	if (!hasOwn$1(target.parent, target.key)) return { status: "unchanged" };
+	if (target.node.kind !== "field" && target.node.kind !== "variant" && target.node.kind !== "dict" && target.node.kind !== "record" && target.node.kind !== "list" && target.node.kind !== "tree") return {
+		status: "rejected",
+		issue: from(operation, "invalid-operation", "This optional value has no clear operation.")
+	};
+	const inverse = (() => {
+		switch (target.node.kind) {
+			case "field": return {
+				type: "field.set",
+				at: operation.at,
+				value: target.value
+			};
+			case "variant": return {
+				type: "variant.replace",
+				at: operation.at,
+				value: cloneValue(target.value, "inverse")
+			};
+			case "dict":
+			case "record": return {
+				type: "dict.replace",
+				at: operation.at,
+				value: cloneValue(target.value, "inverse")
+			};
+			case "list":
+				if (!Array.isArray(target.value)) return {
+					type: "list.replace",
+					at: operation.at,
+					value: [],
+					keys: []
+				};
+				return {
+					type: "list.replace",
+					at: operation.at,
+					value: cloneValue(target.value, "inverse"),
+					keys: target.value.map(target.node.keyOf)
+				};
+			case "tree": return {
+				type: "tree.replace",
+				at: operation.at,
+				value: cloneValue(target.value, "inverse")
+			};
+		}
+	})();
+	delete target.parent[target.key];
+	return {
+		status: "changed",
+		inverse: [inverse]
+	};
+};
 const invalidTarget = (operation) => ({
 	status: "rejected",
 	issue: from(operation, "invalid-address", `Operation '${operation.type}' does not match the schema address.`)
 });
 const execute = (root, operation, target, copyPayload) => {
+	if (operation.type === "value.clear") return !target ? invalidTarget(operation) : executeClear(target, operation);
 	if (operation.type === "field.set" || operation.type === "field.clear") return !target || target.node.kind !== "field" ? invalidTarget(operation) : executeValue(target, operation, copyPayload);
 	if (operation.type === "variant.replace") return !target || target.node.kind !== "variant" ? invalidTarget(operation) : executeValue(target, operation, copyPayload);
 	if (operation.type === "dict.set" || operation.type === "dict.delete" || operation.type === "dict.replace") return !target || target.node.kind !== "dict" && target.node.kind !== "record" ? invalidTarget(operation) : executeValue(target, operation, copyPayload);
@@ -1532,11 +1649,12 @@ const createChangeJournal = (root) => {
 	const recordValue = (resolved, operation, inverse) => {
 		if (find("value", operation.at, resolved.addressHash)) return;
 		const first = inverse[0];
-		if (first?.type !== "field.set" && first?.type !== "field.clear") return inverseMismatch(operation);
+		if (first?.type !== "field.set" && first?.type !== "field.clear" && first?.type !== "value.clear" && !("value" in (first ?? {}))) return inverseMismatch(operation);
+		const before = first.type === "field.clear" || first.type === "value.clear" ? absent : "value" in first ? present(first.value) : inverseMismatch(operation);
 		add({
 			...base(resolved, operation),
 			kind: "value",
-			before: first.type === "field.set" ? present(first.value) : absent
+			before
 		});
 	};
 	const recordVariant = (resolved, operation, inverse) => {
@@ -1579,6 +1697,18 @@ const createChangeJournal = (root) => {
 		if (!first) return inverseMismatch(operation);
 		let subject = find("list", operation.at, resolved.addressHash);
 		if (!subject) {
+			if (first.type === "value.clear") {
+				add({
+					...base(resolved, operation),
+					kind: "list",
+					node: resolved.node,
+					state: {
+						mode: "whole",
+						value: void 0
+					}
+				});
+				return;
+			}
 			if (first.type === "list.replace") {
 				add({
 					...base(resolved, operation),
@@ -1666,6 +1796,22 @@ const createChangeJournal = (root) => {
 	};
 	const recordTree = (resolved, operation, inverse) => {
 		const current = read(root, operation.at);
+		if (inverse.length === 1 && inverse[0].type === "value.clear" && operation.type === "tree.replace") {
+			const subject = find("tree", operation.at, resolved.addressHash);
+			if (subject) subject.state = {
+				mode: "whole",
+				value: void 0
+			};
+			else add({
+				...base(resolved, operation),
+				kind: "tree",
+				state: {
+					mode: "whole",
+					value: void 0
+				}
+			});
+			return;
+		}
 		if (!is(current)) return inverseMismatch(operation);
 		const inverses = inverse.filter(treeOperation);
 		if (inverses.length === 0 || inverses.length !== inverse.length) return inverseMismatch(operation);
@@ -1682,7 +1828,7 @@ const createChangeJournal = (root) => {
 		record: (resolved, operation, inverse) => {
 			profile.batch.journalRecord();
 			if (ownerOf(operation.at)) return;
-			if (operation.type === "field.set" || operation.type === "field.clear") {
+			if (operation.type === "field.set" || operation.type === "field.clear" || operation.type === "value.clear") {
 				recordValue(resolved, operation, inverse);
 				return;
 			}
@@ -1691,7 +1837,8 @@ const createChangeJournal = (root) => {
 				return;
 			}
 			if (operation.type === "dict.set" || operation.type === "dict.delete" || operation.type === "dict.replace") {
-				recordDict(resolved, operation, inverse);
+				if (operation.type === "dict.replace" && inverse[0]?.type === "value.clear") recordValue(resolved, operation, inverse);
+				else recordDict(resolved, operation, inverse);
 				return;
 			}
 			if (operation.type === "entity.create" || operation.type === "entity.remove" || operation.type === "entity.move") {
@@ -1792,7 +1939,8 @@ const decode = (input) => {
 	switch (input.type) {
 		case "field.set":
 		case "variant.replace": return has(input, "value") ? decoded(input) : rejected("invalid-operation", "Operation value is required.");
-		case "field.clear": return decoded(input);
+		case "field.clear":
+		case "value.clear": return decoded(input);
 		case "dict.set": return typeof input.key === "string" && has(input, "value") ? decoded(input) : rejected("invalid-operation", "Dictionary set requires a string key and value.");
 		case "dict.delete": return typeof input.key === "string" ? decoded(input) : rejected("invalid-operation", "Dictionary delete requires a string key.");
 		case "dict.replace": return isRecord(input.value) ? decoded(input) : rejected("invalid-operation", "Dictionary replacement must be an object.");
@@ -1985,6 +2133,7 @@ const commandFootprint = (operations) => {
 	for (const operation of operations) switch (operation.type) {
 		case "field.set":
 		case "field.clear":
+		case "value.clear":
 		case "variant.replace":
 			add(targets, {
 				kind: "value",