doxum 0.1.40 → 0.1.42

package/dist/local-sync.d.ts

@@ -1,4 +1,4 @@
-import { W as ObjectSchema, g as Readable, s as DocumentRuntime } from "./contract-COgxO5sv.js";
+import { W as ObjectSchema, g as Readable, s as DocumentRuntime } from "./contract-PqdXNaP8.js";
 
 //#region core/src/local-sync/json.d.ts
 type JsonPrimitive = null | boolean | number | string;

package/dist/local-sync.js

@@ -1,5 +1,5 @@
 import { n as isPlainObject, r as isRecord } from "./record-B2yRhYsc.js";
-import { a as changeCount, n as installRuntimeWriteDriver, o as decodeChanges } from "./driver-B7RR-VfX.js";
+import { a as changeCount, c as addListener, n as installRuntimeWriteDriver, o as decodeChanges } from "./driver-B7Hu6D0u.js";
 //#region core/src/local-sync/error.ts
 var LocalSyncError = class extends Error {
 	code;
@@ -466,10 +466,7 @@ const attachLocalSync = async (input) => {
 				revision: () => stateRevision,
 				subscribe: (listener) => {
 					if (disposed) throw new LocalSyncError("disposed", "Local sync has been disposed.");
-					stateListeners.add(listener);
-					return () => {
-						stateListeners.delete(listener);
-					};
+					return addListener(stateListeners, listener);
 				}
 			}),
 			flush: async () => {

package/dist/react.cjs

@@ -1,9 +1,43 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-let doxum = require("doxum");
 let react = require("react");
-//#region react/src/hooks.ts
+let doxum = require("doxum");
+//#region react/src/projection.ts
 const ProjectionContext = (0, react.createContext)(void 0);
-const ProjectionProvider = ProjectionContext.Provider;
+const ManagedProjectionProvider = ({ runtime, fallback, children }) => {
+	const generation = (0, react.useRef)(0);
+	const [owner, setOwner] = (0, react.useState)();
+	(0, react.useEffect)(() => {
+		const scope = runtime.scope();
+		setOwner({
+			runtime,
+			scope,
+			generation: ++generation.current
+		});
+		return () => scope.dispose();
+	}, [runtime]);
+	if (!owner || owner.runtime !== runtime) return fallback ?? null;
+	return (0, react.createElement)(ProjectionContext.Provider, {
+		value: owner.scope,
+		key: owner.generation
+	}, children);
+};
+/** runtime creates an owned scope after commit; value borrows an external owner. */
+const ProjectionProvider = (props) => {
+	if (props.runtime !== void 0) {
+		if (props.value !== void 0) throw new TypeError("ProjectionProvider accepts runtime or value, not both.");
+		return (0, react.createElement)(ManagedProjectionProvider, props);
+	}
+	if (props.value === void 0) throw new TypeError("ProjectionProvider requires runtime or value.");
+	return (0, react.createElement)(ProjectionContext.Provider, { value: props.value }, props.children);
+};
+/** Reads a scope supplied by a managed Provider or an explicitly injected scope. */
+const useProjectionScope = () => {
+	const owner = (0, react.useContext)(ProjectionContext);
+	if (!owner || !("own" in owner)) throw new Error("A ProjectionScope provider is required.");
+	return owner;
+};
+//#endregion
+//#region react/src/hooks.ts
 function useProjection(projection, selector, equality = Object.is) {
 	const owner = (0, react.useContext)(ProjectionContext);
 	if (!owner) throw new Error("ProjectionRuntime is required.");
@@ -56,4 +90,5 @@ exports.useDocumentSelector = useDocumentSelector;
 exports.useHistory = useHistory;
 exports.useInput = useInput;
 exports.useProjection = useProjection;
+exports.useProjectionScope = useProjectionScope;
 exports.useReadable = useReadable;

package/dist/react.d.cts

@@ -1,8 +1,7 @@
-import * as _$react from "react";
 import { CollectionInput, CollectionInputDraft, DocumentSelector, HistoryState, Input, LocalHistory, ObjectSchema, OperationResult, Projection, ProjectionRuntime, ProjectionScope, Readable, ReadonlyDocument } from "doxum";
+import { ReactElement, ReactNode } from "react";
 
 //#region react/src/hooks.d.ts
-declare const ProjectionProvider: _$react.Provider<ProjectionRuntime | ProjectionScope | undefined>;
 declare function useProjection<T>(projection: Projection<T>): T;
 declare function useProjection<T, R>(projection: Projection<T>, selector: (value: T) => R, equality?: (previous: R, next: R) => boolean): R;
 declare function useInput<T>(input: Input<T>): readonly [T, (value: T) => void];
@@ -14,4 +13,21 @@ declare function useHistory<TCommit>(history: LocalHistory<TCommit>): HistorySta
   redo(): OperationResult<TCommit>;
 };
 //#endregion
-export { ProjectionProvider, useDocumentSelector, useHistory, useInput, useProjection, useReadable };
+//#region react/src/projection.d.ts
+type ProjectionProviderProps = {
+  readonly children?: ReactNode;
+} & ({
+  readonly runtime: ProjectionRuntime;
+  readonly fallback?: ReactNode;
+  readonly value?: never;
+} | {
+  readonly value: ProjectionRuntime | ProjectionScope;
+  readonly runtime?: never;
+  readonly fallback?: never;
+});
+/** runtime creates an owned scope after commit; value borrows an external owner. */
+declare const ProjectionProvider: (props: ProjectionProviderProps) => ReactElement;
+/** Reads a scope supplied by a managed Provider or an explicitly injected scope. */
+declare const useProjectionScope: () => ProjectionScope;
+//#endregion
+export { ProjectionProvider, type ProjectionProviderProps, useDocumentSelector, useHistory, useInput, useProjection, useProjectionScope, useReadable };

package/dist/react.d.ts

@@ -1,8 +1,7 @@
+import { ReactElement, ReactNode } from "react";
 import { CollectionInput, CollectionInputDraft, DocumentSelector, HistoryState, Input, LocalHistory, ObjectSchema, OperationResult, Projection, ProjectionRuntime, ProjectionScope, Readable, ReadonlyDocument } from "doxum";
-import * as _$react from "react";
 
 //#region react/src/hooks.d.ts
-declare const ProjectionProvider: _$react.Provider<ProjectionRuntime | ProjectionScope | undefined>;
 declare function useProjection<T>(projection: Projection<T>): T;
 declare function useProjection<T, R>(projection: Projection<T>, selector: (value: T) => R, equality?: (previous: R, next: R) => boolean): R;
 declare function useInput<T>(input: Input<T>): readonly [T, (value: T) => void];
@@ -14,4 +13,21 @@ declare function useHistory<TCommit>(history: LocalHistory<TCommit>): HistorySta
   redo(): OperationResult<TCommit>;
 };
 //#endregion
-export { ProjectionProvider, useDocumentSelector, useHistory, useInput, useProjection, useReadable };
+//#region react/src/projection.d.ts
+type ProjectionProviderProps = {
+  readonly children?: ReactNode;
+} & ({
+  readonly runtime: ProjectionRuntime;
+  readonly fallback?: ReactNode;
+  readonly value?: never;
+} | {
+  readonly value: ProjectionRuntime | ProjectionScope;
+  readonly runtime?: never;
+  readonly fallback?: never;
+});
+/** runtime creates an owned scope after commit; value borrows an external owner. */
+declare const ProjectionProvider: (props: ProjectionProviderProps) => ReactElement;
+/** Reads a scope supplied by a managed Provider or an explicitly injected scope. */
+declare const useProjectionScope: () => ProjectionScope;
+//#endregion
+export { ProjectionProvider, type ProjectionProviderProps, useDocumentSelector, useHistory, useInput, useProjection, useProjectionScope, useReadable };

package/dist/react.js

@@ -1,8 +1,42 @@
+import { createContext, createElement, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import { select } from "doxum";
-import { createContext, useCallback, useContext, useMemo, useSyncExternalStore } from "react";
-//#region react/src/hooks.ts
+//#region react/src/projection.ts
 const ProjectionContext = createContext(void 0);
-const ProjectionProvider = ProjectionContext.Provider;
+const ManagedProjectionProvider = ({ runtime, fallback, children }) => {
+	const generation = useRef(0);
+	const [owner, setOwner] = useState();
+	useEffect(() => {
+		const scope = runtime.scope();
+		setOwner({
+			runtime,
+			scope,
+			generation: ++generation.current
+		});
+		return () => scope.dispose();
+	}, [runtime]);
+	if (!owner || owner.runtime !== runtime) return fallback ?? null;
+	return createElement(ProjectionContext.Provider, {
+		value: owner.scope,
+		key: owner.generation
+	}, children);
+};
+/** runtime creates an owned scope after commit; value borrows an external owner. */
+const ProjectionProvider = (props) => {
+	if (props.runtime !== void 0) {
+		if (props.value !== void 0) throw new TypeError("ProjectionProvider accepts runtime or value, not both.");
+		return createElement(ManagedProjectionProvider, props);
+	}
+	if (props.value === void 0) throw new TypeError("ProjectionProvider requires runtime or value.");
+	return createElement(ProjectionContext.Provider, { value: props.value }, props.children);
+};
+/** Reads a scope supplied by a managed Provider or an explicitly injected scope. */
+const useProjectionScope = () => {
+	const owner = useContext(ProjectionContext);
+	if (!owner || !("own" in owner)) throw new Error("A ProjectionScope provider is required.");
+	return owner;
+};
+//#endregion
+//#region react/src/hooks.ts
 function useProjection(projection, selector, equality = Object.is) {
 	const owner = useContext(ProjectionContext);
 	if (!owner) throw new Error("ProjectionRuntime is required.");
@@ -50,4 +84,4 @@ function useHistory(history) {
 	]);
 }
 //#endregion
-export { ProjectionProvider, useDocumentSelector, useHistory, useInput, useProjection, useReadable };
+export { ProjectionProvider, useDocumentSelector, useHistory, useInput, useProjection, useProjectionScope, useReadable };

package/dist/{transform-8xXf0OKB.cjs → transform-BPh55GWO.cjs}

@@ -29,6 +29,8 @@ const profile = {
 		segmentCompared: () => {}
 	},
 	collectionIndex: {
+		batch: (sortedKeys) => {},
+		visit: () => {},
 		node: () => {},
 		build: (items) => {}
 	},
@@ -259,7 +261,8 @@ var ProjectionDisposedError = class extends Error {
 //#endregion
 //#region core/src/projection/graph/scheduler.ts
 const createScheduler = (onError) => {
-	let disposed = false;
+	let lifecycle = "active";
+	let lockDepth = 0;
 	let depth = 0;
 	let batchSequence = 0;
 	let activeBatch;
@@ -277,13 +280,39 @@ const createScheduler = (onError) => {
 	let reportingFailures = [];
 	const guards = /* @__PURE__ */ new Set();
 	const assertActive = () => {
-		if (disposed) throw new ProjectionDisposedError();
+		if (lifecycle === "disposed" || phase === "release") throw new ProjectionDisposedError();
 	};
 	const assertIdle = () => {
 		assertActive();
-		if (phase !== "idle") throw new Error("Projection cannot be re-entered during input callbacks, processing or notification.");
+		if (phase !== "idle" && phase !== "cleanup") throw new Error("Projection cannot be re-entered during input callbacks, processing or notification.");
+	};
+	const assertCommand = () => {
+		assertActive();
+		if (lifecycle === "closing" || phase === "cleanup") throw new Error("Projection cleanup only permits reads and unsubscribe.");
+		assertIdle();
+	};
+	const lock = (value) => {
+		const previous = lockDepth;
+		lockDepth += value ? 1 : -1;
+		if (!previous || !lockDepth) guards.forEach((guard) => guard(value));
+	};
+	const beginClose = () => {
+		if (lifecycle !== "active") return false;
+		assertCommand();
+		lifecycle = "closing";
+		return true;
+	};
+	const withPhase = (next, run) => {
+		const previous = phase;
+		phase = next;
+		lock(true);
+		try {
+			return run();
+		} finally {
+			lock(false);
+			phase = previous;
+		}
 	};
-	const lock = (value) => guards.forEach((guard) => guard(value));
 	const markDirty = (producer) => {
 		const pending = [producer];
 		for (let index = 0; index < pending.length; index++) {
@@ -300,7 +329,7 @@ const createScheduler = (onError) => {
 	};
 	const errorFor = (producer, cause, kind = producer.kind === "source" ? "source" : "processor") => new ProjectionError(kind, cause);
 	const capture = (source) => {
-		if (disposed) return;
+		if (lifecycle === "disposed") return;
 		if (phase !== "idle") {
 			source.fault = errorFor(source, /* @__PURE__ */ new Error("Source changed while projection was running."), "source");
 			errors.push(source.fault);
@@ -420,18 +449,9 @@ const createScheduler = (onError) => {
 			}
 		}
 	};
-	const compute = (run) => {
-		phase = "compute";
-		lock(true);
-		try {
-			return run();
-		} finally {
-			lock(false);
-			phase = "idle";
-		}
-	};
+	const compute = (run) => withPhase("compute", run);
 	const settle = () => {
-		if (disposed || depth || phase !== "idle") return;
+		if (lifecycle !== "active" || depth || phase !== "idle") return;
 		const cause = settleCause();
 		compute(() => {
 			for (const producer of dirty) advance(producer, cause);
@@ -447,7 +467,7 @@ const createScheduler = (onError) => {
 		}
 	};
 	const flush = () => {
-		if (disposed || depth) return [];
+		if (lifecycle !== "active" || depth || phase === "cleanup" || phase === "release") return [];
 		if (emissions.size || completed.size) profile.projection("flushes");
 		phase = "notify";
 		lock(true);
@@ -495,7 +515,7 @@ const createScheduler = (onError) => {
 		return result;
 	};
 	const batch = (callback, options) => {
-		assertIdle();
+		assertCommand();
 		if (depth === 0) activeBatch = Object.freeze({
 			id: ++batchSequence,
 			...options?.cause === void 0 ? {} : { cause: options.cause }
@@ -522,7 +542,8 @@ const createScheduler = (onError) => {
 		}
 	};
 	const releaseProducer = (producer) => {
-		assertIdle();
+		if (producer.disposed) return;
+		if (phase !== "release") assertIdle();
 		if (producer.outputs.some((output) => output.hasConsumers())) throw new Error("Projection producer is still used by another processor.");
 		producer.disposed = true;
 		dirty.delete(producer);
@@ -552,6 +573,16 @@ const createScheduler = (onError) => {
 	return {
 		assertActive,
 		assertIdle,
+		assertCommand,
+		beginClose,
+		cleanup(run) {
+			assertIdle();
+			return withPhase("cleanup", run);
+		},
+		releaseOwned(run) {
+			assertIdle();
+			return withPhase("release", run);
+		},
 		capture,
 		settle,
 		ensureCurrent,
@@ -560,15 +591,17 @@ const createScheduler = (onError) => {
 		registerGuard(guard) {
 			assertActive();
 			guards.add(guard);
+			if (lockDepth) guard(true);
 			let registered = true;
 			return () => {
 				if (!registered) return;
 				registered = false;
 				guards.delete(guard);
+				if (lockDepth) guard(false);
 			};
 		},
 		get active() {
-			return !disposed;
+			return lifecycle !== "disposed" && phase !== "release";
 		},
 		addSource(source) {
 			assertIdle();
@@ -582,7 +615,7 @@ const createScheduler = (onError) => {
 		releaseProducer,
 		nextId: () => sequence++,
 		acceptInput(callback) {
-			assertIdle();
+			assertCommand();
 			phase = "input";
 			lock(true);
 			try {
@@ -598,38 +631,39 @@ const createScheduler = (onError) => {
 		},
 		batch,
 		batchContext: () => activeBatch,
-		dispose() {
-			if (disposed) return;
-			assertIdle();
-			disposed = true;
+		dispose(releaseConsumers, releaseSources) {
+			if (lifecycle === "disposed") return;
+			if (lifecycle === "active") beginClose();
 			const failures = [];
-			processors.forEach((processor) => {
-				processor.disposed = true;
-				try {
-					processor.release();
-				} catch (error) {
-					failures.push(error);
-				}
-			});
-			sources.forEach((source) => {
-				source.disposed = true;
+			const attempt = (run) => {
 				try {
-					source.release();
+					run();
 				} catch (error) {
 					failures.push(error);
 				}
-			});
-			processors.clear();
-			sources.clear();
-			pendingSources.clear();
-			dirty.clear();
-			queued.clear();
-			completed.clear();
-			emissions.clear();
-			forced.clear();
-			guards.clear();
-			errors.length = 0;
-			reportingFailures = [];
+			};
+			try {
+				withPhase("release", () => {
+					attempt(releaseConsumers);
+					for (const processor of [...processors].reverse()) attempt(() => releaseProducer(processor));
+					for (const source of [...sources].reverse()) attempt(() => releaseProducer(source));
+					attempt(releaseSources);
+				});
+			} finally {
+				lifecycle = "disposed";
+				processors.clear();
+				sources.clear();
+				pendingSources.clear();
+				dirty.clear();
+				queued.clear();
+				completed.clear();
+				emissions.clear();
+				forced.clear();
+				guards.clear();
+				errors.length = 0;
+				reportingFailures = [];
+			}
+			if (failures.length === 1) throw failures[0];
 			if (failures.length) throw new AggregateError(failures, "Projection cleanup failed.");
 		}
 	};

package/dist/{transform--WCn6_v0.js → transform-BvDYPUMm.js}

@@ -29,6 +29,8 @@ const profile = {
 		segmentCompared: () => {}
 	},
 	collectionIndex: {
+		batch: (sortedKeys) => {},
+		visit: () => {},
 		node: () => {},
 		build: (items) => {}
 	},
@@ -259,7 +261,8 @@ var ProjectionDisposedError = class extends Error {
 //#endregion
 //#region core/src/projection/graph/scheduler.ts
 const createScheduler = (onError) => {
-	let disposed = false;
+	let lifecycle = "active";
+	let lockDepth = 0;
 	let depth = 0;
 	let batchSequence = 0;
 	let activeBatch;
@@ -277,13 +280,39 @@ const createScheduler = (onError) => {
 	let reportingFailures = [];
 	const guards = /* @__PURE__ */ new Set();
 	const assertActive = () => {
-		if (disposed) throw new ProjectionDisposedError();
+		if (lifecycle === "disposed" || phase === "release") throw new ProjectionDisposedError();
 	};
 	const assertIdle = () => {
 		assertActive();
-		if (phase !== "idle") throw new Error("Projection cannot be re-entered during input callbacks, processing or notification.");
+		if (phase !== "idle" && phase !== "cleanup") throw new Error("Projection cannot be re-entered during input callbacks, processing or notification.");
+	};
+	const assertCommand = () => {
+		assertActive();
+		if (lifecycle === "closing" || phase === "cleanup") throw new Error("Projection cleanup only permits reads and unsubscribe.");
+		assertIdle();
+	};
+	const lock = (value) => {
+		const previous = lockDepth;
+		lockDepth += value ? 1 : -1;
+		if (!previous || !lockDepth) guards.forEach((guard) => guard(value));
+	};
+	const beginClose = () => {
+		if (lifecycle !== "active") return false;
+		assertCommand();
+		lifecycle = "closing";
+		return true;
+	};
+	const withPhase = (next, run) => {
+		const previous = phase;
+		phase = next;
+		lock(true);
+		try {
+			return run();
+		} finally {
+			lock(false);
+			phase = previous;
+		}
 	};
-	const lock = (value) => guards.forEach((guard) => guard(value));
 	const markDirty = (producer) => {
 		const pending = [producer];
 		for (let index = 0; index < pending.length; index++) {
@@ -300,7 +329,7 @@ const createScheduler = (onError) => {
 	};
 	const errorFor = (producer, cause, kind = producer.kind === "source" ? "source" : "processor") => new ProjectionError(kind, cause);
 	const capture = (source) => {
-		if (disposed) return;
+		if (lifecycle === "disposed") return;
 		if (phase !== "idle") {
 			source.fault = errorFor(source, /* @__PURE__ */ new Error("Source changed while projection was running."), "source");
 			errors.push(source.fault);
@@ -420,18 +449,9 @@ const createScheduler = (onError) => {
 			}
 		}
 	};
-	const compute = (run) => {
-		phase = "compute";
-		lock(true);
-		try {
-			return run();
-		} finally {
-			lock(false);
-			phase = "idle";
-		}
-	};
+	const compute = (run) => withPhase("compute", run);
 	const settle = () => {
-		if (disposed || depth || phase !== "idle") return;
+		if (lifecycle !== "active" || depth || phase !== "idle") return;
 		const cause = settleCause();
 		compute(() => {
 			for (const producer of dirty) advance(producer, cause);
@@ -447,7 +467,7 @@ const createScheduler = (onError) => {
 		}
 	};
 	const flush = () => {
-		if (disposed || depth) return [];
+		if (lifecycle !== "active" || depth || phase === "cleanup" || phase === "release") return [];
 		if (emissions.size || completed.size) profile.projection("flushes");
 		phase = "notify";
 		lock(true);
@@ -495,7 +515,7 @@ const createScheduler = (onError) => {
 		return result;
 	};
 	const batch = (callback, options) => {
-		assertIdle();
+		assertCommand();
 		if (depth === 0) activeBatch = Object.freeze({
 			id: ++batchSequence,
 			...options?.cause === void 0 ? {} : { cause: options.cause }
@@ -522,7 +542,8 @@ const createScheduler = (onError) => {
 		}
 	};
 	const releaseProducer = (producer) => {
-		assertIdle();
+		if (producer.disposed) return;
+		if (phase !== "release") assertIdle();
 		if (producer.outputs.some((output) => output.hasConsumers())) throw new Error("Projection producer is still used by another processor.");
 		producer.disposed = true;
 		dirty.delete(producer);
@@ -552,6 +573,16 @@ const createScheduler = (onError) => {
 	return {
 		assertActive,
 		assertIdle,
+		assertCommand,
+		beginClose,
+		cleanup(run) {
+			assertIdle();
+			return withPhase("cleanup", run);
+		},
+		releaseOwned(run) {
+			assertIdle();
+			return withPhase("release", run);
+		},
 		capture,
 		settle,
 		ensureCurrent,
@@ -560,15 +591,17 @@ const createScheduler = (onError) => {
 		registerGuard(guard) {
 			assertActive();
 			guards.add(guard);
+			if (lockDepth) guard(true);
 			let registered = true;
 			return () => {
 				if (!registered) return;
 				registered = false;
 				guards.delete(guard);
+				if (lockDepth) guard(false);
 			};
 		},
 		get active() {
-			return !disposed;
+			return lifecycle !== "disposed" && phase !== "release";
 		},
 		addSource(source) {
 			assertIdle();
@@ -582,7 +615,7 @@ const createScheduler = (onError) => {
 		releaseProducer,
 		nextId: () => sequence++,
 		acceptInput(callback) {
-			assertIdle();
+			assertCommand();
 			phase = "input";
 			lock(true);
 			try {
@@ -598,38 +631,39 @@ const createScheduler = (onError) => {
 		},
 		batch,
 		batchContext: () => activeBatch,
-		dispose() {
-			if (disposed) return;
-			assertIdle();
-			disposed = true;
+		dispose(releaseConsumers, releaseSources) {
+			if (lifecycle === "disposed") return;
+			if (lifecycle === "active") beginClose();
 			const failures = [];
-			processors.forEach((processor) => {
-				processor.disposed = true;
-				try {
-					processor.release();
-				} catch (error) {
-					failures.push(error);
-				}
-			});
-			sources.forEach((source) => {
-				source.disposed = true;
+			const attempt = (run) => {
 				try {
-					source.release();
+					run();
 				} catch (error) {
 					failures.push(error);
 				}
-			});
-			processors.clear();
-			sources.clear();
-			pendingSources.clear();
-			dirty.clear();
-			queued.clear();
-			completed.clear();
-			emissions.clear();
-			forced.clear();
-			guards.clear();
-			errors.length = 0;
-			reportingFailures = [];
+			};
+			try {
+				withPhase("release", () => {
+					attempt(releaseConsumers);
+					for (const processor of [...processors].reverse()) attempt(() => releaseProducer(processor));
+					for (const source of [...sources].reverse()) attempt(() => releaseProducer(source));
+					attempt(releaseSources);
+				});
+			} finally {
+				lifecycle = "disposed";
+				processors.clear();
+				sources.clear();
+				pendingSources.clear();
+				dirty.clear();
+				queued.clear();
+				completed.clear();
+				emissions.clear();
+				forced.clear();
+				guards.clear();
+				errors.length = 0;
+				reportingFailures = [];
+			}
+			if (failures.length === 1) throw failures[0];
 			if (failures.length) throw new AggregateError(failures, "Projection cleanup failed.");
 		}
 	};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doxum",
-  "version": "0.1.40",
+  "version": "0.1.42",
   "private": false,
   "license": "MIT",
   "description": "Doxum is a typed runtime for complex mutable documents.",