@party-stack/ontology 0.19.1 → 0.21.0

package/lib/tanstack/collections.js

@@ -0,0 +1,495 @@
+import { registerCollectionDemands } from "./diagnostics.js";
+import { analyzeOntologySubset, analyzeStorageSubset, ontologySubset, storageSubset } from "./subset.js";
+import { Runtime } from "@party-stack/runtime";
+import { Deferred, Effect, Exit, Fiber, Queue, Scope, Stream } from "effect";
+import { BasicIndex, IR, collectionOptions, createCollection, whenSyncAccepted } from "@tanstack/db";
+import { Table } from "@party-stack/ontology-storage/tables";
+import { coversSubset } from "@party-stack/ontology-backend/subset";
+import { readVisibleRevision } from "@party-stack/ontology-replica/infrastructure";
+//#region src/tanstack/collections.ts
+function lookupKeys(subset, primaryKey) {
+	if (!primaryKey || subset.offset || subset.cursor || subset.where?.type !== "func") return;
+	const { name, args } = subset.where;
+	const field = (value) => value?.type === "ref" && IR.getPropRefPropertyPath(value).length === 1 && IR.getPropRefPropertyPath(value)[0] === primaryKey;
+	const key = (value) => typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+	if (name === "eq") {
+		const value = field(args[0]) ? args[1] : field(args[1]) ? args[0] : void 0;
+		return value?.type === "val" && key(value.value) ? [value.value] : void 0;
+	}
+	if (name === "in" && field(args[0]) && args[1]?.type === "val") {
+		const values = args[1].value;
+		return Array.isArray(values) && values.every(key) ? values : void 0;
+	}
+}
+/** Options creators are Effects: their callback fibers and subscriptions belong to the caller's scope. */
+const persistedCollectionOptions = (options) => collectionOptionsImpl(options);
+const collectionOptionsImpl = Effect.fnUntraced(function* (options, native) {
+	const observing = options.observe !== void 0 || native !== void 0;
+	const scope = yield* Effect.scope;
+	const context = yield* Effect.context();
+	let active = true;
+	yield* Effect.addFinalizer(() => Effect.sync(() => {
+		active = false;
+	}));
+	const run = (effect, owner = scope) => !active || owner.state._tag === "Closed" ? Promise.reject(/* @__PURE__ */ new Error("Collection scope is closed.")) : Effect.runPromiseWith(context)(Effect.flatMap(Effect.forkIn(effect, owner, { startImmediately: observing }), Fiber.join));
+	let refresh;
+	let queried = false;
+	const persist = options.persist ? async ({ transaction, collection }) => {
+		await run(options.persist(transaction.mutations.filter((mutation) => mutation.collection === collection)));
+		await refresh?.();
+	} : () => Promise.reject(/* @__PURE__ */ new Error("This collection is read-only. Use ontology actions to mutate it."));
+	return {
+		id: options.id,
+		getKey: options.getKey,
+		defaultIndexType: BasicIndex,
+		autoIndex: "eager",
+		defaultStringCollation: { stringSort: "lexical" },
+		syncMode: "on-demand",
+		startSync: true,
+		onInsert: persist,
+		onUpdate: persist,
+		onDelete: persist,
+		sync: {
+			rowUpdateMode: "full",
+			supportsOrderedWindow: options.supportsOrderedWindow,
+			sync: ({ begin, write, commit, markReady, fail, collection }) => {
+				const runScope = Effect.runSync(Scope.fork(scope));
+				let alive = true;
+				let tail;
+				const releasing = /* @__PURE__ */ new Set();
+				const demands = /* @__PURE__ */ new Map();
+				const observations = /* @__PURE__ */ new Map();
+				const releaseDiagnostics = options.describeSubset ? registerCollectionDemands(collection, () => [...demands.values()].map(({ subset, received, settled }) => ({
+					...options.describeSubset(subset),
+					subscription: subset.subscription,
+					received,
+					ready: settled
+				}))) : void 0;
+				const codec = Table.make({ name: "collection-value" });
+				const fingerprint = (value) => {
+					try {
+						return codec.encode(value);
+					} catch {
+						return;
+					}
+				};
+				const installed = new Map([...collection.entries()].map(([key, value]) => [key, fingerprint(value)]));
+				const dirtyKeys = /* @__PURE__ */ new Set();
+				let reconcileInstalled = installed.size > 0;
+				const stop = (error) => {
+					if (!alive || !active) return;
+					alive = false;
+					fail(error);
+					for (const demand of demands.values()) demand.release();
+					const closing = Effect.runPromise(Scope.close(runScope, Exit.void));
+					releasing.add(closing);
+					closing.finally(() => releasing.delete(closing)).catch(() => void 0);
+				};
+				const writeRows = async (rows, changed) => {
+					if (!active || !alive) return;
+					const stale = /* @__PURE__ */ new Set();
+					for (const key of changed ?? installed.keys()) if (installed.has(key) && !rows.has(key)) stale.add(key);
+					const updates = (changed ? [...changed].flatMap((key) => rows.has(key) ? [[key, rows.get(key)]] : []) : [...rows]).filter(([key, value]) => {
+						const encoded = fingerprint(value);
+						return encoded === void 0 || installed.get(key) !== encoded;
+					});
+					if (observing && [...demands.values()].some((demand) => !demand.received)) {
+						if (stale.size) reconcileInstalled = true;
+						stale.clear();
+					} else if (reconcileInstalled) {
+						for (const key of installed.keys()) if (!rows.has(key)) stale.add(key);
+						reconcileInstalled = false;
+					}
+					if (!updates.length && !stale.size) return;
+					begin();
+					for (const [key, value] of updates) write({
+						type: installed.has(key) ? "update" : "insert",
+						value
+					});
+					for (const key of stale) write({
+						type: "delete",
+						key
+					});
+					const receipt = commit();
+					await whenSyncAccepted(receipt);
+					for (const key of stale) installed.delete(key);
+					for (const [key, value] of updates) installed.set(key, fingerprint(value));
+				};
+				const load = () => {
+					const work = async () => {
+						if (!active || !alive) return;
+						const changed = observing ? new Set(dirtyKeys) : void 0;
+						dirtyKeys.clear();
+						const rows = /* @__PURE__ */ new Map();
+						if (observing) for (const demand of demands.values()) {
+							if (!demand.received) continue;
+							for (const [key, value] of demand.rows) rows.set(key, value);
+						}
+						else {
+							if (typeof options.load !== "function") for (const row of await run(options.load)) rows.set(row.key, row.value);
+							for (const [key, demand] of demands) {
+								if (typeof options.load !== "function") break;
+								const loaded = await run(options.load(demand.subset));
+								if (demands.get(key) !== demand) continue;
+								for (const row of loaded) rows.set(row.key, row.value);
+							}
+						}
+						await writeRows(rows, changed);
+					};
+					let start;
+					const next = new Promise((resolve, reject) => {
+						start = () => {
+							work().then(resolve, reject);
+						};
+					});
+					const previous = tail;
+					tail = next;
+					const finish = () => {
+						if (tail === next) tail = void 0;
+					};
+					next.then(finish, finish);
+					if (previous) previous.then(start, start);
+					else if (observing) start();
+					else Promise.resolve().then(start);
+					return next;
+				};
+				const close = (owner) => {
+					const closing = Effect.runPromise(Scope.close(owner, Exit.void));
+					releasing.add(closing);
+					closing.then(() => releasing.delete(closing), (error) => {
+						releasing.delete(closing);
+						stop(error);
+					});
+				};
+				const publishObservation = async (group, batch) => {
+					if (!alive || !active || observations.get(group.key) !== group) return;
+					let changed = false;
+					if (batch) {
+						if (batch.reset) {
+							for (const key of group.rows.keys()) dirtyKeys.add(key);
+							changed = group.rows.size > 0;
+							group.rows.clear();
+						}
+						for (const key of batch.removed) {
+							if (!group.rows.delete(key)) continue;
+							dirtyKeys.add(key);
+							changed = true;
+						}
+						for (const row of batch.rows) {
+							dirtyKeys.add(row.key);
+							group.rows.set(row.key, row.value);
+							changed = true;
+						}
+						group.revision = batch.revision;
+					}
+					let admitted = false;
+					for (const member of group.members) {
+						if (member.received || group.revision === void 0 || group.revision < member.requiredRevision) continue;
+						member.received = true;
+						admitted = true;
+						for (const key of group.rows.keys()) dirtyKeys.add(key);
+					}
+					const published = [...group.members].filter((member) => member.received);
+					if (changed || admitted || reconcileInstalled) await load();
+					for (const member of published) {
+						if (!alive || !active || !group.members.has(member)) continue;
+						if (member.keys?.every((key) => group.rows.has(key))) Effect.runSync(Deferred.succeed(member.available, void 0));
+						Effect.runSync(Deferred.succeed(member.observed, void 0));
+					}
+				};
+				const observeNative = Effect.fnUntraced(function* (demand) {
+					const revision = yield* native.revision;
+					const joined = yield* Effect.uninterruptible(Effect.gen(function* () {
+						if (demands.get(demand.subset) !== demand) return;
+						const key = native.key(demand.subset);
+						let group = observations.get(key);
+						const created = !group;
+						if (!group) {
+							group = {
+								key,
+								scope: Scope.forkUnsafe(runScope),
+								rows: /* @__PURE__ */ new Map(),
+								members: /* @__PURE__ */ new Set()
+							};
+							observations.set(key, group);
+						}
+						const current = group;
+						demand.rows = current.rows;
+						demand.requiredRevision = revision;
+						demand.group = current;
+						current.members.add(demand);
+						if (created) yield* Stream.runForEach(native.observe(demand.subset), (batch) => Effect.tryPromise({
+							try: () => publishObservation(current, batch),
+							catch: (cause) => cause
+						}).pipe(Effect.withSpan("Ontology.collection.publish", { attributes: {
+							collection: options.id,
+							rows: batch.rows.length,
+							removed: batch.removed.length,
+							reset: batch.reset
+						} }))).pipe(Effect.catch((error) => Effect.sync(() => {
+							if (observations.get(key) !== current) return;
+							for (const member of current.members) Effect.runSync(Deferred.fail(member.observed, error));
+							stop(error);
+						})), Effect.interruptible, Effect.forkIn(current.scope, { startImmediately: true }));
+						return {
+							current,
+							created
+						};
+					}));
+					if (!joined) return;
+					const { current, created } = joined;
+					if (!created && current.revision !== void 0 && current.revision >= revision) yield* Effect.tryPromise({
+						try: () => publishObservation(current),
+						catch: (cause) => cause
+					});
+					yield* Deferred.await(demand.observed);
+				});
+				refresh = load;
+				const watcher = run(Effect.forkIn(Stream.runForEach(observing ? Stream.empty : options.changes, () => queried && (demands.size || typeof options.load !== "function") ? Effect.tryPromise({
+					try: load,
+					catch: (cause) => cause
+				}) : Effect.void).pipe(Effect.catch((error) => Effect.sync(() => {
+					stop(error);
+				}))), runScope, { startImmediately: true }), runScope);
+				markReady();
+				return {
+					loadSubset: (subset) => {
+						if (subset.signal?.aborted) return Promise.resolve();
+						queried = true;
+						const keys = lookupKeys(subset, options.primaryKey);
+						let cached = [...demands.values()].some((demand) => demand.settled && !demand.subset.where && demand.subset.limit === void 0 && !demand.subset.offset && !demand.subset.cursor) || [...demands.values()].some((demand) => demand.settled && options.covers?.(subset, demand.subset)) || keys && keys.every((key) => collection.has(key) && [...demands.values()].some((demand) => demand.settled && demand.rows.has(key)));
+						const key = subset;
+						let demand = demands.get(key);
+						if (!demand) {
+							if (!demands.size) reconcileInstalled = true;
+							const child = Effect.runSync(Scope.fork(runScope));
+							const acquire = options.acquireDemand;
+							demand = {
+								scope: child,
+								subset,
+								rows: /* @__PURE__ */ new Map(),
+								received: false,
+								settled: false,
+								ready: Promise.resolve(),
+								available: Effect.runSync(Deferred.make()),
+								observed: Effect.runSync(Deferred.make()),
+								keys,
+								release: () => {
+									subset.signal?.removeEventListener("abort", demand.release);
+									if (!demand || demands.get(key) !== demand) return;
+									if (demand.received) for (const rowKey of demand.rows.keys()) dirtyKeys.add(rowKey);
+									demands.delete(key);
+									const group = demand.group;
+									group?.members.delete(demand);
+									if (group && !group.members.size) {
+										observations.delete(group.key);
+										close(group.scope);
+									}
+									close(child);
+									if (alive && active && demands.size) load().catch(stop);
+								}
+							};
+							demands.set(key, demand);
+							subset.signal?.addEventListener("abort", demand.release, { once: true });
+							demand.ready = run(Scope.provide(Effect.gen(function* () {
+								const acquisition = typeof acquire === "function" ? acquire(subset) : acquire;
+								const acquiring = observing && acquisition ? yield* Effect.forkIn(acquisition, child, { startImmediately: true }) : void 0;
+								if (!observing && acquisition) yield* acquisition;
+								if (native) {
+									const observed = yield* Effect.forkIn(observeNative(demand), child, { startImmediately: true });
+									yield* Effect.all([Fiber.join(observed), ...acquiring ? [Fiber.join(acquiring)] : []], {
+										concurrency: "unbounded",
+										discard: true
+									});
+								} else if (options.observe) {
+									const ready = yield* Deferred.make();
+									yield* Stream.runForEach(options.observe(subset), (batch) => Effect.tryPromise({
+										try: async () => {
+											if (!demand || demands.get(key) !== demand) return;
+											const first = !demand.received;
+											let changed = false;
+											demand.received = true;
+											if (batch.reset) {
+												for (const rowKey of demand.rows.keys()) {
+													dirtyKeys.add(rowKey);
+													changed = true;
+												}
+												demand.rows.clear();
+											}
+											for (const removed of batch.removed) {
+												if (!demand.rows.delete(removed)) continue;
+												dirtyKeys.add(removed);
+												changed = true;
+											}
+											for (const row of batch.rows) {
+												dirtyKeys.add(row.key);
+												demand.rows.set(row.key, row.value);
+												changed = true;
+											}
+											if (first || changed || reconcileInstalled) await load();
+											if (keys?.every((key) => demand.rows.has(key))) Effect.runSync(Deferred.succeed(demand.available, void 0));
+											Effect.runSync(Deferred.succeed(ready, void 0));
+										},
+										catch: (cause) => cause
+									}).pipe(Effect.withSpan("Ontology.collection.publish", { attributes: {
+										collection: options.id,
+										rows: batch.rows.length,
+										removed: batch.removed.length,
+										reset: batch.reset
+									} }))).pipe(Effect.catch((error) => Effect.gen(function* () {
+										yield* Deferred.fail(ready, error);
+										if (alive && active && demands.get(key) === demand) stop(error);
+									})), Effect.forkIn(child, { startImmediately: true }));
+									yield* Effect.all([Deferred.await(ready), ...acquiring ? [Fiber.join(acquiring)] : []], {
+										concurrency: "unbounded",
+										discard: true
+									});
+								}
+							}), child), child);
+							demand.ready.catch((error) => {
+								if ((cached || demand.settled) && demands.get(key) === demand && !subset.signal?.aborted) stop(error);
+								demand.release();
+							});
+						}
+						const current = demand;
+						cached ||= Boolean(keys?.every((key) => current.rows.has(key) && collection.has(key)));
+						if (native && !current.received) cached = false;
+						const completed = Promise.race([current.ready, ...keys ? [run(Deferred.await(current.available), current.scope)] : []]).then(async () => {
+							await load();
+							current.settled = true;
+						});
+						if (cached) {
+							completed.catch((error) => {
+								if (demands.get(key) === current && !subset.signal?.aborted) stop(error);
+							});
+							return true;
+						}
+						return completed;
+					},
+					unloadSubset: (subset) => {
+						demands.get(subset)?.release();
+					},
+					cleanup: async () => {
+						releaseDiagnostics?.();
+						alive = false;
+						refresh = void 0;
+						await watcher.then((fiber) => Effect.runPromise(Fiber.interrupt(fiber)), () => void 0);
+						await Promise.all([...releasing, ...[...demands.values()].map((demand) => {
+							demand.subset.signal?.removeEventListener("abort", demand.release);
+							return Effect.runPromise(Scope.close(demand.scope, Exit.void));
+						})]);
+						demands.clear();
+						observations.clear();
+						dirtyKeys.clear();
+						await Effect.runPromise(Scope.close(runScope, Exit.void));
+					}
+				};
+			}
+		}
+	};
+});
+const localListeners = /* @__PURE__ */ new WeakMap();
+const localChanges = (tables) => {
+	let listeners = localListeners.get(tables);
+	if (!listeners) localListeners.set(tables, listeners = /* @__PURE__ */ new Set());
+	const current = listeners;
+	return {
+		changes: Stream.callback((queue) => Effect.acquireRelease(Effect.sync(() => {
+			const listener = () => {
+				Queue.offerUnsafe(queue, void 0);
+			};
+			current.add(listener);
+			return listener;
+		}), (listener) => Effect.sync(() => {
+			current.delete(listener);
+		})), {
+			bufferSize: 1,
+			strategy: "sliding"
+		}),
+		notify: Effect.sync(() => {
+			for (const listener of current) listener();
+		})
+	};
+};
+const localCollectionOptions = Effect.fnUntraced(function* (options) {
+	const runtime = yield* Runtime;
+	const local = localChanges(runtime.tables);
+	const table = Table.make({
+		name: JSON.stringify([
+			"local",
+			runtime.owner,
+			runtime.namespace,
+			options.name
+		]),
+		version: options.schemaVersion
+	});
+	return yield* persistedCollectionOptions({
+		id: `party-stack:${runtime.owner}:${runtime.namespace}:${options.name}`,
+		getKey: options.getKey,
+		load: (subset) => runtime.tables.query(table, storageSubset(subset)),
+		changes: local.changes,
+		persist: (mutations) => runtime.tables.transaction((tx) => Effect.gen(function* () {
+			for (const mutation of mutations) if (mutation.type === "delete") yield* tx.delete(table, mutation.key);
+			else yield* tx.put(table, mutation.key, mutation.modified);
+		})).pipe(Effect.tap(() => local.notify))
+	});
+});
+const replicatedCollectionOptions = Effect.fnUntraced(function* (options) {
+	const subsetCodec = Table.make({ name: "native-observation-subset" });
+	const revision = readVisibleRevision(options.replica);
+	const observe = (subset) => options.replica.observeSubset(ontologySubset(subset, options.replica.ir, options.objectType)).pipe(Stream.map((batch) => ({
+		...batch,
+		rows: batch.rows.map((row) => ({
+			key: row.key,
+			value: row.value
+		}))
+	})));
+	return yield* collectionOptionsImpl({
+		id: options.id,
+		getKey: options.getKey,
+		primaryKey: options.replica.ir.objectTypes.find((type) => type.name === options.objectType)?.primaryKey,
+		supportsOrderedWindow: (subset) => analyzeOntologySubset(subset, options.replica.ir, options.objectType).orderedWindowExact,
+		covers: (requested, held) => coversSubset({
+			objectType: options.objectType,
+			query: storageSubset(requested, options.replica.ir, options.objectType)
+		}, {
+			objectType: options.objectType,
+			query: storageSubset(held, options.replica.ir, options.objectType)
+		}),
+		describeSubset: (subset) => ({
+			objectType: options.objectType,
+			...analyzeStorageSubset(subset, options.replica.ir, options.objectType),
+			requested: {
+				where: subset.where,
+				orderBy: subset.orderBy,
+				limit: subset.limit,
+				offset: subset.offset,
+				cursor: subset.cursor
+			}
+		}),
+		load: (subset) => Effect.map(options.replica.readSubset(ontologySubset(subset, options.replica.ir, options.objectType)), (rows) => rows.map((row) => ({
+			key: row.key,
+			value: row.value
+		}))),
+		changes: Stream.empty,
+		observe,
+		acquireDemand: (subset) => options.localOnly ? options.replica.demand.acquire(ontologySubset(subset, options.replica.ir, options.objectType), { localOnly: true }) : options.replica.demand.acquire(ontologySubset(subset, options.replica.ir, options.objectType))
+	}, revision ? {
+		key: (subset) => subsetCodec.encode(ontologySubset(subset, options.replica.ir, options.objectType)),
+		revision,
+		observe
+	} : void 0);
+});
+const scopedCollection = (options, client) => client ? Effect.sync(() => client.collection(collectionOptions(options))) : Effect.acquireRelease(Effect.sync(() => createCollection(options)), (collection) => Effect.promise(async () => {
+	await collection.cleanup({ dependents: true });
+}));
+const makeLocalCollection = Effect.fn("Ontology.localCollection")(function* (options) {
+	return yield* scopedCollection(yield* localCollectionOptions(options));
+});
+const makeReplicatedCollection = Effect.fn("Ontology.replicatedCollection")(function* (options, client) {
+	return yield* scopedCollection(yield* replicatedCollectionOptions(options), client);
+});
+//#endregion
+export { localCollectionOptions, makeLocalCollection, makeReplicatedCollection, persistedCollectionOptions, replicatedCollectionOptions, scopedCollection };
+
+//# sourceMappingURL=collections.js.map

package/lib/tanstack/collections.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collections.js","names":[],"sources":["../../src/tanstack/collections.ts"],"sourcesContent":["import { coversSubset } from \"@party-stack/ontology-backend/subset\";\nimport { readVisibleRevision } from \"@party-stack/ontology-replica/infrastructure\";\nimport { Table } from \"@party-stack/ontology-storage/tables\";\nimport { Runtime } from \"@party-stack/runtime\";\nimport { BasicIndex, createCollection, collectionOptions, whenSyncAccepted, IR } from \"@tanstack/db\";\nimport { Deferred, Effect, Exit, Fiber, Scope, Stream, Queue } from \"effect\";\nimport { registerCollectionDemands, type CollectionDemandDiagnostic } from \"./diagnostics.js\";\nimport { analyzeOntologySubset, analyzeStorageSubset, storageSubset, ontologySubset } from \"./subset.js\";\nimport type { ReplicaService } from \"@party-stack/ontology-replica\";\nimport type { Key } from \"@party-stack/ontology-storage\";\nimport type { TablesService } from \"@party-stack/ontology-storage/tables\";\nimport type { CollectionConfig, DbClient, LoadSubsetOptions } from \"@tanstack/db\";\n\ninterface Change<A> {\n    readonly key: Key;\n    readonly type: \"insert\" | \"update\" | \"delete\";\n    readonly modified: A;\n}\n// A present primary-key row is a complete answer, unlike an empty filtered\n// cache. Only reuse rows held by another successfully acquired live demand.\nfunction lookupKeys(subset: LoadSubsetOptions, primaryKey: string | undefined): readonly Key[] | undefined {\n    if (!primaryKey || subset.offset || subset.cursor || subset.where?.type !== \"func\") return;\n    const { name, args } = subset.where;\n    const field = (value: IR.BasicExpression | undefined) =>\n        value?.type === \"ref\" &&\n        IR.getPropRefPropertyPath(value).length === 1 &&\n        IR.getPropRefPropertyPath(value)[0] === primaryKey;\n    const key = (value: unknown): value is Key =>\n        typeof value === \"string\" || (typeof value === \"number\" && Number.isFinite(value));\n    if (name === \"eq\") {\n        const value = field(args[0]) ? args[1] : field(args[1]) ? args[0] : undefined;\n        return value?.type === \"val\" && key(value.value) ? [value.value] : undefined;\n    }\n    if (name === \"in\" && field(args[0]) && args[1]?.type === \"val\") {\n        const values: unknown = args[1].value;\n        return Array.isArray(values) && values.every(key) ? values : undefined;\n    }\n    return;\n}\ninterface RowsBatch<A> {\n    readonly reset: boolean;\n    readonly rows: readonly { key: Key; value: A }[];\n    readonly removed: readonly Key[];\n}\ninterface NativeObservations<A> {\n    readonly key: (subset: LoadSubsetOptions) => string;\n    readonly revision: Effect.Effect<number, unknown>;\n    readonly observe: (\n        subset: LoadSubsetOptions\n    ) => Stream.Stream<RowsBatch<A> & { readonly revision: number }, unknown>;\n}\ninterface PersistedCollectionOptions<A extends object, K extends Key> {\n    readonly id: string;\n    readonly getKey: (value: A) => K;\n    readonly primaryKey?: string;\n    readonly load:\n        | Effect.Effect<readonly { key: Key; value: A }[], unknown>\n        | ((subset: LoadSubsetOptions) => Effect.Effect<readonly { key: Key; value: A }[], unknown>);\n    readonly changes: Stream.Stream<void>;\n    readonly observe?: (subset: LoadSubsetOptions) => Stream.Stream<\n        {\n            readonly reset: boolean;\n            readonly rows: readonly { key: Key; value: A }[];\n            readonly removed: readonly Key[];\n        },\n        unknown\n    >;\n    readonly persist?: (mutations: readonly Change<A>[]) => Effect.Effect<void, unknown>;\n    readonly acquireDemand?:\n        | Effect.Effect<void, unknown, Scope.Scope>\n        | ((subset: LoadSubsetOptions) => Effect.Effect<void, unknown, Scope.Scope>);\n    readonly describeSubset?: (subset: LoadSubsetOptions) => Omit<CollectionDemandDiagnostic, \"subscription\">;\n    /** Compare the regions actually acquired by this source, after residual\n     * filters/order have widened them. No inference from cached row contents.\n     */\n    readonly covers?: (requested: LoadSubsetOptions, held: LoadSubsetOptions) => boolean;\n    readonly supportsOrderedWindow?: (subset: LoadSubsetOptions) => boolean;\n}\n/** Options creators are Effects: their callback fibers and subscriptions belong to the caller's scope. */\nexport const persistedCollectionOptions = <A extends object, K extends Key>(\n    options: PersistedCollectionOptions<A, K>\n) => collectionOptionsImpl(options);\nconst collectionOptionsImpl = Effect.fnUntraced(function* <A extends object, K extends Key>(\n    options: PersistedCollectionOptions<A, K>,\n    native?: NativeObservations<A>\n) {\n    const observing = options.observe !== undefined || native !== undefined;\n    const scope = yield* Effect.scope;\n    const context = yield* Effect.context<never>();\n    let active = true;\n    yield* Effect.addFinalizer(() =>\n        Effect.sync(() => {\n            active = false;\n        })\n    );\n    const run = <B, E>(effect: Effect.Effect<B, E>, owner = scope) =>\n        !active || owner.state._tag === \"Closed\"\n            ? Promise.reject(new Error(\"Collection scope is closed.\"))\n            : Effect.runPromiseWith(context)(\n                  Effect.flatMap(Effect.forkIn(effect, owner, { startImmediately: observing }), Fiber.join)\n              );\n    let refresh: (() => Promise<void>) | undefined;\n    let queried = false;\n    const persist: (args: {\n        transaction: { mutations: readonly (Change<A> & { collection: unknown })[] };\n        collection: unknown;\n    }) => Promise<void> = options.persist\n        ? async ({ transaction, collection }) => {\n              await run(\n                  options.persist!(\n                      transaction.mutations.filter((mutation) => mutation.collection === collection)\n                  )\n              );\n              // In particular, optimistic:false callers must observe the confirmed write\n              // as soon as the transaction settles.\n              await refresh?.();\n          }\n        : () => Promise.reject(new Error(\"This collection is read-only. Use ontology actions to mutate it.\"));\n    const config: CollectionConfig<A, K> = {\n        id: options.id,\n        getKey: options.getKey,\n        defaultIndexType: BasicIndex,\n        autoIndex: \"eager\",\n        defaultStringCollation: { stringSort: \"lexical\" },\n        syncMode: \"on-demand\",\n        startSync: true,\n        onInsert: persist,\n        onUpdate: persist,\n        onDelete: persist,\n        sync: {\n            rowUpdateMode: \"full\",\n            supportsOrderedWindow: options.supportsOrderedWindow,\n            sync: ({ begin, write, commit, markReady, fail, collection }) => {\n                const runScope = Effect.runSync(Scope.fork(scope));\n                let alive = true;\n                let tail: Promise<void> | undefined;\n                const releasing = new Set<Promise<void>>();\n                interface Demand {\n                    scope: Scope.Closeable;\n                    ready: Promise<void>;\n                    available: Deferred.Deferred<void>;\n                    subset: LoadSubsetOptions;\n                    release: () => void;\n                    rows: Map<Key, A>;\n                    received: boolean;\n                    settled: boolean;\n                    observed: Deferred.Deferred<void, unknown>;\n                    keys?: readonly Key[];\n                    requiredRevision?: number;\n                    group?: Observation;\n                }\n                interface Observation {\n                    key: string;\n                    scope: Scope.Closeable;\n                    rows: Map<Key, A>;\n                    revision?: number;\n                    members: Set<Demand>;\n                }\n                const demands = new Map<LoadSubsetOptions, Demand>();\n                const observations = new Map<string, Observation>();\n                const releaseDiagnostics = options.describeSubset\n                    ? registerCollectionDemands(collection, () =>\n                          [...demands.values()].map(({ subset, received, settled }) => ({\n                              ...options.describeSubset!(subset),\n                              subscription: subset.subscription,\n                              received,\n                              ready: settled,\n                          }))\n                      )\n                    : undefined;\n                const codec = Table.make<A>({ name: \"collection-value\" });\n                // Diagnostic rows can include typed Error instances. Their display\n                // values need no storage codec; conservatively rewrite such rows.\n                const fingerprint = (value: A): string | undefined => {\n                    try {\n                        return codec.encode(value);\n                    } catch {\n                        return undefined;\n                    }\n                };\n                // Reload keeps the previous rows. Reconcile against those keys\n                // rather than inserting them a second time in the new sync run.\n                const installed = new Map<Key, string | undefined>(\n                    [...collection.entries()].map(([key, value]) => [key, fingerprint(value)])\n                );\n                const dirtyKeys = new Set<Key>();\n                let reconcileInstalled = installed.size > 0;\n                const stop = (error: unknown) => {\n                    if (!alive || !active) return;\n                    alive = false;\n                    fail(error);\n                    for (const demand of demands.values()) demand.release();\n                    const closing = Effect.runPromise(Scope.close(runScope, Exit.void));\n                    releasing.add(closing);\n                    void closing.finally(() => releasing.delete(closing)).catch(() => undefined);\n                };\n                const writeRows = async (rows: ReadonlyMap<Key, A>, changed?: ReadonlySet<Key>) => {\n                    if (!active || !alive) return;\n                    const stale = new Set<Key>();\n                    for (const key of changed ?? installed.keys())\n                        if (installed.has(key) && !rows.has(key)) stale.add(key);\n                    const candidates = changed\n                        ? [...changed].flatMap((key) =>\n                              rows.has(key) ? [[key, rows.get(key)!] as const] : []\n                          )\n                        : [...rows];\n                    const updates = candidates.filter(([key, value]) => {\n                        const encoded = fingerprint(value);\n                        return encoded === undefined || installed.get(key) !== encoded;\n                    });\n                    // A reload can receive its demanded subsets independently.\n                    // Keep the old rows until every active subset has a first batch.\n                    if (observing && [...demands.values()].some((demand) => !demand.received)) {\n                        if (stale.size) reconcileInstalled = true;\n                        stale.clear();\n                    } else if (reconcileInstalled) {\n                        for (const key of installed.keys()) if (!rows.has(key)) stale.add(key);\n                        reconcileInstalled = false;\n                    }\n                    if (!updates.length && !stale.size) return;\n                    begin();\n                    for (const [key, value] of updates)\n                        write({ type: installed.has(key) ? \"update\" : \"insert\", value });\n                    for (const key of stale) write({ type: \"delete\", key: key as K });\n                    const receipt = commit();\n                    await whenSyncAccepted(receipt);\n                    for (const key of stale) installed.delete(key);\n                    for (const [key, value] of updates) installed.set(key, fingerprint(value));\n                };\n                const load = () => {\n                    const work = async () => {\n                        if (!active || !alive) return;\n                        // Observation batches identify every key whose winning\n                        // demand can change. Take this work before awaiting a\n                        // commit so concurrent batches stay queued for next time.\n                        const changed = observing ? new Set(dirtyKeys) : undefined;\n                        dirtyKeys.clear();\n                        const rows = new Map<Key, A>();\n                        if (observing) {\n                            for (const demand of demands.values()) {\n                                if (!demand.received) continue;\n                                for (const [key, value] of demand.rows) rows.set(key, value);\n                            }\n                        } else {\n                            if (typeof options.load !== \"function\")\n                                for (const row of await run(options.load)) rows.set(row.key, row.value);\n                            for (const [key, demand] of demands) {\n                                if (typeof options.load !== \"function\") break;\n                                const loaded = await run(options.load(demand.subset));\n                                if (demands.get(key) !== demand) continue;\n                                for (const row of loaded) rows.set(row.key, row.value);\n                            }\n                        }\n                        await writeRows(rows, changed);\n                    };\n                    // Start an idle publisher in this turn. Its first sync commit\n                    // can install a native memory snapshot before a query reads it.\n                    // Reserve the queue slot first: commit can acquire more demand\n                    // reentrantly, which must still publish in FIFO order.\n                    let start!: () => void;\n                    const next = new Promise<void>((resolve, reject) => {\n                        start = () => {\n                            void work().then(resolve, reject);\n                        };\n                    });\n                    const previous = tail;\n                    tail = next;\n                    const finish = () => {\n                        if (tail === next) tail = undefined;\n                    };\n                    void next.then(finish, finish);\n                    if (previous) void previous.then(start, start);\n                    else if (observing) start();\n                    else void Promise.resolve().then(start);\n                    return next;\n                };\n                const close = (owner: Scope.Closeable) => {\n                    const closing = Effect.runPromise(Scope.close(owner, Exit.void));\n                    releasing.add(closing);\n                    void closing.then(\n                        () => releasing.delete(closing),\n                        (error) => {\n                            releasing.delete(closing);\n                            stop(error);\n                        }\n                    );\n                };\n                const publishObservation = async (\n                    group: Observation,\n                    batch?: RowsBatch<A> & { readonly revision: number }\n                ) => {\n                    if (!alive || !active || observations.get(group.key) !== group) return;\n                    let changed = false;\n                    if (batch) {\n                        if (batch.reset) {\n                            for (const key of group.rows.keys()) dirtyKeys.add(key);\n                            changed = group.rows.size > 0;\n                            group.rows.clear();\n                        }\n                        for (const key of batch.removed) {\n                            if (!group.rows.delete(key)) continue;\n                            dirtyKeys.add(key);\n                            changed = true;\n                        }\n                        for (const row of batch.rows) {\n                            dirtyKeys.add(row.key);\n                            group.rows.set(row.key, row.value);\n                            changed = true;\n                        }\n                        // Admission must see this before load(): a DB commit can\n                        // acquire another identical include synchronously.\n                        group.revision = batch.revision;\n                    }\n                    let admitted = false;\n                    for (const member of group.members) {\n                        if (\n                            member.received ||\n                            group.revision === undefined ||\n                            group.revision < member.requiredRevision!\n                        )\n                            continue;\n                        member.received = true;\n                        admitted = true;\n                        // The new logical demand can change overlap precedence.\n                        for (const key of group.rows.keys()) dirtyKeys.add(key);\n                    }\n                    const published = [...group.members].filter((member) => member.received);\n                    if (changed || admitted || reconcileInstalled) await load();\n                    for (const member of published) {\n                        if (!alive || !active || !group.members.has(member)) continue;\n                        if (member.keys?.every((key) => group.rows.has(key)))\n                            Effect.runSync(Deferred.succeed(member.available, undefined));\n                        Effect.runSync(Deferred.succeed(member.observed, undefined));\n                    }\n                };\n                const observeNative = Effect.fnUntraced(function* (demand: Demand) {\n                    const revision = yield* native!.revision;\n                    const joined = yield* Effect.uninterruptible(\n                        Effect.gen(function* () {\n                            if (demands.get(demand.subset) !== demand) return;\n                            const key = native!.key(demand.subset);\n                            let group = observations.get(key);\n                            const created = !group;\n                            if (!group) {\n                                // Lookup, allocation and registration are one synchronous\n                                // operation, including under cooperative Effect scheduling.\n                                group = {\n                                    key,\n                                    scope: Scope.forkUnsafe(runScope),\n                                    rows: new Map(),\n                                    members: new Set(),\n                                };\n                                observations.set(key, group);\n                            }\n                            const current = group;\n                            demand.rows = current.rows;\n                            demand.requiredRevision = revision;\n                            demand.group = current;\n                            current.members.add(demand);\n                            if (created) {\n                                yield* Stream.runForEach(native!.observe(demand.subset), (batch) =>\n                                    Effect.tryPromise({\n                                        try: () => publishObservation(current, batch),\n                                        catch: (cause) => cause,\n                                    }).pipe(\n                                        Effect.withSpan(\"Ontology.collection.publish\", {\n                                            attributes: {\n                                                collection: options.id,\n                                                rows: batch.rows.length,\n                                                removed: batch.removed.length,\n                                                reset: batch.reset,\n                                            },\n                                        })\n                                    )\n                                ).pipe(\n                                    Effect.catch((error) =>\n                                        Effect.sync(() => {\n                                            if (observations.get(key) !== current) return;\n                                            for (const member of current.members)\n                                                Effect.runSync(Deferred.fail(member.observed, error));\n                                            stop(error);\n                                        })\n                                    ),\n                                    Effect.interruptible,\n                                    Effect.forkIn(current.scope, { startImmediately: true })\n                                );\n                            }\n                            // Only registration is uninterruptible. The shared observer\n                            // belongs to its own scope before the first caller can leave.\n                            return { current, created };\n                        })\n                    );\n                    if (!joined) return;\n                    const { current, created } = joined;\n                    if (!created && current.revision !== undefined && current.revision >= revision) {\n                        yield* Effect.tryPromise({\n                            try: () => publishObservation(current),\n                            catch: (cause) => cause,\n                        });\n                    }\n                    yield* Deferred.await(demand.observed);\n                });\n                refresh = load;\n                const watcher = run(\n                    Effect.forkIn(\n                        Stream.runForEach(observing ? Stream.empty : options.changes, () =>\n                            queried && (demands.size || typeof options.load !== \"function\")\n                                ? Effect.tryPromise({ try: load, catch: (cause) => cause })\n                                : Effect.void\n                        ).pipe(\n                            Effect.catch((error) =>\n                                Effect.sync(() => {\n                                    stop(error);\n                                })\n                            )\n                        ),\n                        runScope,\n                        { startImmediately: true }\n                    ),\n                    runScope\n                );\n                markReady();\n                return {\n                    loadSubset: (subset) => {\n                        if (subset.signal?.aborted) return Promise.resolve();\n                        queried = true;\n                        const keys = lookupKeys(subset, options.primaryKey);\n                        // A completed, still-held collection demand is a completeness\n                        // witness for every local filter/window, including empty results.\n                        const wholeCollection = [...demands.values()].some(\n                            (demand) =>\n                                demand.settled &&\n                                !demand.subset.where &&\n                                demand.subset.limit === undefined &&\n                                !demand.subset.offset &&\n                                !demand.subset.cursor\n                        );\n                        let cached =\n                            wholeCollection ||\n                            [...demands.values()].some(\n                                (demand) => demand.settled && options.covers?.(subset, demand.subset)\n                            ) ||\n                            (keys &&\n                                keys.every(\n                                    (key) =>\n                                        collection.has(key as K) &&\n                                        [...demands.values()].some(\n                                            (demand) => demand.settled && demand.rows.has(key)\n                                        )\n                                ));\n                        // Each acquisition has its own immutable options, signal\n                        // and matching unload, even for equivalent queries.\n                        const key = subset;\n                        let demand = demands.get(key);\n                        if (!demand) {\n                            if (!demands.size) reconcileInstalled = true;\n                            const child = Effect.runSync(Scope.fork(runScope));\n                            const acquire = options.acquireDemand;\n                            demand = {\n                                scope: child,\n                                subset,\n                                rows: new Map(),\n                                received: false,\n                                settled: false,\n                                ready: Promise.resolve(),\n                                available: Effect.runSync(Deferred.make<void>()),\n                                observed: Effect.runSync(Deferred.make<void, unknown>()),\n                                keys,\n                                release: () => {\n                                    subset.signal?.removeEventListener(\"abort\", demand!.release);\n                                    if (!demand || demands.get(key) !== demand) return;\n                                    if (demand.received)\n                                        for (const rowKey of demand.rows.keys()) dirtyKeys.add(rowKey);\n                                    demands.delete(key);\n                                    const group = demand.group;\n                                    group?.members.delete(demand);\n                                    if (group && !group.members.size) {\n                                        observations.delete(group.key);\n                                        close(group.scope);\n                                    }\n                                    close(child);\n                                    if (alive && active && demands.size) void load().catch(stop);\n                                },\n                            };\n                            demands.set(key, demand);\n                            subset.signal?.addEventListener(\"abort\", demand.release, { once: true });\n                            demand.ready = run(\n                                Scope.provide(\n                                    Effect.gen(function* () {\n                                        const acquisition =\n                                            typeof acquire === \"function\" ? acquire(subset) : acquire;\n                                        // Observe installed rows while readiness is pending. Cached\n                                        // data is displayable; it does not mean remote demand is ready.\n                                        const acquiring =\n                                            observing && acquisition\n                                                ? yield* Effect.forkIn(acquisition, child, {\n                                                      startImmediately: true,\n                                                  })\n                                                : undefined;\n                                        if (!observing && acquisition) yield* acquisition;\n                                        if (native) {\n                                            const observed = yield* Effect.forkIn(\n                                                observeNative(demand!),\n                                                child,\n                                                {\n                                                    startImmediately: true,\n                                                }\n                                            );\n                                            yield* Effect.all(\n                                                [\n                                                    Fiber.join(observed),\n                                                    ...(acquiring ? [Fiber.join(acquiring)] : []),\n                                                ],\n                                                { concurrency: \"unbounded\", discard: true }\n                                            );\n                                        } else if (options.observe) {\n                                            const ready = yield* Deferred.make<void, unknown>();\n                                            yield* Stream.runForEach(options.observe(subset), (batch) =>\n                                                Effect.tryPromise({\n                                                    try: async () => {\n                                                        if (!demand || demands.get(key) !== demand) return;\n                                                        const first = !demand.received;\n                                                        let changed = false;\n                                                        demand.received = true;\n                                                        if (batch.reset) {\n                                                            for (const rowKey of demand.rows.keys()) {\n                                                                dirtyKeys.add(rowKey);\n                                                                changed = true;\n                                                            }\n                                                            demand.rows.clear();\n                                                        }\n                                                        for (const removed of batch.removed) {\n                                                            // Native observers conservatively report keys\n                                                            // outside their filter. Only a key contributed\n                                                            // by this demand can change its winning row.\n                                                            if (!demand.rows.delete(removed)) continue;\n                                                            dirtyKeys.add(removed);\n                                                            changed = true;\n                                                        }\n                                                        for (const row of batch.rows) {\n                                                            dirtyKeys.add(row.key);\n                                                            demand.rows.set(row.key, row.value);\n                                                            changed = true;\n                                                        }\n                                                        if (first || changed || reconcileInstalled)\n                                                            await load();\n                                                        // An optimistic insert can arrive after a point read\n                                                        // starts. Its positive result is already known locally;\n                                                        // only absence needs completed upstream coverage.\n                                                        if (keys?.every((key) => demand!.rows.has(key)))\n                                                            Effect.runSync(\n                                                                Deferred.succeed(demand.available, undefined)\n                                                            );\n                                                        Effect.runSync(Deferred.succeed(ready, undefined));\n                                                    },\n                                                    catch: (cause) => cause,\n                                                }).pipe(\n                                                    Effect.withSpan(\"Ontology.collection.publish\", {\n                                                        attributes: {\n                                                            collection: options.id,\n                                                            rows: batch.rows.length,\n                                                            removed: batch.removed.length,\n                                                            reset: batch.reset,\n                                                        },\n                                                    })\n                                                )\n                                            ).pipe(\n                                                Effect.catch((error) =>\n                                                    Effect.gen(function* () {\n                                                        yield* Deferred.fail(ready, error);\n                                                        if (alive && active && demands.get(key) === demand)\n                                                            stop(error);\n                                                    })\n                                                ),\n                                                Effect.forkIn(child, { startImmediately: true })\n                                            );\n                                            yield* Effect.all(\n                                                [\n                                                    Deferred.await(ready),\n                                                    ...(acquiring ? [Fiber.join(acquiring)] : []),\n                                                ],\n                                                { concurrency: \"unbounded\", discard: true }\n                                            );\n                                        }\n                                    }),\n                                    child\n                                ),\n                                child\n                            );\n                            void demand.ready.catch((error) => {\n                                if (\n                                    (cached || demand!.settled) &&\n                                    demands.get(key) === demand &&\n                                    !subset.signal?.aborted\n                                )\n                                    stop(error);\n                                demand!.release();\n                            });\n                        }\n                        const current = demand;\n                        // A synchronous first snapshot can answer a positive\n                        // point read immediately. Absence still waits for upstream\n                        // coverage, and the scoped acquisition reports late errors.\n                        cached ||= Boolean(\n                            keys?.every((key) => current.rows.has(key) && collection.has(key as K))\n                        );\n                        // Reusing rows or coverage never bypasses the new lease's\n                        // local revision fence, including a complete empty answer.\n                        if (native && !current.received) cached = false;\n                        const completed = Promise.race([\n                            current.ready,\n                            ...(keys ? [run(Deferred.await(current.available), current.scope)] : []),\n                        ]).then(async () => {\n                            await load();\n                            current.settled = true;\n                        });\n                        if (cached) {\n                            // Keep the scoped observer/lease and report later failures normally;\n                            // readiness needn't wait for another acquisition of a known row.\n                            void completed.catch((error) => {\n                                if (demands.get(key) === current && !subset.signal?.aborted) stop(error);\n                            });\n                            return true;\n                        }\n                        return completed;\n                    },\n                    unloadSubset: (subset) => {\n                        const demand = demands.get(subset);\n                        demand?.release();\n                    },\n                    cleanup: async () => {\n                        releaseDiagnostics?.();\n                        alive = false;\n                        refresh = undefined;\n                        await watcher.then(\n                            (fiber) => Effect.runPromise(Fiber.interrupt(fiber)),\n                            () => undefined\n                        );\n                        await Promise.all([\n                            ...releasing,\n                            ...[...demands.values()].map((demand) => {\n                                demand.subset.signal?.removeEventListener(\"abort\", demand.release);\n                                return Effect.runPromise(Scope.close(demand.scope, Exit.void));\n                            }),\n                        ]);\n                        demands.clear();\n                        observations.clear();\n                        dirtyKeys.clear();\n                        await Effect.runPromise(Scope.close(runScope, Exit.void));\n                    },\n                };\n            },\n        },\n    };\n    return config;\n});\n// Local collection clients share the owning tables service, never another context's tables.\nconst localListeners = new WeakMap<TablesService, Set<() => void>>();\nconst localChanges = (tables: TablesService) => {\n    let listeners = localListeners.get(tables);\n    if (!listeners) localListeners.set(tables, (listeners = new Set()));\n    const current = listeners;\n    return {\n        changes: Stream.callback<void>(\n            (queue) =>\n                Effect.acquireRelease(\n                    Effect.sync(() => {\n                        const listener = () => {\n                            Queue.offerUnsafe(queue, undefined);\n                        };\n                        current.add(listener);\n                        return listener;\n                    }),\n                    (listener) =>\n                        Effect.sync(() => {\n                            current.delete(listener);\n                        })\n                ),\n            { bufferSize: 1, strategy: \"sliding\" }\n        ),\n        notify: Effect.sync(() => {\n            for (const listener of current) listener();\n        }),\n    };\n};\nexport const localCollectionOptions = Effect.fnUntraced(function* <A extends object, K extends Key>(options: {\n    readonly name: string;\n    readonly getKey: (value: A) => K;\n    readonly schemaVersion?: number;\n}) {\n    const runtime = yield* Runtime;\n    const local = localChanges(runtime.tables);\n    const table = Table.make<A>({\n        name: JSON.stringify([\"local\", runtime.owner, runtime.namespace, options.name]),\n        version: options.schemaVersion,\n    });\n    const config = yield* persistedCollectionOptions<A, K>({\n        id: `party-stack:${runtime.owner}:${runtime.namespace}:${options.name}`,\n        getKey: options.getKey,\n        load: (subset) => runtime.tables.query(table, storageSubset(subset)),\n        changes: local.changes,\n        persist: (mutations) =>\n            runtime.tables\n                .transaction((tx) =>\n                    Effect.gen(function* () {\n                        for (const mutation of mutations) {\n                            if (mutation.type === \"delete\") yield* tx.delete(table, mutation.key);\n                            else yield* tx.put(table, mutation.key, mutation.modified);\n                        }\n                    })\n                )\n                .pipe(Effect.tap(() => local.notify)),\n    });\n    return config;\n});\nexport const replicatedCollectionOptions = Effect.fnUntraced(function* <A extends object>(options: {\n    readonly replica: ReplicaService;\n    readonly objectType: string;\n    readonly getKey: (value: A) => Key;\n    readonly id: string;\n    /** Observe and retain local cache only; never acquire upstream demand. */\n    readonly localOnly?: boolean;\n}) {\n    const subsetCodec = Table.make({ name: \"native-observation-subset\" });\n    const revision = readVisibleRevision(options.replica);\n    const observe = (subset: LoadSubsetOptions) =>\n        options.replica.observeSubset(ontologySubset(subset, options.replica.ir, options.objectType)).pipe(\n            Stream.map((batch) => ({\n                ...batch,\n                rows: batch.rows.map((row) => ({ key: row.key, value: row.value as A })),\n            }))\n        );\n    return yield* collectionOptionsImpl<A, Key>(\n        {\n            id: options.id,\n            getKey: options.getKey,\n            primaryKey: options.replica.ir.objectTypes.find((type) => type.name === options.objectType)\n                ?.primaryKey,\n            supportsOrderedWindow: (subset) =>\n                analyzeOntologySubset(subset, options.replica.ir, options.objectType).orderedWindowExact,\n            covers: (requested, held) =>\n                coversSubset(\n                    {\n                        objectType: options.objectType,\n                        query: storageSubset(requested, options.replica.ir, options.objectType),\n                    },\n                    {\n                        objectType: options.objectType,\n                        query: storageSubset(held, options.replica.ir, options.objectType),\n                    }\n                ),\n            describeSubset: (subset) => ({\n                objectType: options.objectType,\n                ...analyzeStorageSubset(subset, options.replica.ir, options.objectType),\n                requested: {\n                    where: subset.where,\n                    orderBy: subset.orderBy,\n                    limit: subset.limit,\n                    offset: subset.offset,\n                    cursor: subset.cursor,\n                },\n            }),\n            load: (subset) =>\n                Effect.map(\n                    options.replica.readSubset(\n                        ontologySubset(subset, options.replica.ir, options.objectType)\n                    ),\n                    (rows) =>\n                        rows.map((row) => ({\n                            key: row.key,\n                            value: row.value as A,\n                        }))\n                ),\n            changes: Stream.empty,\n            observe,\n            acquireDemand: (subset) =>\n                options.localOnly\n                    ? options.replica.demand.acquire(\n                          ontologySubset(subset, options.replica.ir, options.objectType),\n                          { localOnly: true }\n                      )\n                    : options.replica.demand.acquire(\n                          ontologySubset(subset, options.replica.ir, options.objectType)\n                      ),\n        },\n        revision\n            ? {\n                  key: (subset) =>\n                      subsetCodec.encode(ontologySubset(subset, options.replica.ir, options.objectType)),\n                  revision,\n                  observe,\n              }\n            : undefined\n    );\n});\nexport const scopedCollection = <A extends object, K extends Key>(\n    options: CollectionConfig<A, K>,\n    client?: DbClient\n) =>\n    client\n        ? Effect.sync(() => client.collection(collectionOptions(options)))\n        : Effect.acquireRelease(\n              Effect.sync(() => createCollection(options)),\n              (collection) =>\n                  Effect.promise(async () => {\n                      await collection.cleanup({ dependents: true });\n                  })\n          );\nexport const makeLocalCollection = Effect.fn(\"Ontology.localCollection\")(function* <\n    A extends object,\n    K extends Key,\n>(options: Parameters<typeof localCollectionOptions<A, K>>[0]) {\n    return yield* scopedCollection(yield* localCollectionOptions(options));\n});\nexport const makeReplicatedCollection = Effect.fn(\"Ontology.replicatedCollection\")(function* <\n    A extends object,\n>(options: Parameters<typeof replicatedCollectionOptions<A>>[0], client?: DbClient) {\n    return yield* scopedCollection(yield* replicatedCollectionOptions(options), client);\n});\n"],"mappings":"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"}

package/lib/tanstack/createLocalCollection.d.ts

@@ -0,0 +1,14 @@
+import { RuntimeService } from "@party-stack/runtime";
+import { Scope } from "effect";
+import { Collection } from "@tanstack/db";
+//#region src/tanstack/createLocalCollection.d.ts
+export declare function createLocalCollection<T extends object, TKey extends string | number>(options: {
+  name: string;
+  getKey: (value: T) => TKey;
+  runtime: RuntimeService;
+  schemaVersion?: number;
+  /** Optional owner for the collection's Effect resources. */
+  scope: Scope.Scope;
+}): Collection<T, TKey>;
+//#endregion
+//# sourceMappingURL=createLocalCollection.d.ts.map

package/lib/tanstack/createLocalCollection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createLocalCollection.d.ts","names":[],"sources":["../../src/tanstack/createLocalCollection.ts"],"mappings":";;;;wBAKgB,sBAAsB,kBAAkB,8BAA8B;EAClF;EACA,SAAS,OAAO,MAAM;EACtB,SAAS;EACT;;EAEA,OAAO,MAAM;IACb,WAAW,GAAG"}

package/lib/tanstack/createLocalCollection.js

@@ -0,0 +1,9 @@
+import { createEffectLocalCollection } from "./localCollection.js";
+//#region src/tanstack/createLocalCollection.ts
+function createLocalCollection(options) {
+	return createEffectLocalCollection(options);
+}
+//#endregion
+export { createLocalCollection };
+
+//# sourceMappingURL=createLocalCollection.js.map