doxum 0.1.14 → 0.1.16

package/dist/{definition-DN6yW2vi.d.cts → definition-C__VJqA4.d.cts}

@@ -6,6 +6,40 @@ type Cause = unknown;
 type BatchOptions = {
   readonly cause?: Cause;
 };
+type CollectionEntryTransition<K extends string, V> = {
+  readonly key: K;
+  readonly kind: 'added';
+  readonly before: undefined;
+  readonly after: V;
+} | {
+  readonly key: K;
+  readonly kind: 'updated';
+  readonly before: V;
+  readonly after: V;
+} | {
+  readonly key: K;
+  readonly kind: 'removed';
+  readonly before: V;
+  readonly after: undefined;
+};
+type CollectionChange<K extends string, V> = {
+  readonly kind: 'reset';
+} | {
+  readonly kind: 'incremental';
+  readonly added: readonly Omit<Extract<CollectionEntryTransition<K, V>, {
+    readonly kind: 'added';
+  }>, 'before'>[];
+  readonly updated: readonly Extract<CollectionEntryTransition<K, V>, {
+    readonly kind: 'updated';
+  }>[];
+  readonly removed: readonly Omit<Extract<CollectionEntryTransition<K, V>, {
+    readonly kind: 'removed';
+  }>, 'after'>[];
+  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;
@@ -69,18 +103,21 @@ declare class ProjectionDisposedError extends Error {
 //#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, reusable projection definition. Its value is materialized per runtime. */
-type Projection<T> = {
+type Projection<T, C = undefined> = {
   readonly [projectionDefinition]: T;
+  readonly [projectionChanges]: C;
 };
 /** A runtime-local writable projection definition. */
 type Input<T> = Projection<T> & {
   readonly [writableInput]: true;
 };
-type ProjectionValues<D extends readonly Projection<unknown>[]> = { readonly [K in keyof D]: D[K] extends Projection<infer T> ? T : never };
+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 PublicCollection<K extends string, V> = ReadonlyMap<K, V>;
-type ObservedCollection<P extends CollectionPath> = PublicCollection<CollectionId<P>, ReadonlyValue<Infer<CollectionNode<P>>>>;
+type CollectionProjection<K extends string, V> = Projection<PublicCollection<K, V>, CollectionChange<K, V>>;
 declare const input: <T>(initial: T, equality?: (previous: T, next: T) => boolean) => Input<T>;
 /**
  * Establishes a reactive boundary from a document, readable, or external
@@ -89,11 +126,11 @@ declare const input: <T>(initial: T, equality?: (previous: T, next: T) => boolea
  */
 declare function observe<S extends ObjectNode>(document: DocumentReadable<S>): Projection<Infer<S>>;
 declare function observe<T, D>(source: ExternalValueSource<T, D>): Projection<T>;
-declare function observe<K extends string, V, D>(source: ExternalCollectionSource<K, V, D>): Projection<PublicCollection<K, V>>;
+declare function observe<K extends string, V, D>(source: ExternalCollectionSource<K, V, D>): CollectionProjection<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<ObservedCollection<P>>;
+declare function observe<S extends ObjectNode, P extends CollectionPath>(document: DocumentReadable<S>, selector: (path: SchemaPath<S['shape']>) => P): CollectionProjection<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>[], 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<D>) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): Projection<T>;
 //#endregion
-export { ProjectionError as _, derive as a, BatchOptions as c, ExternalCollectionEvent as d, ExternalCollectionRead as f, ProjectionDisposedError as g, ExternalValueSource as h, PublicCollection as i, CollectionDraft as l, ExternalValueEvent as m, Projection as n, input as o, ExternalCollectionSource as p, ProjectionValues as r, observe as s, Input as t, CollectionRead as u };
-//# sourceMappingURL=definition-DN6yW2vi.d.cts.map
+export { ExternalValueEvent as _, ProjectionValues as a, ProjectionError as b, input as c, CollectionChange as d, CollectionDraft as f, ExternalCollectionSource as g, ExternalCollectionRead as h, ProjectionChanges as i, observe as l, ExternalCollectionEvent as m, Input as n, PublicCollection as o, CollectionRead as p, Projection as r, derive as s, CollectionProjection as t, BatchOptions as u, ExternalValueSource as v, ProjectionDisposedError as y };
+//# sourceMappingURL=definition-C__VJqA4.d.cts.map

package/dist/{definition-Dr8tHwTD.d.ts → definition-Dc1Udkop.d.ts}

@@ -1,4 +1,4 @@
-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-BT53Gg94.js";
+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
 /** Opaque application metadata identifying the action that produced a source event. */
@@ -6,6 +6,40 @@ type Cause = unknown;
 type BatchOptions = {
   readonly cause?: Cause;
 };
+type CollectionEntryTransition<K extends string, V> = {
+  readonly key: K;
+  readonly kind: 'added';
+  readonly before: undefined;
+  readonly after: V;
+} | {
+  readonly key: K;
+  readonly kind: 'updated';
+  readonly before: V;
+  readonly after: V;
+} | {
+  readonly key: K;
+  readonly kind: 'removed';
+  readonly before: V;
+  readonly after: undefined;
+};
+type CollectionChange<K extends string, V> = {
+  readonly kind: 'reset';
+} | {
+  readonly kind: 'incremental';
+  readonly added: readonly Omit<Extract<CollectionEntryTransition<K, V>, {
+    readonly kind: 'added';
+  }>, 'before'>[];
+  readonly updated: readonly Extract<CollectionEntryTransition<K, V>, {
+    readonly kind: 'updated';
+  }>[];
+  readonly removed: readonly Omit<Extract<CollectionEntryTransition<K, V>, {
+    readonly kind: 'removed';
+  }>, 'after'>[];
+  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;
@@ -69,18 +103,21 @@ declare class ProjectionDisposedError extends Error {
 //#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, reusable projection definition. Its value is materialized per runtime. */
-type Projection<T> = {
+type Projection<T, C = undefined> = {
   readonly [projectionDefinition]: T;
+  readonly [projectionChanges]: C;
 };
 /** A runtime-local writable projection definition. */
 type Input<T> = Projection<T> & {
   readonly [writableInput]: true;
 };
-type ProjectionValues<D extends readonly Projection<unknown>[]> = { readonly [K in keyof D]: D[K] extends Projection<infer T> ? T : never };
+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 PublicCollection<K extends string, V> = ReadonlyMap<K, V>;
-type ObservedCollection<P extends CollectionPath> = PublicCollection<CollectionId<P>, ReadonlyValue<Infer<CollectionNode<P>>>>;
+type CollectionProjection<K extends string, V> = Projection<PublicCollection<K, V>, CollectionChange<K, V>>;
 declare const input: <T>(initial: T, equality?: (previous: T, next: T) => boolean) => Input<T>;
 /**
  * Establishes a reactive boundary from a document, readable, or external
@@ -89,11 +126,11 @@ declare const input: <T>(initial: T, equality?: (previous: T, next: T) => boolea
  */
 declare function observe<S extends ObjectNode>(document: DocumentReadable<S>): Projection<Infer<S>>;
 declare function observe<T, D>(source: ExternalValueSource<T, D>): Projection<T>;
-declare function observe<K extends string, V, D>(source: ExternalCollectionSource<K, V, D>): Projection<PublicCollection<K, V>>;
+declare function observe<K extends string, V, D>(source: ExternalCollectionSource<K, V, D>): CollectionProjection<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<ObservedCollection<P>>;
+declare function observe<S extends ObjectNode, P extends CollectionPath>(document: DocumentReadable<S>, selector: (path: SchemaPath<S['shape']>) => P): CollectionProjection<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>[], 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<D>) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): Projection<T>;
 //#endregion
-export { ProjectionError as _, derive as a, BatchOptions as c, ExternalCollectionEvent as d, ExternalCollectionRead as f, ProjectionDisposedError as g, ExternalValueSource as h, PublicCollection as i, CollectionDraft as l, ExternalValueEvent as m, Projection as n, input as o, ExternalCollectionSource as p, ProjectionValues as r, observe as s, Input as t, CollectionRead as u };
-//# sourceMappingURL=definition-Dr8tHwTD.d.ts.map
+export { ExternalValueEvent as _, ProjectionValues as a, ProjectionError as b, input as c, CollectionChange as d, CollectionDraft as f, ExternalCollectionSource as g, ExternalCollectionRead as h, ProjectionChanges as i, observe as l, ExternalCollectionEvent as m, Input as n, PublicCollection as o, CollectionRead as p, Projection as r, derive as s, CollectionProjection as t, BatchOptions as u, ExternalValueSource as v, ProjectionDisposedError as y };
+//# sourceMappingURL=definition-Dc1Udkop.d.ts.map

package/dist/definition-Z6TagMup.cjs

@@ -0,0 +1,107 @@
+//#region core/src/projection/definition.ts
+const definitions = /* @__PURE__ */ new WeakMap();
+const define = (definition) => {
+	const handle = Object.freeze({});
+	definitions.set(handle, definition);
+	return handle;
+};
+const definitionOf = (projection) => {
+	const definition = definitions.get(projection);
+	if (!definition) throw new TypeError("Unknown projection definition.");
+	return definition;
+};
+const input = (initial, equality = Object.is) => define({
+	kind: "input",
+	initial,
+	isEqual: equality
+});
+function observe(document, selector) {
+	if (isExternalSource(document)) return document.kind === "collection" ? defineExternalCollection(document) : defineExternalValue(document);
+	if ("current" in document && typeof document.current === "function") return defineReadable(document);
+	return define({
+		kind: "document",
+		document,
+		selector
+	});
+}
+const isExternalSource = (source) => {
+	if (!source || typeof source !== "object") return false;
+	const candidate = source;
+	return (candidate.kind === "value" || candidate.kind === "collection") && typeof candidate.current === "function" && typeof candidate.revision === "function" && typeof candidate.subscribe === "function";
+};
+function derive(dependencies, compute, equality = Object.is) {
+	if (!Array.isArray(dependencies) || dependencies.some((value) => !definitions.has(value))) throw new TypeError("derive dependencies must be projections.");
+	return define({
+		kind: "derive",
+		dependencies: Object.freeze([...dependencies]),
+		compute,
+		isEqual: equality
+	});
+}
+/** Internal source adapters used by observe, not exported publicly. */
+const defineReadable = (readable, equality = Object.is) => define({
+	kind: "readable",
+	readable,
+	isEqual: equality
+});
+const defineExternalValue = (source) => define({
+	kind: "source-value",
+	source
+});
+const defineExternalCollection = (source) => define({
+	kind: "source-collection",
+	source
+});
+const defineIncrementalValue = (definition) => define({
+	kind: "incremental-value",
+	dependencies: definition.dependencies,
+	build: definition.build,
+	isEqual: definition.isEqual,
+	name: definition.name
+});
+const defineIncrementalCollection = (definition) => define({
+	kind: "incremental-collection",
+	dependencies: definition.dependencies,
+	build: definition.build,
+	isEqual: definition.isEqual,
+	name: definition.name
+});
+//#endregion
+Object.defineProperty(exports, "defineIncrementalCollection", {
+	enumerable: true,
+	get: function() {
+		return defineIncrementalCollection;
+	}
+});
+Object.defineProperty(exports, "defineIncrementalValue", {
+	enumerable: true,
+	get: function() {
+		return defineIncrementalValue;
+	}
+});
+Object.defineProperty(exports, "definitionOf", {
+	enumerable: true,
+	get: function() {
+		return definitionOf;
+	}
+});
+Object.defineProperty(exports, "derive", {
+	enumerable: true,
+	get: function() {
+		return derive;
+	}
+});
+Object.defineProperty(exports, "input", {
+	enumerable: true,
+	get: function() {
+		return input;
+	}
+});
+Object.defineProperty(exports, "observe", {
+	enumerable: true,
+	get: function() {
+		return observe;
+	}
+});
+
+//# sourceMappingURL=definition-Z6TagMup.cjs.map

package/dist/definition-Z6TagMup.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-Z6TagMup.cjs","names":[],"sources":["../core/src/projection/definition.ts"],"sourcesContent":["import type { DocumentReadable, Synchronous } from '../runtime/contract';\nimport type {\n  CollectionId,\n  CollectionPath,\n  CollectionNode as SchemaCollectionNode,\n  Infer,\n  ObjectNode,\n  ReadonlyValue,\n  SchemaPath,\n  PathValueOf,\n} from '../schema';\nimport type { Readable } from './readable';\nimport type {\n  BatchContext,\n  Cause,\n  CollectionContext,\n  CollectionChange,\n  CollectionDraft,\n  CollectionRead,\n  CollectionEntryTransition,\n  DocumentContext,\n  ExternalCollectionSource,\n  ExternalValueSource,\n  GraphSources,\n  InputHandles,\n  NodeUpdate,\n  ValueContext,\n} from './contract';\n\ndeclare const projectionDefinition: unique symbol;\ndeclare const projectionChanges: unique symbol;\ndeclare const writableInput: unique symbol;\n\n/** A lazy, reusable projection definition. Its value is materialized per runtime. */\nexport type Projection<T, C = undefined> = {\n  readonly [projectionDefinition]: T;\n  readonly [projectionChanges]: C;\n};\n\n/** A runtime-local writable projection definition. */\nexport type Input<T> = Projection<T> & { readonly [writableInput]: true };\n\nexport type ProjectionValues<D extends readonly Projection<unknown, unknown>[]> = {\n  readonly [K in keyof D]: D[K] extends Projection<infer T, unknown> ? T : never;\n};\n\nexport type ProjectionChanges<D extends readonly Projection<unknown, unknown>[]> = {\n  readonly [K in keyof D]: D[K] extends Projection<unknown, infer C>\n    ? [C] extends [undefined]\n      ? undefined\n      : C | undefined\n    : undefined;\n};\n\nexport type PublicCollection<K extends string, V> = ReadonlyMap<K, V>;\nexport type CollectionProjection<K extends string, V> = Projection<\n  PublicCollection<K, V>,\n  CollectionChange<K, V>\n>;\n\ntype Equality = (a: unknown, b: unknown) => boolean;\ntype PathSelector<S extends ObjectNode> = (path: SchemaPath<S['shape']>) => unknown;\n\ntype Definition =\n  | { readonly kind: 'input'; readonly initial: unknown; readonly isEqual?: Equality }\n  | { readonly kind: 'readable'; readonly readable: Readable<unknown>; readonly isEqual?: Equality }\n  | { readonly kind: 'source-value'; readonly source: ExternalValueSource<unknown, unknown> }\n  | {\n      readonly kind: 'source-collection';\n      readonly source: ExternalCollectionSource<string, unknown, unknown>;\n    }\n  | {\n      readonly kind: 'document';\n      readonly document: DocumentReadable<ObjectNode>;\n      readonly selector?: PathSelector<ObjectNode>;\n    }\n  | {\n      readonly kind: 'derive';\n      readonly dependencies: readonly Projection<unknown, unknown>[];\n      readonly compute: (...values: readonly unknown[]) => unknown;\n      readonly isEqual?: Equality;\n    }\n  | {\n      readonly kind: 'incremental-value';\n      readonly dependencies: GraphSources;\n      readonly build: (...args: never[]) => unknown;\n      readonly isEqual?: Equality;\n      readonly name?: string;\n    }\n  | {\n      readonly kind: 'incremental-collection';\n      readonly dependencies: GraphSources;\n      readonly build: (...args: never[]) => unknown;\n      readonly isEqual?: Equality;\n      readonly name?: string;\n    };\n\ntype DefinitionProjection = Projection<unknown, unknown>;\nconst definitions = new WeakMap<object, Definition>();\n\nconst define = <T, C = undefined>(definition: Definition): Projection<T, C> => {\n  const handle = Object.freeze({}) as Projection<T, C>;\n  definitions.set(handle, definition);\n  return handle;\n};\n\nexport const definitionOf = (projection: DefinitionProjection): Definition => {\n  const definition = definitions.get(projection);\n  if (!definition) throw new TypeError('Unknown projection definition.');\n  return definition;\n};\n\nexport const input = <T>(\n  initial: T,\n  equality: (previous: T, next: T) => boolean = Object.is\n): Input<T> => define<T>({ kind: 'input', initial, isEqual: equality as Equality }) as Input<T>;\n\n/**\n * Establishes a reactive boundary from a document, readable, or external\n * source. The selector is compiled when the definition is materialized, so\n * declarations stay lazy and reusable.\n */\nexport function observe<S extends ObjectNode>(document: DocumentReadable<S>): Projection<Infer<S>>;\nexport function observe<T, D>(source: ExternalValueSource<T, D>): Projection<T>;\nexport function observe<K extends string, V, D>(\n  source: ExternalCollectionSource<K, V, D>\n): CollectionProjection<K, V>;\nexport function observe<T>(readable: Readable<T>): Projection<T>;\nexport function observe<S extends ObjectNode, P extends CollectionPath>(\n  document: DocumentReadable<S>,\n  selector: (path: SchemaPath<S['shape']>) => P\n): CollectionProjection<CollectionId<P>, ReadonlyValue<Infer<SchemaCollectionNode<P>>>>;\nexport function observe<S extends ObjectNode, P>(\n  document: DocumentReadable<S>,\n  selector: (path: SchemaPath<S['shape']>) => P\n): Projection<PathValueOf<P>>;\nexport function observe<S extends ObjectNode>(\n  document:\n    | DocumentReadable<S>\n    | Readable<unknown>\n    | ExternalValueSource<unknown, unknown>\n    | ExternalCollectionSource<string, unknown, unknown>,\n  selector?: PathSelector<S>\n): Projection<unknown, unknown> {\n  if (isExternalSource(document))\n    return document.kind === 'collection'\n      ? defineExternalCollection(document)\n      : defineExternalValue(document);\n  if ('current' in document && typeof document.current === 'function')\n    return defineReadable(document as Readable<unknown>);\n  return define({\n    kind: 'document',\n    document: document as DocumentReadable<ObjectNode>,\n    selector: selector as PathSelector<ObjectNode> | undefined,\n  });\n}\n\nconst isExternalSource = (\n  source: unknown\n): source is\n  ExternalValueSource<unknown, unknown> | ExternalCollectionSource<string, unknown, unknown> => {\n  if (!source || typeof source !== 'object') return false;\n  const candidate = source as {\n    readonly kind?: unknown;\n    readonly current?: unknown;\n    readonly revision?: unknown;\n    readonly subscribe?: unknown;\n  };\n  return (\n    (candidate.kind === 'value' || candidate.kind === 'collection') &&\n    typeof candidate.current === 'function' &&\n    typeof candidate.revision === 'function' &&\n    typeof candidate.subscribe === 'function'\n  );\n};\n\nexport function derive<const D extends readonly Projection<unknown, unknown>[], T>(\n  dependencies: D,\n  compute: (...values: ProjectionValues<D>) => Synchronous<T>,\n  equality: (previous: T, next: T) => boolean = Object.is\n): Projection<T> {\n  if (!Array.isArray(dependencies) || dependencies.some(value => !definitions.has(value)))\n    throw new TypeError('derive dependencies must be projections.');\n  const frozen = Object.freeze([...dependencies]) as readonly Projection<unknown, unknown>[];\n  return define<T>({\n    kind: 'derive',\n    dependencies: frozen,\n    compute: compute as (...values: readonly unknown[]) => unknown,\n    isEqual: equality as Equality,\n  });\n}\n\n/** Internal source adapters used by observe, not exported publicly. */\nexport const defineReadable = <T>(\n  readable: Readable<T>,\n  equality: (a: T, b: T) => boolean = Object.is\n): Projection<T> => define<T>({ kind: 'readable', readable, isEqual: equality as Equality });\n\nexport const defineExternalValue = <T, D>(source: ExternalValueSource<T, D>): Projection<T> =>\n  define<T>({ kind: 'source-value', source: source as never });\n\nexport const defineExternalCollection = <K extends string, V, D>(\n  source: ExternalCollectionSource<K, V, D>\n): CollectionProjection<K, V> =>\n  define<PublicCollection<K, V>, CollectionChange<K, V>>({\n    kind: 'source-collection',\n    source: source as never,\n  });\n\nexport type IncrementalValueDefinition = Extract<Definition, { kind: 'incremental-value' }>;\nexport type IncrementalCollectionDefinition = Extract<\n  Definition,\n  { kind: 'incremental-collection' }\n>;\n\nexport const defineIncrementalValue = <T>(definition: {\n  readonly dependencies: GraphSources;\n  readonly build: (...args: never[]) => unknown;\n  readonly isEqual?: (a: T, b: T) => boolean;\n  readonly name?: string;\n}): Projection<T> =>\n  define<T>({\n    kind: 'incremental-value',\n    dependencies: definition.dependencies,\n    build: definition.build,\n    isEqual: definition.isEqual as Equality | undefined,\n    name: definition.name,\n  });\n\nexport const defineIncrementalCollection = <K extends string, V>(definition: {\n  readonly dependencies: GraphSources;\n  readonly build: (...args: never[]) => unknown;\n  readonly isEqual?: (a: V, b: V) => boolean;\n  readonly name?: string;\n}): CollectionProjection<K, V> =>\n  define<PublicCollection<K, V>, CollectionChange<K, V>>({\n    kind: 'incremental-collection',\n    dependencies: definition.dependencies,\n    build: definition.build,\n    isEqual: definition.isEqual as Equality | undefined,\n    name: definition.name,\n  });\n\n// Internal event names remain private implementation detail and are not root exports.\nexport type InternalDocumentEvent<S extends ObjectNode> = DocumentContext<S>;\nexport type InternalValueEvent<T, D = unknown> = ValueContext<T, D>;\nexport type InternalCollectionEvent<K extends string, V, D = unknown> = CollectionContext<K, V, D>;\nexport type InternalCollectionTransition<K extends string, V> = CollectionEntryTransition<K, V>;\nexport type InternalCollectionDraft<K extends string, V> = CollectionDraft<K, V>;\nexport type InternalBatchContext = BatchContext;\nexport type InternalCause = Cause;\nexport type InternalInputHandles<S extends GraphSources> = InputHandles<S>;\nexport type InternalNodeUpdate<T> = NodeUpdate<T>;\nexport type InternalCollectionRead<K extends string, V> = CollectionRead<K, V>;\n"],"mappings":";AAkGA,MAAM,8BAAc,IAAI,SAA6B;AAErD,MAAM,UAA4B,eAA6C;CAC7E,MAAM,SAAS,OAAO,OAAO,EAAE,CAAC;AAChC,aAAY,IAAI,QAAQ,WAAW;AACnC,QAAO;;AAGT,MAAa,gBAAgB,eAAiD;CAC5E,MAAM,aAAa,YAAY,IAAI,WAAW;AAC9C,KAAI,CAAC,WAAY,OAAM,IAAI,UAAU,iCAAiC;AACtE,QAAO;;AAGT,MAAa,SACX,SACA,WAA8C,OAAO,OACxC,OAAU;CAAE,MAAM;CAAS;CAAS,SAAS;CAAsB,CAAC;AAqBnF,SAAgB,QACd,UAKA,UAC8B;AAC9B,KAAI,iBAAiB,SAAS,CAC5B,QAAO,SAAS,SAAS,eACrB,yBAAyB,SAAS,GAClC,oBAAoB,SAAS;AACnC,KAAI,aAAa,YAAY,OAAO,SAAS,YAAY,WACvD,QAAO,eAAe,SAA8B;AACtD,QAAO,OAAO;EACZ,MAAM;EACI;EACA;EACX,CAAC;;AAGJ,MAAM,oBACJ,WAE8F;AAC9F,KAAI,CAAC,UAAU,OAAO,WAAW,SAAU,QAAO;CAClD,MAAM,YAAY;AAMlB,SACG,UAAU,SAAS,WAAW,UAAU,SAAS,iBAClD,OAAO,UAAU,YAAY,cAC7B,OAAO,UAAU,aAAa,cAC9B,OAAO,UAAU,cAAc;;AAInC,SAAgB,OACd,cACA,SACA,WAA8C,OAAO,IACtC;AACf,KAAI,CAAC,MAAM,QAAQ,aAAa,IAAI,aAAa,MAAK,UAAS,CAAC,YAAY,IAAI,MAAM,CAAC,CACrF,OAAM,IAAI,UAAU,2CAA2C;AAEjE,QAAO,OAAU;EACf,MAAM;EACN,cAHa,OAAO,OAAO,CAAC,GAAG,aAAa,CAGxB;EACX;EACT,SAAS;EACV,CAAC;;;AAIJ,MAAa,kBACX,UACA,WAAoC,OAAO,OACzB,OAAU;CAAE,MAAM;CAAY;CAAU,SAAS;CAAsB,CAAC;AAE5F,MAAa,uBAA6B,WACxC,OAAU;CAAE,MAAM;CAAwB;CAAiB,CAAC;AAE9D,MAAa,4BACX,WAEA,OAAuD;CACrD,MAAM;CACE;CACT,CAAC;AAQJ,MAAa,0BAA6B,eAMxC,OAAU;CACR,MAAM;CACN,cAAc,WAAW;CACzB,OAAO,WAAW;CAClB,SAAS,WAAW;CACpB,MAAM,WAAW;CAClB,CAAC;AAEJ,MAAa,+BAAoD,eAM/D,OAAuD;CACrD,MAAM;CACN,cAAc,WAAW;CACzB,OAAO,WAAW;CAClB,SAAS,WAAW;CACpB,MAAM,WAAW;CAClB,CAAC"}

package/dist/definition-c6XQXzvK.js

@@ -0,0 +1,72 @@
+//#region core/src/projection/definition.ts
+const definitions = /* @__PURE__ */ new WeakMap();
+const define = (definition) => {
+	const handle = Object.freeze({});
+	definitions.set(handle, definition);
+	return handle;
+};
+const definitionOf = (projection) => {
+	const definition = definitions.get(projection);
+	if (!definition) throw new TypeError("Unknown projection definition.");
+	return definition;
+};
+const input = (initial, equality = Object.is) => define({
+	kind: "input",
+	initial,
+	isEqual: equality
+});
+function observe(document, selector) {
+	if (isExternalSource(document)) return document.kind === "collection" ? defineExternalCollection(document) : defineExternalValue(document);
+	if ("current" in document && typeof document.current === "function") return defineReadable(document);
+	return define({
+		kind: "document",
+		document,
+		selector
+	});
+}
+const isExternalSource = (source) => {
+	if (!source || typeof source !== "object") return false;
+	const candidate = source;
+	return (candidate.kind === "value" || candidate.kind === "collection") && typeof candidate.current === "function" && typeof candidate.revision === "function" && typeof candidate.subscribe === "function";
+};
+function derive(dependencies, compute, equality = Object.is) {
+	if (!Array.isArray(dependencies) || dependencies.some((value) => !definitions.has(value))) throw new TypeError("derive dependencies must be projections.");
+	return define({
+		kind: "derive",
+		dependencies: Object.freeze([...dependencies]),
+		compute,
+		isEqual: equality
+	});
+}
+/** Internal source adapters used by observe, not exported publicly. */
+const defineReadable = (readable, equality = Object.is) => define({
+	kind: "readable",
+	readable,
+	isEqual: equality
+});
+const defineExternalValue = (source) => define({
+	kind: "source-value",
+	source
+});
+const defineExternalCollection = (source) => define({
+	kind: "source-collection",
+	source
+});
+const defineIncrementalValue = (definition) => define({
+	kind: "incremental-value",
+	dependencies: definition.dependencies,
+	build: definition.build,
+	isEqual: definition.isEqual,
+	name: definition.name
+});
+const defineIncrementalCollection = (definition) => define({
+	kind: "incremental-collection",
+	dependencies: definition.dependencies,
+	build: definition.build,
+	isEqual: definition.isEqual,
+	name: definition.name
+});
+//#endregion
+export { input as a, derive as i, defineIncrementalValue as n, observe as o, definitionOf as r, defineIncrementalCollection as t };
+
+//# sourceMappingURL=definition-c6XQXzvK.js.map

package/dist/definition-c6XQXzvK.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-c6XQXzvK.js","names":[],"sources":["../core/src/projection/definition.ts"],"sourcesContent":["import type { DocumentReadable, Synchronous } from '../runtime/contract';\nimport type {\n  CollectionId,\n  CollectionPath,\n  CollectionNode as SchemaCollectionNode,\n  Infer,\n  ObjectNode,\n  ReadonlyValue,\n  SchemaPath,\n  PathValueOf,\n} from '../schema';\nimport type { Readable } from './readable';\nimport type {\n  BatchContext,\n  Cause,\n  CollectionContext,\n  CollectionChange,\n  CollectionDraft,\n  CollectionRead,\n  CollectionEntryTransition,\n  DocumentContext,\n  ExternalCollectionSource,\n  ExternalValueSource,\n  GraphSources,\n  InputHandles,\n  NodeUpdate,\n  ValueContext,\n} from './contract';\n\ndeclare const projectionDefinition: unique symbol;\ndeclare const projectionChanges: unique symbol;\ndeclare const writableInput: unique symbol;\n\n/** A lazy, reusable projection definition. Its value is materialized per runtime. */\nexport type Projection<T, C = undefined> = {\n  readonly [projectionDefinition]: T;\n  readonly [projectionChanges]: C;\n};\n\n/** A runtime-local writable projection definition. */\nexport type Input<T> = Projection<T> & { readonly [writableInput]: true };\n\nexport type ProjectionValues<D extends readonly Projection<unknown, unknown>[]> = {\n  readonly [K in keyof D]: D[K] extends Projection<infer T, unknown> ? T : never;\n};\n\nexport type ProjectionChanges<D extends readonly Projection<unknown, unknown>[]> = {\n  readonly [K in keyof D]: D[K] extends Projection<unknown, infer C>\n    ? [C] extends [undefined]\n      ? undefined\n      : C | undefined\n    : undefined;\n};\n\nexport type PublicCollection<K extends string, V> = ReadonlyMap<K, V>;\nexport type CollectionProjection<K extends string, V> = Projection<\n  PublicCollection<K, V>,\n  CollectionChange<K, V>\n>;\n\ntype Equality = (a: unknown, b: unknown) => boolean;\ntype PathSelector<S extends ObjectNode> = (path: SchemaPath<S['shape']>) => unknown;\n\ntype Definition =\n  | { readonly kind: 'input'; readonly initial: unknown; readonly isEqual?: Equality }\n  | { readonly kind: 'readable'; readonly readable: Readable<unknown>; readonly isEqual?: Equality }\n  | { readonly kind: 'source-value'; readonly source: ExternalValueSource<unknown, unknown> }\n  | {\n      readonly kind: 'source-collection';\n      readonly source: ExternalCollectionSource<string, unknown, unknown>;\n    }\n  | {\n      readonly kind: 'document';\n      readonly document: DocumentReadable<ObjectNode>;\n      readonly selector?: PathSelector<ObjectNode>;\n    }\n  | {\n      readonly kind: 'derive';\n      readonly dependencies: readonly Projection<unknown, unknown>[];\n      readonly compute: (...values: readonly unknown[]) => unknown;\n      readonly isEqual?: Equality;\n    }\n  | {\n      readonly kind: 'incremental-value';\n      readonly dependencies: GraphSources;\n      readonly build: (...args: never[]) => unknown;\n      readonly isEqual?: Equality;\n      readonly name?: string;\n    }\n  | {\n      readonly kind: 'incremental-collection';\n      readonly dependencies: GraphSources;\n      readonly build: (...args: never[]) => unknown;\n      readonly isEqual?: Equality;\n      readonly name?: string;\n    };\n\ntype DefinitionProjection = Projection<unknown, unknown>;\nconst definitions = new WeakMap<object, Definition>();\n\nconst define = <T, C = undefined>(definition: Definition): Projection<T, C> => {\n  const handle = Object.freeze({}) as Projection<T, C>;\n  definitions.set(handle, definition);\n  return handle;\n};\n\nexport const definitionOf = (projection: DefinitionProjection): Definition => {\n  const definition = definitions.get(projection);\n  if (!definition) throw new TypeError('Unknown projection definition.');\n  return definition;\n};\n\nexport const input = <T>(\n  initial: T,\n  equality: (previous: T, next: T) => boolean = Object.is\n): Input<T> => define<T>({ kind: 'input', initial, isEqual: equality as Equality }) as Input<T>;\n\n/**\n * Establishes a reactive boundary from a document, readable, or external\n * source. The selector is compiled when the definition is materialized, so\n * declarations stay lazy and reusable.\n */\nexport function observe<S extends ObjectNode>(document: DocumentReadable<S>): Projection<Infer<S>>;\nexport function observe<T, D>(source: ExternalValueSource<T, D>): Projection<T>;\nexport function observe<K extends string, V, D>(\n  source: ExternalCollectionSource<K, V, D>\n): CollectionProjection<K, V>;\nexport function observe<T>(readable: Readable<T>): Projection<T>;\nexport function observe<S extends ObjectNode, P extends CollectionPath>(\n  document: DocumentReadable<S>,\n  selector: (path: SchemaPath<S['shape']>) => P\n): CollectionProjection<CollectionId<P>, ReadonlyValue<Infer<SchemaCollectionNode<P>>>>;\nexport function observe<S extends ObjectNode, P>(\n  document: DocumentReadable<S>,\n  selector: (path: SchemaPath<S['shape']>) => P\n): Projection<PathValueOf<P>>;\nexport function observe<S extends ObjectNode>(\n  document:\n    | DocumentReadable<S>\n    | Readable<unknown>\n    | ExternalValueSource<unknown, unknown>\n    | ExternalCollectionSource<string, unknown, unknown>,\n  selector?: PathSelector<S>\n): Projection<unknown, unknown> {\n  if (isExternalSource(document))\n    return document.kind === 'collection'\n      ? defineExternalCollection(document)\n      : defineExternalValue(document);\n  if ('current' in document && typeof document.current === 'function')\n    return defineReadable(document as Readable<unknown>);\n  return define({\n    kind: 'document',\n    document: document as DocumentReadable<ObjectNode>,\n    selector: selector as PathSelector<ObjectNode> | undefined,\n  });\n}\n\nconst isExternalSource = (\n  source: unknown\n): source is\n  ExternalValueSource<unknown, unknown> | ExternalCollectionSource<string, unknown, unknown> => {\n  if (!source || typeof source !== 'object') return false;\n  const candidate = source as {\n    readonly kind?: unknown;\n    readonly current?: unknown;\n    readonly revision?: unknown;\n    readonly subscribe?: unknown;\n  };\n  return (\n    (candidate.kind === 'value' || candidate.kind === 'collection') &&\n    typeof candidate.current === 'function' &&\n    typeof candidate.revision === 'function' &&\n    typeof candidate.subscribe === 'function'\n  );\n};\n\nexport function derive<const D extends readonly Projection<unknown, unknown>[], T>(\n  dependencies: D,\n  compute: (...values: ProjectionValues<D>) => Synchronous<T>,\n  equality: (previous: T, next: T) => boolean = Object.is\n): Projection<T> {\n  if (!Array.isArray(dependencies) || dependencies.some(value => !definitions.has(value)))\n    throw new TypeError('derive dependencies must be projections.');\n  const frozen = Object.freeze([...dependencies]) as readonly Projection<unknown, unknown>[];\n  return define<T>({\n    kind: 'derive',\n    dependencies: frozen,\n    compute: compute as (...values: readonly unknown[]) => unknown,\n    isEqual: equality as Equality,\n  });\n}\n\n/** Internal source adapters used by observe, not exported publicly. */\nexport const defineReadable = <T>(\n  readable: Readable<T>,\n  equality: (a: T, b: T) => boolean = Object.is\n): Projection<T> => define<T>({ kind: 'readable', readable, isEqual: equality as Equality });\n\nexport const defineExternalValue = <T, D>(source: ExternalValueSource<T, D>): Projection<T> =>\n  define<T>({ kind: 'source-value', source: source as never });\n\nexport const defineExternalCollection = <K extends string, V, D>(\n  source: ExternalCollectionSource<K, V, D>\n): CollectionProjection<K, V> =>\n  define<PublicCollection<K, V>, CollectionChange<K, V>>({\n    kind: 'source-collection',\n    source: source as never,\n  });\n\nexport type IncrementalValueDefinition = Extract<Definition, { kind: 'incremental-value' }>;\nexport type IncrementalCollectionDefinition = Extract<\n  Definition,\n  { kind: 'incremental-collection' }\n>;\n\nexport const defineIncrementalValue = <T>(definition: {\n  readonly dependencies: GraphSources;\n  readonly build: (...args: never[]) => unknown;\n  readonly isEqual?: (a: T, b: T) => boolean;\n  readonly name?: string;\n}): Projection<T> =>\n  define<T>({\n    kind: 'incremental-value',\n    dependencies: definition.dependencies,\n    build: definition.build,\n    isEqual: definition.isEqual as Equality | undefined,\n    name: definition.name,\n  });\n\nexport const defineIncrementalCollection = <K extends string, V>(definition: {\n  readonly dependencies: GraphSources;\n  readonly build: (...args: never[]) => unknown;\n  readonly isEqual?: (a: V, b: V) => boolean;\n  readonly name?: string;\n}): CollectionProjection<K, V> =>\n  define<PublicCollection<K, V>, CollectionChange<K, V>>({\n    kind: 'incremental-collection',\n    dependencies: definition.dependencies,\n    build: definition.build,\n    isEqual: definition.isEqual as Equality | undefined,\n    name: definition.name,\n  });\n\n// Internal event names remain private implementation detail and are not root exports.\nexport type InternalDocumentEvent<S extends ObjectNode> = DocumentContext<S>;\nexport type InternalValueEvent<T, D = unknown> = ValueContext<T, D>;\nexport type InternalCollectionEvent<K extends string, V, D = unknown> = CollectionContext<K, V, D>;\nexport type InternalCollectionTransition<K extends string, V> = CollectionEntryTransition<K, V>;\nexport type InternalCollectionDraft<K extends string, V> = CollectionDraft<K, V>;\nexport type InternalBatchContext = BatchContext;\nexport type InternalCause = Cause;\nexport type InternalInputHandles<S extends GraphSources> = InputHandles<S>;\nexport type InternalNodeUpdate<T> = NodeUpdate<T>;\nexport type InternalCollectionRead<K extends string, V> = CollectionRead<K, V>;\n"],"mappings":";AAkGA,MAAM,8BAAc,IAAI,SAA6B;AAErD,MAAM,UAA4B,eAA6C;CAC7E,MAAM,SAAS,OAAO,OAAO,EAAE,CAAC;AAChC,aAAY,IAAI,QAAQ,WAAW;AACnC,QAAO;;AAGT,MAAa,gBAAgB,eAAiD;CAC5E,MAAM,aAAa,YAAY,IAAI,WAAW;AAC9C,KAAI,CAAC,WAAY,OAAM,IAAI,UAAU,iCAAiC;AACtE,QAAO;;AAGT,MAAa,SACX,SACA,WAA8C,OAAO,OACxC,OAAU;CAAE,MAAM;CAAS;CAAS,SAAS;CAAsB,CAAC;AAqBnF,SAAgB,QACd,UAKA,UAC8B;AAC9B,KAAI,iBAAiB,SAAS,CAC5B,QAAO,SAAS,SAAS,eACrB,yBAAyB,SAAS,GAClC,oBAAoB,SAAS;AACnC,KAAI,aAAa,YAAY,OAAO,SAAS,YAAY,WACvD,QAAO,eAAe,SAA8B;AACtD,QAAO,OAAO;EACZ,MAAM;EACI;EACA;EACX,CAAC;;AAGJ,MAAM,oBACJ,WAE8F;AAC9F,KAAI,CAAC,UAAU,OAAO,WAAW,SAAU,QAAO;CAClD,MAAM,YAAY;AAMlB,SACG,UAAU,SAAS,WAAW,UAAU,SAAS,iBAClD,OAAO,UAAU,YAAY,cAC7B,OAAO,UAAU,aAAa,cAC9B,OAAO,UAAU,cAAc;;AAInC,SAAgB,OACd,cACA,SACA,WAA8C,OAAO,IACtC;AACf,KAAI,CAAC,MAAM,QAAQ,aAAa,IAAI,aAAa,MAAK,UAAS,CAAC,YAAY,IAAI,MAAM,CAAC,CACrF,OAAM,IAAI,UAAU,2CAA2C;AAEjE,QAAO,OAAU;EACf,MAAM;EACN,cAHa,OAAO,OAAO,CAAC,GAAG,aAAa,CAGxB;EACX;EACT,SAAS;EACV,CAAC;;;AAIJ,MAAa,kBACX,UACA,WAAoC,OAAO,OACzB,OAAU;CAAE,MAAM;CAAY;CAAU,SAAS;CAAsB,CAAC;AAE5F,MAAa,uBAA6B,WACxC,OAAU;CAAE,MAAM;CAAwB;CAAiB,CAAC;AAE9D,MAAa,4BACX,WAEA,OAAuD;CACrD,MAAM;CACE;CACT,CAAC;AAQJ,MAAa,0BAA6B,eAMxC,OAAU;CACR,MAAM;CACN,cAAc,WAAW;CACzB,OAAO,WAAW;CAClB,SAAS,WAAW;CACpB,MAAM,WAAW;CAClB,CAAC;AAEJ,MAAa,+BAAoD,eAM/D,OAAuD;CACrD,MAAM;CACN,cAAc,WAAW;CACzB,OAAO,WAAW;CAClB,SAAS,WAAW;CACpB,MAAM,WAAW;CAClB,CAAC"}