doxum 0.1.17 → 0.1.18

package/dist/{definition-Bf8Z7xtX.d.cts → advanced-GTwIWcn6.d.cts}

@@ -77,17 +77,19 @@ declare class ProjectionDisposedError extends Error {
 declare const projectionDefinition: unique symbol;
 declare const projectionChanges: unique symbol;
 declare const writableInput: unique symbol;
-/** A lazy, reusable projection definition with no runtime-owned state. */
+/** A lazy definition with no materialized state; root definitions are reusable. */
 type Projection<T, C = undefined> = {
   readonly [projectionDefinition]: T;
   readonly [projectionChanges]: C;
 };
 /** A runtime-local writable projection definition. */
-type Input<T> = Projection<T> & {
+type Input<T, C = undefined> = Projection<T, C> & {
   readonly [writableInput]: true;
 };
-type ProjectionValues<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D]: D[K] extends Projection<infer T, unknown> ? T : never };
-declare const input: <T>(initial: T, equality?: (previous: T, next: T) => boolean) => Input<T>;
+type ProjectionValues$1<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D]: D[K] extends Projection<infer T, unknown> ? T : never };
+declare const input: (<T>(initial: T, equality?: (previous: T, next: T) => boolean) => Input<T>) & {
+  collection: <K extends string, V>(initial?: ReadonlyMap<K, V>) => Input<ReadonlyMap<K, V>, CollectionChange<K, V>>;
+};
 /** Establish a lazy reactive boundary from a document, readable, or external source. */
 declare function observe<S extends ObjectNode>(document: DocumentReadable<S>): Projection<Infer<S>>;
 declare function observe<T>(source: ExternalValueSource<T>): Projection<T>;
@@ -95,7 +97,42 @@ declare function observe<K extends string, V>(source: ExternalCollectionSource<K
 declare function observe<T>(readable: Readable<T>): Projection<T>;
 declare function observe<S extends ObjectNode, P extends CollectionPath>(document: DocumentReadable<S>, selector: (path: SchemaPath<S['shape']>) => P): Projection<ReadonlyMap<CollectionId<P>, ReadonlyValue<Infer<CollectionNode<P>>>>, CollectionChange<CollectionId<P>, ReadonlyValue<Infer<CollectionNode<P>>>>>;
 declare function observe<S extends ObjectNode, P>(document: DocumentReadable<S>, selector: (path: SchemaPath<S['shape']>) => P): Projection<PathValueOf<P>>;
-declare function derive<const D extends readonly Projection<unknown, unknown>[], T>(dependencies: D, compute: (...values: ProjectionValues<D>) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): Projection<T>;
+declare function derive<const D extends readonly Projection<unknown, unknown>[], T>(dependencies: D, compute: (...values: ProjectionValues$1<D>) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): Projection<T>;
+//#endregion
+//#region core/src/projection/advanced.d.ts
+type ProjectionValues<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D]: D[K] extends Projection<infer T, unknown> ? T : never };
+type ProjectionChanges<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D]: D[K] extends Projection<unknown, infer C> ? [C] extends [undefined] ? undefined : C | undefined : undefined };
+type IncrementalValueContext<D extends readonly Projection<unknown, unknown>[], T> = {
+  readonly sources: ProjectionValues<D>;
+  readonly changes: ProjectionChanges<D>;
+  readonly previous: T | undefined;
+  readonly reset: boolean;
+  readonly cause: unknown;
+  readonly state: Record<string, unknown>;
+};
+type IncrementalValueProcessor<D extends readonly Projection<unknown, unknown>[], T> = (context: IncrementalValueContext<D, T>) => T | {
+  readonly kind: 'rebuild';
+};
+type IncrementalCollectionContext<D extends readonly Projection<unknown, unknown>[], K extends string, V> = {
+  readonly sources: ProjectionValues<D>;
+  readonly changes: ProjectionChanges<D>;
+  readonly previous: CollectionRead<K, V>;
+  readonly next: CollectionRead<K, V>;
+  readonly reset: boolean;
+  readonly cause: unknown;
+  readonly state: Record<string, unknown>;
+  readonly output: CollectionDraft<K, V>;
+};
+type IncrementalCollectionProcessor<D extends readonly Projection<unknown, unknown>[], K extends string, V> = (context: IncrementalCollectionContext<D, K, V>) => void | {
+  readonly kind: 'rebuild';
+};
+type DependencyMap<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D as `d${Extract<K, number>}`]: D[K] };
+declare function createIncrementalValue<const D extends readonly Projection<unknown, unknown>[], T>(dependencies: D, processor: IncrementalValueProcessor<D, T>): Projection<T>;
+declare function createIncrementalCollection<const D extends readonly Projection<unknown, unknown>[], K extends string, V>(dependencies: D, processor: IncrementalCollectionProcessor<D, K, V>): Projection<ReadonlyMap<K, V>, CollectionChange<K, V>>;
+declare const incremental: typeof createIncrementalValue & {
+  collection: typeof createIncrementalCollection;
+};
+type IncrementalDependencies<D extends readonly Projection<unknown, unknown>[]> = DependencyMap<D>;
 //#endregion
-export { observe as a, CollectionRead as c, ExternalCollectionSource as d, ExternalValueEvent as f, ProjectionError as h, input as i, ExternalCollectionEvent as l, ProjectionDisposedError as m, Projection as n, CollectionChange as o, ExternalValueSource as p, derive as r, CollectionDraft as s, Input as t, ExternalCollectionRead as u };
-//# sourceMappingURL=definition-Bf8Z7xtX.d.cts.map
+export { ExternalValueSource as _, IncrementalValueProcessor as a, Projection as c, observe as d, CollectionChange as f, ExternalValueEvent as g, ExternalCollectionSource as h, IncrementalValueContext as i, derive as l, ExternalCollectionRead as m, IncrementalCollectionProcessor as n, incremental as o, ExternalCollectionEvent as p, IncrementalDependencies as r, Input as s, IncrementalCollectionContext as t, input as u, ProjectionDisposedError as v, ProjectionError as y };
+//# sourceMappingURL=advanced-GTwIWcn6.d.cts.map

package/dist/{definition-BdLGD8Rq.d.ts → advanced-c0F3gpLG.d.ts}

@@ -77,17 +77,19 @@ declare class ProjectionDisposedError extends Error {
 declare const projectionDefinition: unique symbol;
 declare const projectionChanges: unique symbol;
 declare const writableInput: unique symbol;
-/** A lazy, reusable projection definition with no runtime-owned state. */
+/** A lazy definition with no materialized state; root definitions are reusable. */
 type Projection<T, C = undefined> = {
   readonly [projectionDefinition]: T;
   readonly [projectionChanges]: C;
 };
 /** A runtime-local writable projection definition. */
-type Input<T> = Projection<T> & {
+type Input<T, C = undefined> = Projection<T, C> & {
   readonly [writableInput]: true;
 };
-type ProjectionValues<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D]: D[K] extends Projection<infer T, unknown> ? T : never };
-declare const input: <T>(initial: T, equality?: (previous: T, next: T) => boolean) => Input<T>;
+type ProjectionValues$1<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D]: D[K] extends Projection<infer T, unknown> ? T : never };
+declare const input: (<T>(initial: T, equality?: (previous: T, next: T) => boolean) => Input<T>) & {
+  collection: <K extends string, V>(initial?: ReadonlyMap<K, V>) => Input<ReadonlyMap<K, V>, CollectionChange<K, V>>;
+};
 /** Establish a lazy reactive boundary from a document, readable, or external source. */
 declare function observe<S extends ObjectNode>(document: DocumentReadable<S>): Projection<Infer<S>>;
 declare function observe<T>(source: ExternalValueSource<T>): Projection<T>;
@@ -95,7 +97,42 @@ declare function observe<K extends string, V>(source: ExternalCollectionSource<K
 declare function observe<T>(readable: Readable<T>): Projection<T>;
 declare function observe<S extends ObjectNode, P extends CollectionPath>(document: DocumentReadable<S>, selector: (path: SchemaPath<S['shape']>) => P): Projection<ReadonlyMap<CollectionId<P>, ReadonlyValue<Infer<CollectionNode<P>>>>, CollectionChange<CollectionId<P>, ReadonlyValue<Infer<CollectionNode<P>>>>>;
 declare function observe<S extends ObjectNode, P>(document: DocumentReadable<S>, selector: (path: SchemaPath<S['shape']>) => P): Projection<PathValueOf<P>>;
-declare function derive<const D extends readonly Projection<unknown, unknown>[], T>(dependencies: D, compute: (...values: ProjectionValues<D>) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): Projection<T>;
+declare function derive<const D extends readonly Projection<unknown, unknown>[], T>(dependencies: D, compute: (...values: ProjectionValues$1<D>) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): Projection<T>;
+//#endregion
+//#region core/src/projection/advanced.d.ts
+type ProjectionValues<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D]: D[K] extends Projection<infer T, unknown> ? T : never };
+type ProjectionChanges<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D]: D[K] extends Projection<unknown, infer C> ? [C] extends [undefined] ? undefined : C | undefined : undefined };
+type IncrementalValueContext<D extends readonly Projection<unknown, unknown>[], T> = {
+  readonly sources: ProjectionValues<D>;
+  readonly changes: ProjectionChanges<D>;
+  readonly previous: T | undefined;
+  readonly reset: boolean;
+  readonly cause: unknown;
+  readonly state: Record<string, unknown>;
+};
+type IncrementalValueProcessor<D extends readonly Projection<unknown, unknown>[], T> = (context: IncrementalValueContext<D, T>) => T | {
+  readonly kind: 'rebuild';
+};
+type IncrementalCollectionContext<D extends readonly Projection<unknown, unknown>[], K extends string, V> = {
+  readonly sources: ProjectionValues<D>;
+  readonly changes: ProjectionChanges<D>;
+  readonly previous: CollectionRead<K, V>;
+  readonly next: CollectionRead<K, V>;
+  readonly reset: boolean;
+  readonly cause: unknown;
+  readonly state: Record<string, unknown>;
+  readonly output: CollectionDraft<K, V>;
+};
+type IncrementalCollectionProcessor<D extends readonly Projection<unknown, unknown>[], K extends string, V> = (context: IncrementalCollectionContext<D, K, V>) => void | {
+  readonly kind: 'rebuild';
+};
+type DependencyMap<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D as `d${Extract<K, number>}`]: D[K] };
+declare function createIncrementalValue<const D extends readonly Projection<unknown, unknown>[], T>(dependencies: D, processor: IncrementalValueProcessor<D, T>): Projection<T>;
+declare function createIncrementalCollection<const D extends readonly Projection<unknown, unknown>[], K extends string, V>(dependencies: D, processor: IncrementalCollectionProcessor<D, K, V>): Projection<ReadonlyMap<K, V>, CollectionChange<K, V>>;
+declare const incremental: typeof createIncrementalValue & {
+  collection: typeof createIncrementalCollection;
+};
+type IncrementalDependencies<D extends readonly Projection<unknown, unknown>[]> = DependencyMap<D>;
 //#endregion
-export { observe as a, CollectionRead as c, ExternalCollectionSource as d, ExternalValueEvent as f, ProjectionError as h, input as i, ExternalCollectionEvent as l, ProjectionDisposedError as m, Projection as n, CollectionChange as o, ExternalValueSource as p, derive as r, CollectionDraft as s, Input as t, ExternalCollectionRead as u };
-//# sourceMappingURL=definition-BdLGD8Rq.d.ts.map
+export { ExternalValueSource as _, IncrementalValueProcessor as a, Projection as c, observe as d, CollectionChange as f, ExternalValueEvent as g, ExternalCollectionSource as h, IncrementalValueContext as i, derive as l, ExternalCollectionRead as m, IncrementalCollectionProcessor as n, incremental as o, ExternalCollectionEvent as p, IncrementalDependencies as r, Input as s, IncrementalCollectionContext as t, input as u, ProjectionDisposedError as v, ProjectionError as y };
+//# sourceMappingURL=advanced-c0F3gpLG.d.ts.map

package/dist/advanced.cjs

@@ -1,150 +1,3 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_scope = require("./scope-Ezs-Y3TY.cjs");
-const require_definition = require("./definition-De6rhTlZ.cjs");
-//#region core/src/projection/advanced.ts
-const resetCollectionChange = Object.freeze({ kind: "reset" });
-const isRebuild = (value) => value !== null && typeof value === "object" && value.kind === "rebuild";
-const collectionChange = (source) => {
-	if (!source || typeof source !== "object" || !("kind" in source)) return void 0;
-	if (source.kind !== "collection") return void 0;
-	return source.change;
-};
-const sourceCause = (sources) => {
-	for (const source of Object.values(sources)) if (source && typeof source === "object" && "kind" in source) {
-		const cause = source.cause;
-		if (cause !== void 0) return cause;
-	}
-};
-const collectionView = (read) => {
-	const entries = function* () {
-		for (const key of read.ids()) yield [key, read.get(key)];
-	};
-	const values = function* () {
-		for (const key of read.ids()) yield read.get(key);
-	};
-	const view = {
-		get: (key) => read.get(key),
-		has: (key) => read.has(key),
-		get size() {
-			return read.ids().length;
-		},
-		keys: () => read.ids()[Symbol.iterator](),
-		values,
-		entries,
-		forEach: (callback, thisArg) => {
-			for (const key of read.ids()) callback.call(thisArg, read.get(key), key, view);
-		},
-		[Symbol.iterator]: entries
-	};
-	return Object.freeze(view);
-};
-const publicSource = (source) => {
-	if (!source || typeof source !== "object") return source;
-	if (!("kind" in source)) return source;
-	if (source.kind === "value") return source.value;
-	if (source.kind === "document") return require_scope.snapshot(source.read);
-	if (source.kind === "collection") {
-		const read = source.read;
-		return collectionView(read);
-	}
-	return source;
-};
-const publicInputs = (sources, initial = false) => {
-	const values = [];
-	const changes = [];
-	for (const key of Object.keys(sources).sort((left, right) => Number(left.slice(1)) - Number(right.slice(1)))) {
-		const source = sources[key];
-		values.push(publicSource(source));
-		changes.push(initial && source && typeof source === "object" && "kind" in source && source.kind === "collection" ? resetCollectionChange : collectionChange(source));
-	}
-	return {
-		values,
-		changes
-	};
-};
-function createIncrementalValue(dependencies, processor) {
-	const dependencyMap = dependenciesOf(dependencies);
-	let state = Object.create(null);
-	let current;
-	const build = (sources) => {
-		state = Object.create(null);
-		const publicInputsForBuild = publicInputs(sources, true);
-		const result = processor({
-			sources: publicInputsForBuild.values,
-			changes: publicInputsForBuild.changes,
-			previous: void 0,
-			reset: true,
-			cause: sourceCause(sources),
-			state
-		});
-		if (isRebuild(result)) throw new TypeError("Initial incremental processor cannot rebuild.");
-		current = result;
-		return {
-			value: current,
-			update: (nextSources) => {
-				const publicInputsForUpdate = publicInputs(nextSources);
-				const next = processor({
-					sources: publicInputsForUpdate.values,
-					changes: publicInputsForUpdate.changes,
-					previous: current,
-					reset: false,
-					cause: sourceCause(nextSources),
-					state
-				});
-				if (isRebuild(next)) return next;
-				current = next;
-				return {
-					kind: "changed",
-					value: current
-				};
-			}
-		};
-	};
-	return require_definition.defineIncrementalValue({
-		dependencies: dependencyMap,
-		build
-	});
-}
-function dependenciesOf(dependencies) {
-	return Object.fromEntries(dependencies.map((dependency, index) => [`d${index}`, dependency]));
-}
-function createIncrementalCollection(dependencies, processor) {
-	const dependencyMap = dependenciesOf(dependencies);
-	let state = Object.create(null);
-	const build = (input) => {
-		state = Object.create(null);
-		const publicInputsForBuild = publicInputs(input.sources, true);
-		if (processor({
-			sources: publicInputsForBuild.values,
-			changes: publicInputsForBuild.changes,
-			previous: input.previous,
-			next: input.next,
-			reset: true,
-			cause: sourceCause(input.sources),
-			state,
-			output: input.output
-		})?.kind === "rebuild") throw new TypeError("Initial incremental collection processor cannot rebuild.");
-		return { update: (nextInput) => {
-			const publicInputsForUpdate = publicInputs(nextInput.sources);
-			return processor({
-				sources: publicInputsForUpdate.values,
-				changes: publicInputsForUpdate.changes,
-				previous: nextInput.previous,
-				next: nextInput.next,
-				reset: false,
-				cause: sourceCause(nextInput.sources),
-				state,
-				output: nextInput.output
-			});
-		} };
-	};
-	return require_definition.defineIncrementalCollection({
-		dependencies: dependencyMap,
-		build
-	});
-}
-const incremental = Object.assign(createIncrementalValue, { collection: createIncrementalCollection });
-//#endregion
-exports.incremental = incremental;
-
-//# sourceMappingURL=advanced.cjs.map
+const require_advanced = require("./advanced-Dgu8-bPS.cjs");
+exports.incremental = require_advanced.incremental;

package/dist/advanced.d.cts

@@ -1,39 +1,2 @@
-import { c as CollectionRead, n as Projection, o as CollectionChange, s as CollectionDraft } from "./definition-Bf8Z7xtX.cjs";
-
-//#region core/src/projection/advanced.d.ts
-type ProjectionValues<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D]: D[K] extends Projection<infer T, unknown> ? T : never };
-type ProjectionChanges<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D]: D[K] extends Projection<unknown, infer C> ? [C] extends [undefined] ? undefined : C | undefined : undefined };
-type IncrementalValueContext<D extends readonly Projection<unknown, unknown>[], T> = {
-  readonly sources: ProjectionValues<D>;
-  readonly changes: ProjectionChanges<D>;
-  readonly previous: T | undefined;
-  readonly reset: boolean;
-  readonly cause: unknown;
-  readonly state: Record<string, unknown>;
-};
-type IncrementalValueProcessor<D extends readonly Projection<unknown, unknown>[], T> = (context: IncrementalValueContext<D, T>) => T | {
-  readonly kind: 'rebuild';
-};
-type IncrementalCollectionContext<D extends readonly Projection<unknown, unknown>[], K extends string, V> = {
-  readonly sources: ProjectionValues<D>;
-  readonly changes: ProjectionChanges<D>;
-  readonly previous: CollectionRead<K, V>;
-  readonly next: CollectionRead<K, V>;
-  readonly reset: boolean;
-  readonly cause: unknown;
-  readonly state: Record<string, unknown>;
-  readonly output: CollectionDraft<K, V>;
-};
-type IncrementalCollectionProcessor<D extends readonly Projection<unknown, unknown>[], K extends string, V> = (context: IncrementalCollectionContext<D, K, V>) => void | {
-  readonly kind: 'rebuild';
-};
-type DependencyMap<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D as `d${Extract<K, number>}`]: D[K] };
-declare function createIncrementalValue<const D extends readonly Projection<unknown, unknown>[], T>(dependencies: D, processor: IncrementalValueProcessor<D, T>): Projection<T>;
-declare function createIncrementalCollection<const D extends readonly Projection<unknown, unknown>[], K extends string, V>(dependencies: D, processor: IncrementalCollectionProcessor<D, K, V>): Projection<ReadonlyMap<K, V>, CollectionChange<K, V>>;
-declare const incremental: typeof createIncrementalValue & {
-  collection: typeof createIncrementalCollection;
-};
-type IncrementalDependencies<D extends readonly Projection<unknown, unknown>[]> = DependencyMap<D>;
-//#endregion
-export { type CollectionChange, IncrementalCollectionContext, IncrementalCollectionProcessor, IncrementalDependencies, IncrementalValueContext, IncrementalValueProcessor, incremental };
-//# sourceMappingURL=advanced.d.cts.map
+import { a as IncrementalValueProcessor, f as CollectionChange, i as IncrementalValueContext, n as IncrementalCollectionProcessor, o as incremental, r as IncrementalDependencies, t as IncrementalCollectionContext } from "./advanced-GTwIWcn6.cjs";
+export { CollectionChange, IncrementalCollectionContext, IncrementalCollectionProcessor, IncrementalDependencies, IncrementalValueContext, IncrementalValueProcessor, incremental };

package/dist/advanced.d.ts

@@ -1,39 +1,2 @@
-import { c as CollectionRead, n as Projection, o as CollectionChange, s as CollectionDraft } from "./definition-BdLGD8Rq.js";
-
-//#region core/src/projection/advanced.d.ts
-type ProjectionValues<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D]: D[K] extends Projection<infer T, unknown> ? T : never };
-type ProjectionChanges<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D]: D[K] extends Projection<unknown, infer C> ? [C] extends [undefined] ? undefined : C | undefined : undefined };
-type IncrementalValueContext<D extends readonly Projection<unknown, unknown>[], T> = {
-  readonly sources: ProjectionValues<D>;
-  readonly changes: ProjectionChanges<D>;
-  readonly previous: T | undefined;
-  readonly reset: boolean;
-  readonly cause: unknown;
-  readonly state: Record<string, unknown>;
-};
-type IncrementalValueProcessor<D extends readonly Projection<unknown, unknown>[], T> = (context: IncrementalValueContext<D, T>) => T | {
-  readonly kind: 'rebuild';
-};
-type IncrementalCollectionContext<D extends readonly Projection<unknown, unknown>[], K extends string, V> = {
-  readonly sources: ProjectionValues<D>;
-  readonly changes: ProjectionChanges<D>;
-  readonly previous: CollectionRead<K, V>;
-  readonly next: CollectionRead<K, V>;
-  readonly reset: boolean;
-  readonly cause: unknown;
-  readonly state: Record<string, unknown>;
-  readonly output: CollectionDraft<K, V>;
-};
-type IncrementalCollectionProcessor<D extends readonly Projection<unknown, unknown>[], K extends string, V> = (context: IncrementalCollectionContext<D, K, V>) => void | {
-  readonly kind: 'rebuild';
-};
-type DependencyMap<D extends readonly Projection<unknown, unknown>[]> = { readonly [K in keyof D as `d${Extract<K, number>}`]: D[K] };
-declare function createIncrementalValue<const D extends readonly Projection<unknown, unknown>[], T>(dependencies: D, processor: IncrementalValueProcessor<D, T>): Projection<T>;
-declare function createIncrementalCollection<const D extends readonly Projection<unknown, unknown>[], K extends string, V>(dependencies: D, processor: IncrementalCollectionProcessor<D, K, V>): Projection<ReadonlyMap<K, V>, CollectionChange<K, V>>;
-declare const incremental: typeof createIncrementalValue & {
-  collection: typeof createIncrementalCollection;
-};
-type IncrementalDependencies<D extends readonly Projection<unknown, unknown>[]> = DependencyMap<D>;
-//#endregion
-export { type CollectionChange, IncrementalCollectionContext, IncrementalCollectionProcessor, IncrementalDependencies, IncrementalValueContext, IncrementalValueProcessor, incremental };
-//# sourceMappingURL=advanced.d.ts.map
+import { a as IncrementalValueProcessor, f as CollectionChange, i as IncrementalValueContext, n as IncrementalCollectionProcessor, o as incremental, r as IncrementalDependencies, t as IncrementalCollectionContext } from "./advanced-c0F3gpLG.js";
+export { CollectionChange, IncrementalCollectionContext, IncrementalCollectionProcessor, IncrementalDependencies, IncrementalValueContext, IncrementalValueProcessor, incremental };

package/dist/advanced.js

@@ -1,149 +1,2 @@
-import { i as snapshot } from "./scope-d-L87NeC.js";
-import { n as defineIncrementalValue, t as defineIncrementalCollection } from "./definition-DUo1lfQ8.js";
-//#region core/src/projection/advanced.ts
-const resetCollectionChange = Object.freeze({ kind: "reset" });
-const isRebuild = (value) => value !== null && typeof value === "object" && value.kind === "rebuild";
-const collectionChange = (source) => {
-	if (!source || typeof source !== "object" || !("kind" in source)) return void 0;
-	if (source.kind !== "collection") return void 0;
-	return source.change;
-};
-const sourceCause = (sources) => {
-	for (const source of Object.values(sources)) if (source && typeof source === "object" && "kind" in source) {
-		const cause = source.cause;
-		if (cause !== void 0) return cause;
-	}
-};
-const collectionView = (read) => {
-	const entries = function* () {
-		for (const key of read.ids()) yield [key, read.get(key)];
-	};
-	const values = function* () {
-		for (const key of read.ids()) yield read.get(key);
-	};
-	const view = {
-		get: (key) => read.get(key),
-		has: (key) => read.has(key),
-		get size() {
-			return read.ids().length;
-		},
-		keys: () => read.ids()[Symbol.iterator](),
-		values,
-		entries,
-		forEach: (callback, thisArg) => {
-			for (const key of read.ids()) callback.call(thisArg, read.get(key), key, view);
-		},
-		[Symbol.iterator]: entries
-	};
-	return Object.freeze(view);
-};
-const publicSource = (source) => {
-	if (!source || typeof source !== "object") return source;
-	if (!("kind" in source)) return source;
-	if (source.kind === "value") return source.value;
-	if (source.kind === "document") return snapshot(source.read);
-	if (source.kind === "collection") {
-		const read = source.read;
-		return collectionView(read);
-	}
-	return source;
-};
-const publicInputs = (sources, initial = false) => {
-	const values = [];
-	const changes = [];
-	for (const key of Object.keys(sources).sort((left, right) => Number(left.slice(1)) - Number(right.slice(1)))) {
-		const source = sources[key];
-		values.push(publicSource(source));
-		changes.push(initial && source && typeof source === "object" && "kind" in source && source.kind === "collection" ? resetCollectionChange : collectionChange(source));
-	}
-	return {
-		values,
-		changes
-	};
-};
-function createIncrementalValue(dependencies, processor) {
-	const dependencyMap = dependenciesOf(dependencies);
-	let state = Object.create(null);
-	let current;
-	const build = (sources) => {
-		state = Object.create(null);
-		const publicInputsForBuild = publicInputs(sources, true);
-		const result = processor({
-			sources: publicInputsForBuild.values,
-			changes: publicInputsForBuild.changes,
-			previous: void 0,
-			reset: true,
-			cause: sourceCause(sources),
-			state
-		});
-		if (isRebuild(result)) throw new TypeError("Initial incremental processor cannot rebuild.");
-		current = result;
-		return {
-			value: current,
-			update: (nextSources) => {
-				const publicInputsForUpdate = publicInputs(nextSources);
-				const next = processor({
-					sources: publicInputsForUpdate.values,
-					changes: publicInputsForUpdate.changes,
-					previous: current,
-					reset: false,
-					cause: sourceCause(nextSources),
-					state
-				});
-				if (isRebuild(next)) return next;
-				current = next;
-				return {
-					kind: "changed",
-					value: current
-				};
-			}
-		};
-	};
-	return defineIncrementalValue({
-		dependencies: dependencyMap,
-		build
-	});
-}
-function dependenciesOf(dependencies) {
-	return Object.fromEntries(dependencies.map((dependency, index) => [`d${index}`, dependency]));
-}
-function createIncrementalCollection(dependencies, processor) {
-	const dependencyMap = dependenciesOf(dependencies);
-	let state = Object.create(null);
-	const build = (input) => {
-		state = Object.create(null);
-		const publicInputsForBuild = publicInputs(input.sources, true);
-		if (processor({
-			sources: publicInputsForBuild.values,
-			changes: publicInputsForBuild.changes,
-			previous: input.previous,
-			next: input.next,
-			reset: true,
-			cause: sourceCause(input.sources),
-			state,
-			output: input.output
-		})?.kind === "rebuild") throw new TypeError("Initial incremental collection processor cannot rebuild.");
-		return { update: (nextInput) => {
-			const publicInputsForUpdate = publicInputs(nextInput.sources);
-			return processor({
-				sources: publicInputsForUpdate.values,
-				changes: publicInputsForUpdate.changes,
-				previous: nextInput.previous,
-				next: nextInput.next,
-				reset: false,
-				cause: sourceCause(nextInput.sources),
-				state,
-				output: nextInput.output
-			});
-		} };
-	};
-	return defineIncrementalCollection({
-		dependencies: dependencyMap,
-		build
-	});
-}
-const incremental = Object.assign(createIncrementalValue, { collection: createIncrementalCollection });
-//#endregion
+import { t as incremental } from "./advanced-DgRnyRAc.js";
 export { incremental };
-
-//# sourceMappingURL=advanced.js.map