doxum 0.1.16 → 0.1.17

package/dist/definition-BdLGD8Rq.d.ts

@@ -0,0 +1,101 @@
+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, reusable projection definition with no runtime-owned state. */
+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, 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>;
+/** 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<D>) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): Projection<T>;
+//#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

package/dist/definition-Bf8Z7xtX.d.cts

@@ -0,0 +1,101 @@
+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, reusable projection definition with no runtime-owned state. */
+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, 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>;
+/** 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<D>) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): Projection<T>;
+//#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

package/dist/{definition-c6XQXzvK.js → definition-DUo1lfQ8.js}

@@ -38,7 +38,6 @@ function derive(dependencies, compute, equality = Object.is) {
 		isEqual: equality
 	});
 }
-/** Internal source adapters used by observe, not exported publicly. */
 const defineReadable = (readable, equality = Object.is) => define({
 	kind: "readable",
 	readable,
@@ -69,4 +68,4 @@ const defineIncrementalCollection = (definition) => define({
 //#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
+//# sourceMappingURL=definition-DUo1lfQ8.js.map

package/dist/definition-DUo1lfQ8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-DUo1lfQ8.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  CollectionChange,\n  ExternalCollectionSource,\n  ExternalValueSource,\n  GraphSources,\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 with no runtime-owned state. */\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\ntype ProjectionValues<D extends readonly Projection<unknown, unknown>[]> = {\n  readonly [K in keyof D]: D[K] extends Projection<infer T, unknown> ? T : never;\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> }\n  | {\n      readonly kind: 'source-collection';\n      readonly source: ExternalCollectionSource<string, 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/** Establish a lazy reactive boundary from a document, readable, or external source. */\nexport function observe<S extends ObjectNode>(document: DocumentReadable<S>): Projection<Infer<S>>;\nexport function observe<T>(source: ExternalValueSource<T>): Projection<T>;\nexport function observe<K extends string, V>(\n  source: ExternalCollectionSource<K, V>\n): Projection<ReadonlyMap<K, V>, CollectionChange<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): Projection<\n  ReadonlyMap<CollectionId<P>, ReadonlyValue<Infer<SchemaCollectionNode<P>>>>,\n  CollectionChange<CollectionId<P>, ReadonlyValue<Infer<SchemaCollectionNode<P>>>>\n>;\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>\n    | ExternalCollectionSource<string, 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 ExternalValueSource<unknown> | ExternalCollectionSource<string, 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\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>(source: ExternalValueSource<T>): Projection<T> =>\n  define<T>({ kind: 'source-value', source: source as ExternalValueSource<unknown> });\n\nexport const defineExternalCollection = <K extends string, V>(\n  source: ExternalCollectionSource<K, V>\n): Projection<ReadonlyMap<K, V>, CollectionChange<K, V>> =>\n  define<ReadonlyMap<K, V>, CollectionChange<K, V>>({\n    kind: 'source-collection',\n    source: source as unknown as ExternalCollectionSource<string, unknown>,\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}): Projection<ReadonlyMap<K, V>, CollectionChange<K, V>> =>\n  define<ReadonlyMap<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"],"mappings":";AA0EA,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;AAoBnF,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,WACuF;AACvF,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;;AAGJ,MAAa,kBACX,UACA,WAAoC,OAAO,OACzB,OAAU;CAAE,MAAM;CAAY;CAAU,SAAS;CAAsB,CAAC;AAE5F,MAAa,uBAA0B,WACrC,OAAU;CAAE,MAAM;CAAwB;CAAwC,CAAC;AAErF,MAAa,4BACX,WAEA,OAAkD;CAChD,MAAM;CACE;CACT,CAAC;AAEJ,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,OAAkD;CAChD,MAAM;CACN,cAAc,WAAW;CACzB,OAAO,WAAW;CAClB,SAAS,WAAW;CACpB,MAAM,WAAW;CAClB,CAAC"}

package/dist/{definition-Z6TagMup.cjs → definition-De6rhTlZ.cjs}

@@ -38,7 +38,6 @@ function derive(dependencies, compute, equality = Object.is) {
 		isEqual: equality
 	});
 }
-/** Internal source adapters used by observe, not exported publicly. */
 const defineReadable = (readable, equality = Object.is) => define({
 	kind: "readable",
 	readable,
@@ -104,4 +103,4 @@ Object.defineProperty(exports, "observe", {
 	}
 });
 
-//# sourceMappingURL=definition-Z6TagMup.cjs.map
+//# sourceMappingURL=definition-De6rhTlZ.cjs.map

package/dist/definition-De6rhTlZ.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-De6rhTlZ.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  CollectionChange,\n  ExternalCollectionSource,\n  ExternalValueSource,\n  GraphSources,\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 with no runtime-owned state. */\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\ntype ProjectionValues<D extends readonly Projection<unknown, unknown>[]> = {\n  readonly [K in keyof D]: D[K] extends Projection<infer T, unknown> ? T : never;\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> }\n  | {\n      readonly kind: 'source-collection';\n      readonly source: ExternalCollectionSource<string, 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/** Establish a lazy reactive boundary from a document, readable, or external source. */\nexport function observe<S extends ObjectNode>(document: DocumentReadable<S>): Projection<Infer<S>>;\nexport function observe<T>(source: ExternalValueSource<T>): Projection<T>;\nexport function observe<K extends string, V>(\n  source: ExternalCollectionSource<K, V>\n): Projection<ReadonlyMap<K, V>, CollectionChange<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): Projection<\n  ReadonlyMap<CollectionId<P>, ReadonlyValue<Infer<SchemaCollectionNode<P>>>>,\n  CollectionChange<CollectionId<P>, ReadonlyValue<Infer<SchemaCollectionNode<P>>>>\n>;\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>\n    | ExternalCollectionSource<string, 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 ExternalValueSource<unknown> | ExternalCollectionSource<string, 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\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>(source: ExternalValueSource<T>): Projection<T> =>\n  define<T>({ kind: 'source-value', source: source as ExternalValueSource<unknown> });\n\nexport const defineExternalCollection = <K extends string, V>(\n  source: ExternalCollectionSource<K, V>\n): Projection<ReadonlyMap<K, V>, CollectionChange<K, V>> =>\n  define<ReadonlyMap<K, V>, CollectionChange<K, V>>({\n    kind: 'source-collection',\n    source: source as unknown as ExternalCollectionSource<string, unknown>,\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}): Projection<ReadonlyMap<K, V>, CollectionChange<K, V>> =>\n  define<ReadonlyMap<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"],"mappings":";AA0EA,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;AAoBnF,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,WACuF;AACvF,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;;AAGJ,MAAa,kBACX,UACA,WAAoC,OAAO,OACzB,OAAU;CAAE,MAAM;CAAY;CAAU,SAAS;CAAsB,CAAC;AAE5F,MAAa,uBAA0B,WACrC,OAAU;CAAE,MAAM;CAAwB;CAAwC,CAAC;AAErF,MAAa,4BACX,WAEA,OAAkD;CAChD,MAAM;CACE;CACT,CAAC;AAEJ,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,OAAkD;CAChD,MAAM;CACN,cAAc,WAAW;CACzB,OAAO,WAAW;CAClB,SAAS,WAAW;CACpB,MAAM,WAAW;CAClB,CAAC"}