doxum 0.1.16 → 0.1.18

package/dist/advanced-GTwIWcn6.d.cts

@@ -0,0 +1,138 @@
+import { J as Infer, L as CollectionId, R as CollectionNode, Z as ObjectNode, _ as Unsubscribe, et as PathValueOf, m as Synchronous, nt as SchemaPath, s as DocumentReadable, tt as ReadonlyValue, v as Readable, x as CollectionImpact, z as CollectionPath } from "./contract-XmKnroJq.cjs";
+
+//#region core/src/projection/contract.d.ts
+/** The one processor-facing collection transition protocol. */
+type CollectionChange<K extends string, V> = {
+  readonly kind: 'reset';
+} | {
+  readonly kind: 'incremental';
+  readonly added: readonly {
+    readonly key: K;
+    readonly after: V;
+  }[];
+  readonly updated: readonly {
+    readonly key: K;
+    readonly before: V;
+    readonly after: V;
+  }[];
+  readonly removed: readonly {
+    readonly key: K;
+    readonly before: V;
+  }[];
+  readonly order?: {
+    readonly before: readonly K[];
+    readonly after: readonly K[];
+  };
+};
+type CollectionRead<K extends string, V> = {
+  get(key: K): V | undefined;
+  has(key: K): boolean;
+  ids(): readonly K[];
+};
+type ExternalCollectionRead<K extends string, V> = {
+  readonly get: (key: K) => V | undefined;
+  readonly has: (key: K) => boolean;
+  readonly ids: () => readonly K[];
+};
+type ExternalValueSource<T> = {
+  readonly kind: 'value';
+  current(): T;
+  revision(): number;
+  subscribe(listener: (event: ExternalValueEvent<T>) => void): Unsubscribe;
+};
+type ExternalCollectionSource<K extends string, V> = {
+  readonly kind: 'collection';
+  current(): ExternalCollectionRead<K, V>;
+  revision(): number;
+  subscribe(listener: (event: ExternalCollectionEvent<K, V>) => void): Unsubscribe;
+};
+type ExternalValueEvent<T> = {
+  readonly value: T;
+  readonly revision: number;
+  readonly reset?: boolean;
+  readonly cause?: unknown;
+};
+type ExternalCollectionEvent<K extends string, V> = {
+  /** Stable read from the source before this event or external batch. */readonly previous: ExternalCollectionRead<K, V>;
+  readonly revision: number; /** Optional document-style hint; the adapter resolves the canonical change. */
+  readonly impact?: CollectionImpact<K>;
+  readonly cause?: unknown;
+};
+type CollectionDraft<K extends string, V> = {
+  set(key: K, value: V): void;
+  remove(key: K): void;
+  order(ids: readonly K[]): void;
+};
+declare class ProjectionError extends Error {
+  readonly phase: 'processor' | 'listener' | 'source' | 'blocked';
+  readonly identity: string;
+  readonly revisions: readonly number[];
+  constructor(phase: 'processor' | 'listener' | 'source' | 'blocked', identity: string, revisions: readonly number[], cause: unknown);
+}
+declare class ProjectionDisposedError extends Error {
+  constructor();
+}
+//#endregion
+//#region core/src/projection/definition.d.ts
+declare const projectionDefinition: unique symbol;
+declare const projectionChanges: unique symbol;
+declare const writableInput: unique symbol;
+/** 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, C = undefined> = Projection<T, C> & {
+  readonly [writableInput]: true;
+};
+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>;
+declare function observe<K extends string, V>(source: ExternalCollectionSource<K, V>): Projection<ReadonlyMap<K, V>, CollectionChange<K, V>>;
+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$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 { 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/advanced-c0F3gpLG.d.ts

@@ -0,0 +1,138 @@
+import { J as Infer, L as CollectionId, R as CollectionNode, Z as ObjectNode, _ as Unsubscribe, et as PathValueOf, m as Synchronous, nt as SchemaPath, s as DocumentReadable, tt as ReadonlyValue, v as Readable, x as CollectionImpact, z as CollectionPath } from "./contract-CATCCVu5.js";
+
+//#region core/src/projection/contract.d.ts
+/** The one processor-facing collection transition protocol. */
+type CollectionChange<K extends string, V> = {
+  readonly kind: 'reset';
+} | {
+  readonly kind: 'incremental';
+  readonly added: readonly {
+    readonly key: K;
+    readonly after: V;
+  }[];
+  readonly updated: readonly {
+    readonly key: K;
+    readonly before: V;
+    readonly after: V;
+  }[];
+  readonly removed: readonly {
+    readonly key: K;
+    readonly before: V;
+  }[];
+  readonly order?: {
+    readonly before: readonly K[];
+    readonly after: readonly K[];
+  };
+};
+type CollectionRead<K extends string, V> = {
+  get(key: K): V | undefined;
+  has(key: K): boolean;
+  ids(): readonly K[];
+};
+type ExternalCollectionRead<K extends string, V> = {
+  readonly get: (key: K) => V | undefined;
+  readonly has: (key: K) => boolean;
+  readonly ids: () => readonly K[];
+};
+type ExternalValueSource<T> = {
+  readonly kind: 'value';
+  current(): T;
+  revision(): number;
+  subscribe(listener: (event: ExternalValueEvent<T>) => void): Unsubscribe;
+};
+type ExternalCollectionSource<K extends string, V> = {
+  readonly kind: 'collection';
+  current(): ExternalCollectionRead<K, V>;
+  revision(): number;
+  subscribe(listener: (event: ExternalCollectionEvent<K, V>) => void): Unsubscribe;
+};
+type ExternalValueEvent<T> = {
+  readonly value: T;
+  readonly revision: number;
+  readonly reset?: boolean;
+  readonly cause?: unknown;
+};
+type ExternalCollectionEvent<K extends string, V> = {
+  /** Stable read from the source before this event or external batch. */readonly previous: ExternalCollectionRead<K, V>;
+  readonly revision: number; /** Optional document-style hint; the adapter resolves the canonical change. */
+  readonly impact?: CollectionImpact<K>;
+  readonly cause?: unknown;
+};
+type CollectionDraft<K extends string, V> = {
+  set(key: K, value: V): void;
+  remove(key: K): void;
+  order(ids: readonly K[]): void;
+};
+declare class ProjectionError extends Error {
+  readonly phase: 'processor' | 'listener' | 'source' | 'blocked';
+  readonly identity: string;
+  readonly revisions: readonly number[];
+  constructor(phase: 'processor' | 'listener' | 'source' | 'blocked', identity: string, revisions: readonly number[], cause: unknown);
+}
+declare class ProjectionDisposedError extends Error {
+  constructor();
+}
+//#endregion
+//#region core/src/projection/definition.d.ts
+declare const projectionDefinition: unique symbol;
+declare const projectionChanges: unique symbol;
+declare const writableInput: unique symbol;
+/** 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, C = undefined> = Projection<T, C> & {
+  readonly [writableInput]: true;
+};
+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>;
+declare function observe<K extends string, V>(source: ExternalCollectionSource<K, V>): Projection<ReadonlyMap<K, V>, CollectionChange<K, V>>;
+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$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 { 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,166 +1,3 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_scope = require("./scope-Ezs-Y3TY.cjs");
-const require_definition = require("./definition-Z6TagMup.cjs");
-//#region core/src/projection/advanced.ts
-const dependenciesOf = (dependencies) => Object.fromEntries(dependencies.map((dependency, index) => [`d${index}`, dependency]));
-const resetCollectionChange = Object.freeze({ kind: "reset" });
-const isCollectionSource = (source) => Boolean(source && typeof source === "object" && "ids" in source && typeof source.ids === "function" && "previous" in source && "transitions" in source && typeof source.transitions === "function");
-const collectionChange = (source) => {
-	if (!isCollectionSource(source)) return void 0;
-	if (source.reset || source.change?.kind === "reset") return resetCollectionChange;
-	const impact = source.change;
-	if (!impact) return void 0;
-	const added = [];
-	const updated = [];
-	const removed = [];
-	for (const transition of source.transitions()) if (transition.kind === "added") added.push({
-		key: transition.key,
-		kind: transition.kind,
-		after: transition.after
-	});
-	else if (transition.kind === "updated") updated.push(transition);
-	else removed.push({
-		key: transition.key,
-		kind: transition.kind,
-		before: transition.before
-	});
-	const order = impact.orderChanged ? {
-		before: Object.freeze([...source.previous.ids()]),
-		after: Object.freeze([...source.ids()])
-	} : void 0;
-	if (!added.length && !updated.length && !removed.length && !order) return void 0;
-	return Object.freeze({
-		kind: "incremental",
-		added: Object.freeze(added),
-		updated: Object.freeze(updated),
-		removed: Object.freeze(removed),
-		...order ? { order: Object.freeze(order) } : {}
-	});
-};
-const sourceCause = (sources) => {
-	for (const source of Object.values(sources)) if (source && typeof source === "object" && "cause" in source && source.cause !== void 0) return source.cause;
-};
-const publicSource = (source) => {
-	if (!source || typeof source !== "object") return source;
-	if ("value" in source) return source.value;
-	if ("read" in source) {
-		const read = source.read;
-		if (read && typeof read === "object" && "ids" in read && typeof read.ids === "function") {
-			const result = /* @__PURE__ */ new Map();
-			for (const id of read.ids()) result.set(id, read.get(id));
-			return result;
-		}
-		return require_scope.snapshot(read);
-	}
-	if ("ids" in source && typeof source.ids === "function") {
-		const result = /* @__PURE__ */ new Map();
-		const read = source;
-		for (const id of read.ids()) result.set(id, read.get(id));
-		return result;
-	}
-	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 && isCollectionSource(source) ? resetCollectionChange : collectionChange(source));
-	}
-	return {
-		values,
-		changes
-	};
-};
-const normalizeValue = (result) => result && typeof result === "object" && result.kind === "value" ? {
-	value: result.value,
-	state: result.state
-} : { value: result };
-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 (result && typeof result === "object" && "kind" in result) throw new TypeError("Initial incremental processor cannot rebuild.");
-		const normalized = normalizeValue(result);
-		current = normalized.value;
-		if (normalized.state) state = normalized.state;
-		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 (next && typeof next === "object" && "kind" in next) return next;
-				const nextValue = normalizeValue(next);
-				current = nextValue.value;
-				if (nextValue.state) state = nextValue.state;
-				return {
-					kind: "changed",
-					value: current
-				};
-			}
-		};
-	};
-	return require_definition.defineIncrementalValue({
-		dependencies: dependencyMap,
-		build
-	});
-}
-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.writer
-		})?.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.writer
-			});
-		} };
-	};
-	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,42 +1,2 @@
-import { a as ProjectionValues, d as CollectionChange, f as CollectionDraft, i as ProjectionChanges, p as CollectionRead, r as Projection, t as CollectionProjection } from "./definition-C__VJqA4.cjs";
-
-//#region core/src/projection/advanced.d.ts
-type IncrementalState = Record<string, unknown>;
-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: IncrementalState;
-};
-type IncrementalValueProcessor<D extends readonly Projection<unknown, unknown>[], T> = (context: IncrementalValueContext<D, T>) => T | {
-  readonly kind: 'value';
-  readonly value: T;
-  readonly state?: IncrementalState;
-} | {
-  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: IncrementalState;
-  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>): CollectionProjection<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, IncrementalState, 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,42 +1,2 @@
-import { a as ProjectionValues, d as CollectionChange, f as CollectionDraft, i as ProjectionChanges, p as CollectionRead, r as Projection, t as CollectionProjection } from "./definition-Dc1Udkop.js";
-
-//#region core/src/projection/advanced.d.ts
-type IncrementalState = Record<string, unknown>;
-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: IncrementalState;
-};
-type IncrementalValueProcessor<D extends readonly Projection<unknown, unknown>[], T> = (context: IncrementalValueContext<D, T>) => T | {
-  readonly kind: 'value';
-  readonly value: T;
-  readonly state?: IncrementalState;
-} | {
-  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: IncrementalState;
-  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>): CollectionProjection<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, IncrementalState, 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 };