@party-stack/ontology 0.19.1 → 0.21.0

package/lib/tanstack/createLocalCollection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createLocalCollection.js","names":[],"sources":["../../src/tanstack/createLocalCollection.ts"],"sourcesContent":["import { createEffectLocalCollection } from \"./localCollection.js\";\nimport type { RuntimeService } from \"@party-stack/runtime\";\nimport type { Collection } from \"@tanstack/db\";\nimport type { Scope } from \"effect\";\n\nexport function createLocalCollection<T extends object, TKey extends string | number>(options: {\n    name: string;\n    getKey: (value: T) => TKey;\n    runtime: RuntimeService;\n    schemaVersion?: number;\n    /** Optional owner for the collection's Effect resources. */\n    scope: Scope.Scope;\n}): Collection<T, TKey> {\n    return createEffectLocalCollection(options);\n}\n"],"mappings":";;AAKA,SAAgB,sBAAsE,SAO9D;CACpB,OAAO,4BAA4B,OAAO;AAC9C"}

package/lib/tanstack/descriptors.d.ts

@@ -0,0 +1,33 @@
+import { CollectionConfig, CollectionOptions, ContextFromSource, QueryBuilder, RefsForContext, Source } from "@tanstack/db";
+import { OntologyDefinition, OntologyObject } from "@party-stack/ontology-spec";
+//#region src/tanstack/descriptors.d.ts
+export declare const ontologyCollectionDependency = "@party-stack/ontology/collectionOptions";
+export type OntologyCollectionResolver = (id: string, objectType: string, localOnly: boolean) => CollectionConfig<OntologyObject, string | number>;
+export type OntologyLinkDefinitions<Definition extends OntologyDefinition> = Partial<{ readonly [Name in keyof Definition["objectTypes"]]: Readonly<Record<string, {
+  readonly objectType: Extract<keyof Definition["objectTypes"], string>;
+  readonly source: readonly string[];
+  readonly target: readonly string[];
+}>>; }>;
+type Descriptor<Definition extends OntologyDefinition, Name extends keyof Definition["objectTypes"]> = CollectionOptions<Definition["objectTypes"][Name], string | number>;
+type RowRef<S extends Source[string]> = RefsForContext<ContextFromSource<{
+  row: S;
+}>>["row"];
+type LinkQuery<Definition extends OntologyDefinition, Link> = Link extends {
+  objectType: infer Target extends keyof Definition["objectTypes"];
+} ? QueryBuilder<ContextFromSource<{
+  row: Descriptor<Definition, Target>;
+}>> : never;
+export type OntologyCollectionDescriptors<Definition extends OntologyDefinition, Links extends OntologyLinkDefinitions<Definition> = Record<never, never>> = { readonly [Name in keyof Definition["objectTypes"]]: CollectionOptions<Definition["objectTypes"][Name], string | number> & {
+  readonly primaryKey: Extract<keyof Definition["objectTypes"][Name], string>;
+  readonly links: Name extends keyof Links ? { readonly [Link in keyof Links[Name]]: (row: RowRef<Descriptor<Definition, Name>>) => LinkQuery<Definition, Links[Name][Link]>; } : Record<never, never>;
+}; };
+/** Reusable module-level descriptors. Each ontology's DbClient supplies the replica
+ * and owns the collection instances; descriptors contain neither account data nor IO.
+ */
+export declare function ontologyCollections<Definition extends OntologyDefinition, const Links extends OntologyLinkDefinitions<Definition> = Record<never, never>>(primaryKeys: { readonly [Name in keyof Definition["objectTypes"]]: Extract<keyof Definition["objectTypes"][Name], string>; }, linkDefinitions?: Links): {
+  objects: OntologyCollectionDescriptors<Definition, Links>;
+  cachedObjects: OntologyCollectionDescriptors<Definition, Links>;
+};
+//#endregion
+export {};
+//# sourceMappingURL=descriptors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"descriptors.d.ts","names":[],"sources":["../../src/tanstack/descriptors.ts"],"mappings":";;;qBAWa;YACD,8BACR,YACA,oBACA,uBACC,iBAAiB;YAEV,wBAAwB,mBAAmB,sBAAsB,oBAC/D,cAAc,4BAA4B,SAChD;WAGiB,YAAY,cAAc;WAC1B;WACA;;KAKpB,WACD,mBAAmB,oBACnB,mBAAmB,6BACnB,kBAAkB,0BAA0B;KAC3C,OAAO,UAAU,kBAAkB,eAAe;EAAoB,KAAK;;KAC3E,UAAU,mBAAmB,oBAAoB,QAAQ;EAC1D,kBAAkB,qBAAqB;IAErC,aAAa;EAAoB,KAAK,WAAW,YAAY;;YAGvD,8BACR,mBAAmB,oBACnB,cAAc,wBAAwB,cAAc,oCAE1C,cAAc,4BAA4B,kBAChD,0BAA0B;WAGjB,YAAY,cAAc,0BAA0B;WACpD,OAAO,mBAAmB,oBAEf,cAAc,MAAM,SAC1B,KAAK,OAAO,WAAW,YAAY,WAClC,UAAU,YAAY,MAAM,MAAM,YAE3C;;;;;wBAOE,oBACZ,mBAAmB,0BACb,cAAc,wBAAwB,cAAc,sBAE1D,yBACc,cAAc,4BAA4B,cAC1C,0BAA0B,mBAIxC,kBAAkB;EAuDT,SAAO,8BAAA,YAAA;EAAsB,eAAa,8BAAA,YAAA"}

package/lib/tanstack/descriptors.js

@@ -0,0 +1,38 @@
+import { Query, collectionOptions, eq } from "@tanstack/db";
+//#region src/tanstack/descriptors.ts
+const ontologyCollectionDependency = "@party-stack/ontology/collectionOptions";
+/** Reusable module-level descriptors. Each ontology's DbClient supplies the replica
+* and owns the collection instances; descriptors contain neither account data nor IO.
+*/
+function ontologyCollections(primaryKeys, linkDefinitions) {
+	const descriptors = (localOnly) => {
+		const entries = /* @__PURE__ */ new Map();
+		const result = new Proxy(Object.create(null), { get: (_target, name) => {
+			if (typeof name !== "string" || name === "then") return void 0;
+			let descriptor = entries.get(name);
+			if (!descriptor) {
+				const id = `party-stack:${localOnly ? "cached" : "objects"}:${name}`;
+				const primaryKey = primaryKeys[name];
+				if (!primaryKey) throw new Error(`Missing primary key for ontology collection: ${name}`);
+				const native = collectionOptions(id, (client) => client.requireDependency(ontologyCollectionDependency)(id, name, localOnly));
+				const links = Object.fromEntries(Object.entries(linkDefinitions?.[name] ?? {}).map(([name, link]) => [name, (parent) => new Query().from({ row: result[link.objectType] }).where(({ row }) => eq(link.target.reduce((value, key) => value[key], row), link.source.reduce((value, key) => value[key], parent)))]));
+				descriptor = Object.freeze(Object.defineProperties({
+					...native,
+					primaryKey,
+					links: Object.freeze(links)
+				}, Object.getOwnPropertyDescriptors(native)));
+				entries.set(name, descriptor);
+			}
+			return descriptor;
+		} });
+		return result;
+	};
+	return {
+		objects: descriptors(false),
+		cachedObjects: descriptors(true)
+	};
+}
+//#endregion
+export { ontologyCollectionDependency, ontologyCollections };
+
+//# sourceMappingURL=descriptors.js.map

package/lib/tanstack/descriptors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptors.js","names":[],"sources":["../../src/tanstack/descriptors.ts"],"sourcesContent":["import { collectionOptions, eq, Query } from \"@tanstack/db\";\nimport type { OntologyDefinition, OntologyObject } from \"@party-stack/ontology-spec\";\nimport type {\n    CollectionConfig,\n    CollectionOptions,\n    ContextFromSource,\n    QueryBuilder,\n    RefsForContext,\n    Source,\n} from \"@tanstack/db\";\n\nexport const ontologyCollectionDependency = \"@party-stack/ontology/collectionOptions\";\nexport type OntologyCollectionResolver = (\n    id: string,\n    objectType: string,\n    localOnly: boolean\n) => CollectionConfig<OntologyObject, string | number>;\n\nexport type OntologyLinkDefinitions<Definition extends OntologyDefinition> = Partial<{\n    readonly [Name in keyof Definition[\"objectTypes\"]]: Readonly<\n        Record<\n            string,\n            {\n                readonly objectType: Extract<keyof Definition[\"objectTypes\"], string>;\n                readonly source: readonly string[];\n                readonly target: readonly string[];\n            }\n        >\n    >;\n}>;\ntype Descriptor<\n    Definition extends OntologyDefinition,\n    Name extends keyof Definition[\"objectTypes\"],\n> = CollectionOptions<Definition[\"objectTypes\"][Name], string | number>;\ntype RowRef<S extends Source[string]> = RefsForContext<ContextFromSource<{ row: S }>>[\"row\"];\ntype LinkQuery<Definition extends OntologyDefinition, Link> = Link extends {\n    objectType: infer Target extends keyof Definition[\"objectTypes\"];\n}\n    ? QueryBuilder<ContextFromSource<{ row: Descriptor<Definition, Target> }>>\n    : never;\n\nexport type OntologyCollectionDescriptors<\n    Definition extends OntologyDefinition,\n    Links extends OntologyLinkDefinitions<Definition> = Record<never, never>,\n> = {\n    readonly [Name in keyof Definition[\"objectTypes\"]]: CollectionOptions<\n        Definition[\"objectTypes\"][Name],\n        string | number\n    > & {\n        readonly primaryKey: Extract<keyof Definition[\"objectTypes\"][Name], string>;\n        readonly links: Name extends keyof Links\n            ? {\n                  readonly [Link in keyof Links[Name]]: (\n                      row: RowRef<Descriptor<Definition, Name>>\n                  ) => LinkQuery<Definition, Links[Name][Link]>;\n              }\n            : Record<never, never>;\n    };\n};\n\n/** Reusable module-level descriptors. Each ontology's DbClient supplies the replica\n * and owns the collection instances; descriptors contain neither account data nor IO.\n */\nexport function ontologyCollections<\n    Definition extends OntologyDefinition,\n    const Links extends OntologyLinkDefinitions<Definition> = Record<never, never>,\n>(\n    primaryKeys: {\n        readonly [Name in keyof Definition[\"objectTypes\"]]: Extract<\n            keyof Definition[\"objectTypes\"][Name],\n            string\n        >;\n    },\n    linkDefinitions?: Links\n) {\n    const descriptors = (localOnly: boolean) => {\n        const entries = new Map<\n            string,\n            CollectionOptions<OntologyObject, string | number> & { readonly primaryKey: string }\n        >();\n        const result: OntologyCollectionDescriptors<Definition, Links> = new Proxy(Object.create(null), {\n            get: (_target, name) => {\n                if (typeof name !== \"string\" || name === \"then\") return undefined;\n                let descriptor = entries.get(name);\n                if (!descriptor) {\n                    const id = `party-stack:${localOnly ? \"cached\" : \"objects\"}:${name}`;\n                    const primaryKey = primaryKeys[name];\n                    if (!primaryKey) throw new Error(`Missing primary key for ontology collection: ${name}`);\n                    const native = collectionOptions(id, (client) =>\n                        client.requireDependency<OntologyCollectionResolver>(ontologyCollectionDependency)(\n                            id,\n                            name,\n                            localOnly\n                        )\n                    );\n                    const links = Object.fromEntries(\n                        Object.entries(linkDefinitions?.[name] ?? {}).map(([name, link]) => [\n                            name,\n                            (parent: Record<string, unknown>) =>\n                                new Query().from({ row: result[link.objectType] }).where(({ row }) =>\n                                    eq(\n                                        link.target.reduce(\n                                            (value, key) => (value as Record<string, unknown>)[key],\n                                            row as unknown\n                                        ),\n                                        link.source.reduce(\n                                            (value, key) => (value as Record<string, unknown>)[key],\n                                            parent as unknown\n                                        )\n                                    )\n                                ),\n                        ])\n                    );\n                    // Native descriptors are frozen and carry non-enumerable branding\n                    // and factories. Preserve those descriptors on a fresh object.\n                    descriptor = Object.freeze(\n                        Object.defineProperties(\n                            { ...native, primaryKey, links: Object.freeze(links) },\n                            Object.getOwnPropertyDescriptors(native)\n                        )\n                    );\n                    entries.set(name, descriptor);\n                }\n                return descriptor;\n            },\n        });\n        return result;\n    };\n    return { objects: descriptors(false), cachedObjects: descriptors(true) };\n}\n"],"mappings":";;AAWA,MAAa,+BAA+B;;;;AAoD5C,SAAgB,oBAIZ,aAMA,iBACF;CACE,MAAM,eAAe,cAAuB;EACxC,MAAM,0BAAU,IAAI,IAGlB;EACF,MAAM,SAA2D,IAAI,MAAM,OAAO,OAAO,IAAI,GAAG,EAC5F,MAAM,SAAS,SAAS;GACpB,IAAI,OAAO,SAAS,YAAY,SAAS,QAAQ,OAAO,KAAA;GACxD,IAAI,aAAa,QAAQ,IAAI,IAAI;GACjC,IAAI,CAAC,YAAY;IACb,MAAM,KAAK,eAAe,YAAY,WAAW,UAAU,GAAG;IAC9D,MAAM,aAAa,YAAY;IAC/B,IAAI,CAAC,YAAY,MAAM,IAAI,MAAM,gDAAgD,MAAM;IACvF,MAAM,SAAS,kBAAkB,KAAK,WAClC,OAAO,kBAA8C,4BAA4B,CAAC,CAC9E,IACA,MACA,SACJ,CACJ;IACA,MAAM,QAAQ,OAAO,YACjB,OAAO,QAAQ,kBAAkB,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,UAAU,CAChE,OACC,WACG,IAAI,MAAM,CAAC,CAAC,KAAK,EAAE,KAAK,OAAO,KAAK,YAAY,CAAC,CAAC,CAAC,OAAO,EAAE,UACxD,GACI,KAAK,OAAO,QACP,OAAO,QAAS,MAAkC,MACnD,GACJ,GACA,KAAK,OAAO,QACP,OAAO,QAAS,MAAkC,MACnD,MACJ,CACJ,CACJ,CACR,CAAC,CACL;IAGA,aAAa,OAAO,OAChB,OAAO,iBACH;KAAE,GAAG;KAAQ;KAAY,OAAO,OAAO,OAAO,KAAK;IAAE,GACrD,OAAO,0BAA0B,MAAM,CAC3C,CACJ;IACA,QAAQ,IAAI,MAAM,UAAU;GAChC;GACA,OAAO;EACX,EACJ,CAAC;EACD,OAAO;CACX;CACA,OAAO;EAAE,SAAS,YAAY,KAAK;EAAG,eAAe,YAAY,IAAI;CAAE;AAC3E"}

package/lib/tanstack/diagnostics.d.ts

@@ -0,0 +1,23 @@
+import { LoadSubsetOptions } from "@tanstack/db";
+import { Query as Query$1 } from "@party-stack/ontology-storage";
+//#region src/tanstack/diagnostics.d.ts
+export interface CollectionDemandDiagnostic {
+  readonly objectType: string;
+  readonly query?: Query$1;
+  /** Tab-local source demand before storage translation; never sent to the backend. */
+  readonly requested?: Pick<LoadSubsetOptions, "where" | "orderBy" | "limit" | "offset" | "cursor">;
+  readonly exact?: boolean;
+  readonly filterExact?: boolean;
+  readonly orderExact?: boolean;
+  /** Whether this acquisition has delivered its first local snapshot. */
+  readonly received?: boolean;
+  /** Whether local delivery and upstream readiness have both completed. */
+  readonly ready?: boolean;
+  /** In-process identity only; never serialized or sent to a replica owner. */
+  readonly subscription?: object;
+}
+/** Read existing acquisitions without starting sync, acquiring demand, or reading rows. */
+export declare const getCollectionDemands: (collection: object) => readonly CollectionDemandDiagnostic[];
+export declare function registerCollectionDemands(collection: object, read: () => readonly CollectionDemandDiagnostic[]): () => void;
+//#endregion
+//# sourceMappingURL=diagnostics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.ts","names":["Query"],"sources":["../../src/tanstack/diagnostics.ts"],"mappings":";;;iBAGiB;WACJ;WACA,QAAQA;;WAER,YAAY,KAAK;WACjB;WACA;WACA;;WAEA;;WAEA;;WAEA;;;qBAIA,uBAAoB,gCAAkC;wBAGnD,0BACZ,oBACA,qBAAqB"}

package/lib/tanstack/diagnostics.js

@@ -0,0 +1,14 @@
+//#region src/tanstack/diagnostics.ts
+const readers = /* @__PURE__ */ new WeakMap();
+/** Read existing acquisitions without starting sync, acquiring demand, or reading rows. */
+const getCollectionDemands = (collection) => readers.get(collection)?.() ?? [];
+function registerCollectionDemands(collection, read) {
+	readers.set(collection, read);
+	return () => {
+		if (readers.get(collection) === read) readers.delete(collection);
+	};
+}
+//#endregion
+export { getCollectionDemands, registerCollectionDemands };
+
+//# sourceMappingURL=diagnostics.js.map

package/lib/tanstack/diagnostics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.js","names":[],"sources":["../../src/tanstack/diagnostics.ts"],"sourcesContent":["import type { Query } from \"@party-stack/ontology-storage\";\nimport type { LoadSubsetOptions } from \"@tanstack/db\";\n\nexport interface CollectionDemandDiagnostic {\n    readonly objectType: string;\n    readonly query?: Query;\n    /** Tab-local source demand before storage translation; never sent to the backend. */\n    readonly requested?: Pick<LoadSubsetOptions, \"where\" | \"orderBy\" | \"limit\" | \"offset\" | \"cursor\">;\n    readonly exact?: boolean;\n    readonly filterExact?: boolean;\n    readonly orderExact?: boolean;\n    /** Whether this acquisition has delivered its first local snapshot. */\n    readonly received?: boolean;\n    /** Whether local delivery and upstream readiness have both completed. */\n    readonly ready?: boolean;\n    /** In-process identity only; never serialized or sent to a replica owner. */\n    readonly subscription?: object;\n}\nconst readers = new WeakMap<object, () => readonly CollectionDemandDiagnostic[]>();\n/** Read existing acquisitions without starting sync, acquiring demand, or reading rows. */\nexport const getCollectionDemands = (collection: object): readonly CollectionDemandDiagnostic[] =>\n    readers.get(collection)?.() ?? [];\n\nexport function registerCollectionDemands(\n    collection: object,\n    read: () => readonly CollectionDemandDiagnostic[]\n) {\n    readers.set(collection, read);\n    return () => {\n        if (readers.get(collection) === read) readers.delete(collection);\n    };\n}\n"],"mappings":";AAkBA,MAAM,0BAAU,IAAI,QAA6D;;AAEjF,MAAa,wBAAwB,eACjC,QAAQ,IAAI,UAAU,CAAC,GAAG,KAAK,CAAC;AAEpC,SAAgB,0BACZ,YACA,MACF;CACE,QAAQ,IAAI,YAAY,IAAI;CAC5B,aAAa;EACT,IAAI,QAAQ,IAAI,UAAU,MAAM,MAAM,QAAQ,OAAO,UAAU;CACnE;AACJ"}

package/lib/tanstack/index.d.ts

@@ -0,0 +1,6 @@
+import { OntologyCollectionDescriptors, OntologyLinkDefinitions, ontologyCollections } from "./descriptors.js";
+import { CollectionDemandDiagnostic, getCollectionDemands } from "./diagnostics.js";
+import { localCollectionOptions, makeLocalCollection, makeReplicatedCollection, persistedCollectionOptions, replicatedCollectionOptions, scopedCollection } from "./collections.js";
+import { createLocalCollection } from "./createLocalCollection.js";
+import { storageSubset } from "./subset.js";
+export { type CollectionDemandDiagnostic, type OntologyCollectionDescriptors, type OntologyLinkDefinitions, createLocalCollection, getCollectionDemands, localCollectionOptions, makeLocalCollection, makeReplicatedCollection, ontologyCollections, persistedCollectionOptions, replicatedCollectionOptions, scopedCollection, storageSubset };

package/lib/tanstack/index.js

@@ -0,0 +1,6 @@
+import { ontologyCollections } from "./descriptors.js";
+import { getCollectionDemands } from "./diagnostics.js";
+import { storageSubset } from "./subset.js";
+import { localCollectionOptions, makeLocalCollection, makeReplicatedCollection, persistedCollectionOptions, replicatedCollectionOptions, scopedCollection } from "./collections.js";
+import { createLocalCollection } from "./createLocalCollection.js";
+export { createLocalCollection, getCollectionDemands, localCollectionOptions, makeLocalCollection, makeReplicatedCollection, ontologyCollections, persistedCollectionOptions, replicatedCollectionOptions, scopedCollection, storageSubset };

package/lib/tanstack/localCollection.d.ts

@@ -0,0 +1,14 @@
+import { RuntimeService } from "@party-stack/runtime";
+import { Scope } from "effect";
+import { Collection } from "@tanstack/db";
+//#region src/tanstack/localCollection.d.ts
+/** Synchronous application boundary; storage acquisition and all work stay in the runtime's scope. */
+export declare function createEffectLocalCollection<A extends object, K extends string | number>(options: {
+  name: string;
+  getKey: (value: A) => K;
+  runtime: RuntimeService;
+  schemaVersion?: number;
+  scope: Scope.Scope;
+}): Collection<A, K>;
+//#endregion
+//# sourceMappingURL=localCollection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"localCollection.d.ts","names":[],"sources":["../../src/tanstack/localCollection.ts"],"mappings":";;;;;wBAQgB,4BAA4B,kBAAkB,2BAA2B;EACrF;EACA,SAAS,OAAO,MAAM;EACtB,SAAS;EACT;EACA,OAAO,MAAM;IACb,WAAW,GAAG"}

package/lib/tanstack/localCollection.js

@@ -0,0 +1,73 @@
+import { localCollectionOptions } from "./collections.js";
+import { Runtime } from "@party-stack/runtime";
+import { Context, Effect, Exit, Scope } from "effect";
+import { BasicIndex, createCollection } from "@tanstack/db";
+//#region src/tanstack/localCollection.ts
+/** Synchronous application boundary; storage acquisition and all work stay in the runtime's scope. */
+function createEffectLocalCollection(options) {
+	const managed = { runPromise: Effect.runPromiseWith(Context.make(Runtime, options.runtime)) };
+	let closed = false;
+	let collection;
+	const initialized = managed.runPromise(Effect.gen(function* () {
+		const scope = yield* Scope.fork(options.scope);
+		yield* Scope.addFinalizer(scope, Effect.promise(async () => {
+			if (closed) return;
+			closed = true;
+			await collection.cleanup({ dependents: true });
+		}));
+		const config = yield* Scope.provide(localCollectionOptions(options), scope);
+		if (closed) yield* Scope.close(scope, Exit.void);
+		return {
+			scope,
+			config
+		};
+	}));
+	initialized.catch(() => void 0);
+	const config = {
+		id: `party-stack:${options.runtime.owner}:${options.runtime.namespace}:${options.name}`,
+		getKey: options.getKey,
+		defaultIndexType: BasicIndex,
+		autoIndex: "eager",
+		syncMode: "on-demand",
+		startSync: true,
+		onInsert: async (args) => (await initialized).config.onInsert(args),
+		onUpdate: async (args) => (await initialized).config.onUpdate(args),
+		onDelete: async (args) => (await initialized).config.onDelete(args),
+		sync: {
+			rowUpdateMode: "full",
+			sync: (args) => {
+				let alive = true;
+				const started = initialized.then(({ config }) => {
+					if (closed || !alive) return void 0;
+					return config.sync.sync(args);
+				});
+				started.catch((error) => {
+					if (alive && !closed) args.fail(error);
+				});
+				return {
+					loadSubset: async (subset) => {
+						const sync = await started;
+						if (sync && typeof sync === "object") await sync.loadSubset?.(subset);
+					},
+					unloadSubset: (subset) => {
+						started.then((sync) => {
+							if (sync && typeof sync === "object") sync.unloadSubset?.(subset);
+						}).catch(() => void 0);
+					},
+					cleanup: async () => {
+						alive = false;
+						const sync = await started;
+						if (typeof sync === "function") await sync();
+						else await sync?.cleanup?.();
+					}
+				};
+			}
+		}
+	};
+	collection = createCollection(config);
+	return collection;
+}
+//#endregion
+export { createEffectLocalCollection };
+
+//# sourceMappingURL=localCollection.js.map

package/lib/tanstack/localCollection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"localCollection.js","names":[],"sources":["../../src/tanstack/localCollection.ts"],"sourcesContent":["import { Runtime } from \"@party-stack/runtime\";\nimport { BasicIndex, createCollection } from \"@tanstack/db\";\nimport { Context, Effect, Exit, Scope } from \"effect\";\nimport { localCollectionOptions } from \"./collections.js\";\nimport type { RuntimeService } from \"@party-stack/runtime\";\nimport type { Collection, CollectionConfig } from \"@tanstack/db\";\n\n/** Synchronous application boundary; storage acquisition and all work stay in the runtime's scope. */\nexport function createEffectLocalCollection<A extends object, K extends string | number>(options: {\n    name: string;\n    getKey: (value: A) => K;\n    runtime: RuntimeService;\n    schemaVersion?: number;\n    scope: Scope.Scope;\n}): Collection<A, K> {\n    const managed = { runPromise: Effect.runPromiseWith(Context.make(Runtime, options.runtime)) };\n    let closed = false;\n    let collection: Collection<A, K>;\n    const initialized = managed.runPromise(\n        Effect.gen(function* () {\n            const scope = yield* Scope.fork(options.scope);\n            yield* Scope.addFinalizer(\n                scope,\n                Effect.promise(async () => {\n                    if (closed) return;\n                    closed = true;\n                    await collection.cleanup({ dependents: true });\n                })\n            );\n            const config = yield* Scope.provide(localCollectionOptions<A, K>(options), scope);\n            if (closed) yield* Scope.close(scope, Exit.void);\n            return { scope, config };\n        })\n    );\n    // Consumers see initialization failures through query and mutation promises.\n    void initialized.catch(() => undefined);\n    const config: CollectionConfig<A, K> = {\n        id: `party-stack:${options.runtime.owner}:${options.runtime.namespace}:${options.name}`,\n        getKey: options.getKey,\n        defaultIndexType: BasicIndex,\n        autoIndex: \"eager\",\n        syncMode: \"on-demand\",\n        startSync: true,\n        onInsert: async (args) => (await initialized).config.onInsert!(args),\n        onUpdate: async (args) => (await initialized).config.onUpdate!(args),\n        onDelete: async (args) => (await initialized).config.onDelete!(args),\n        sync: {\n            rowUpdateMode: \"full\",\n            sync: (args) => {\n                let alive = true;\n                const started = initialized.then(({ config }) => {\n                    if (closed || !alive) return undefined;\n                    return config.sync.sync(args);\n                });\n                void started.catch((error) => {\n                    if (alive && !closed) args.fail(error);\n                });\n                return {\n                    loadSubset: async (subset) => {\n                        const sync = await started;\n                        if (sync && typeof sync === \"object\") await sync.loadSubset?.(subset);\n                    },\n                    unloadSubset: (subset) => {\n                        void started\n                            .then((sync) => {\n                                if (sync && typeof sync === \"object\") sync.unloadSubset?.(subset);\n                            })\n                            .catch(() => undefined);\n                    },\n                    cleanup: async () => {\n                        alive = false;\n                        const sync = await started;\n                        if (typeof sync === \"function\") await sync();\n                        else await sync?.cleanup?.();\n                    },\n                };\n            },\n        },\n    };\n    collection = createCollection(config);\n    return collection;\n}\n"],"mappings":";;;;;;AAQA,SAAgB,4BAAyE,SAMpE;CACjB,MAAM,UAAU,EAAE,YAAY,OAAO,eAAe,QAAQ,KAAK,SAAS,QAAQ,OAAO,CAAC,EAAE;CAC5F,IAAI,SAAS;CACb,IAAI;CACJ,MAAM,cAAc,QAAQ,WACxB,OAAO,IAAI,aAAa;EACpB,MAAM,QAAQ,OAAO,MAAM,KAAK,QAAQ,KAAK;EAC7C,OAAO,MAAM,aACT,OACA,OAAO,QAAQ,YAAY;GACvB,IAAI,QAAQ;GACZ,SAAS;GACT,MAAM,WAAW,QAAQ,EAAE,YAAY,KAAK,CAAC;EACjD,CAAC,CACL;EACA,MAAM,SAAS,OAAO,MAAM,QAAQ,uBAA6B,OAAO,GAAG,KAAK;EAChF,IAAI,QAAQ,OAAO,MAAM,MAAM,OAAO,KAAK,IAAI;EAC/C,OAAO;GAAE;GAAO;EAAO;CAC3B,CAAC,CACL;CAEA,YAAiB,YAAY,KAAA,CAAS;CACtC,MAAM,SAAiC;EACnC,IAAI,eAAe,QAAQ,QAAQ,MAAM,GAAG,QAAQ,QAAQ,UAAU,GAAG,QAAQ;EACjF,QAAQ,QAAQ;EAChB,kBAAkB;EAClB,WAAW;EACX,UAAU;EACV,WAAW;EACX,UAAU,OAAO,UAAU,MAAM,YAAA,CAAa,OAAO,SAAU,IAAI;EACnE,UAAU,OAAO,UAAU,MAAM,YAAA,CAAa,OAAO,SAAU,IAAI;EACnE,UAAU,OAAO,UAAU,MAAM,YAAA,CAAa,OAAO,SAAU,IAAI;EACnE,MAAM;GACF,eAAe;GACf,OAAO,SAAS;IACZ,IAAI,QAAQ;IACZ,MAAM,UAAU,YAAY,MAAM,EAAE,aAAa;KAC7C,IAAI,UAAU,CAAC,OAAO,OAAO,KAAA;KAC7B,OAAO,OAAO,KAAK,KAAK,IAAI;IAChC,CAAC;IACD,QAAa,OAAO,UAAU;KAC1B,IAAI,SAAS,CAAC,QAAQ,KAAK,KAAK,KAAK;IACzC,CAAC;IACD,OAAO;KACH,YAAY,OAAO,WAAW;MAC1B,MAAM,OAAO,MAAM;MACnB,IAAI,QAAQ,OAAO,SAAS,UAAU,MAAM,KAAK,aAAa,MAAM;KACxE;KACA,eAAe,WAAW;MACtB,QACK,MAAM,SAAS;OACZ,IAAI,QAAQ,OAAO,SAAS,UAAU,KAAK,eAAe,MAAM;MACpE,CAAC,CAAC,CACD,YAAY,KAAA,CAAS;KAC9B;KACA,SAAS,YAAY;MACjB,QAAQ;MACR,MAAM,OAAO,MAAM;MACnB,IAAI,OAAO,SAAS,YAAY,MAAM,KAAK;WACtC,MAAM,MAAM,UAAU;KAC/B;IACJ;GACJ;EACJ;CACJ;CACA,aAAa,iBAAiB,MAAM;CACpC,OAAO;AACX"}

package/lib/tanstack/subset.d.ts

@@ -0,0 +1,28 @@
+import { LoadSubsetOptions } from "@tanstack/db";
+import { OntologyIR, Subset } from "@party-stack/ontology-spec";
+import { ObjectSubset } from "@party-stack/ontology-spec/query";
+import { Query as Query$1 } from "@party-stack/ontology-storage";
+//#region src/tanstack/subset.d.ts
+/** Translate TanStack semantics into the shared ontology expression IR. Unsupported expressions
+ * widen demand; TanStack still evaluates the original query on the returned rows.
+ * In particular, a residual filter or locale comparator must run before LIMIT.
+ */
+export declare function analyzeOntologySubset(subset: LoadSubsetOptions, ir?: OntologyIR, objectType?: string): {
+  subset: Subset;
+  exact: boolean;
+  filterExact: boolean;
+  orderExact: boolean;
+  orderedWindowExact: boolean;
+};
+export declare function analyzeStorageSubset(subset: LoadSubsetOptions, ir?: OntologyIR, objectType?: string): {
+  subset: Subset;
+  exact: boolean;
+  filterExact: boolean;
+  orderExact: boolean;
+  orderedWindowExact: boolean;
+  query: Query$1;
+};
+export declare function storageSubset(subset: LoadSubsetOptions, ir?: OntologyIR, objectType?: string): Query$1;
+export declare function ontologySubset(subset: LoadSubsetOptions, ir: OntologyIR, objectType: string): ObjectSubset;
+//#endregion
+//# sourceMappingURL=subset.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subset.d.ts","names":["Query"],"sources":["../../src/tanstack/subset.ts"],"mappings":";;;;;;;;;wBAgDgB,sBAAsB,QAAQ,mBAAmB,KAAK,YAAY;;;;;;;wBAqSlE,qBAAqB,QAAQ,mBAAmB,KAAK,YAAY;;;;;;;;wBAIjE,cAAc,QAAQ,mBAAmB,KAAK,YAAY,sBAAsBA;wBAGhF,eAAe,QAAQ,mBAAmB,IAAI,YAAY,qBAAqB"}

package/lib/tanstack/subset.js

@@ -0,0 +1,290 @@
+import { IR } from "@tanstack/db";
+import * as q from "@party-stack/ontology-spec/query";
+//#region src/tanstack/subset.ts
+const field = (...path) => q.field("row", ...path);
+const isField = (value) => value.kind === "getAt";
+const unknown = {
+	yes: true,
+	no: true,
+	exact: false
+};
+const combine = (op, values) => {
+	const terminal = op === "or";
+	if (values.includes(terminal)) return terminal;
+	const predicates = values.filter((value) => typeof value !== "boolean");
+	return predicates.length === 0 ? !terminal : predicates.length === 1 ? predicates[0] : q[op](...predicates);
+};
+const predicate = (value) => value === true ? void 0 : value === false ? q.or() : value;
+const negate = (value) => typeof value === "boolean" ? !value : q.not(value);
+/** Translate TanStack semantics into the shared ontology expression IR. Unsupported expressions
+* widen demand; TanStack still evaluates the original query on the returned rows.
+* In particular, a residual filter or locale comparator must run before LIMIT.
+*/
+function analyzeOntologySubset(subset, ir, objectType) {
+	const objects = new Map(ir?.objectTypes.map((type) => [type.name, type]));
+	const named = new Map(ir?.types.map((type) => [type.name, type.type]));
+	const resolve = (type, path, optional = false, seen = /* @__PURE__ */ new Set()) => {
+		if (!type || seen.has(type)) return void 0;
+		const next = /* @__PURE__ */ new Set([...seen, type]);
+		if (type.kind === "optional") return resolve(type.value.type, path, true, next);
+		if (type.kind === "ref") return resolve(named.get(type.value.name), path, optional, next);
+		if (type.kind === "objectReference") {
+			const object = objects.get(type.value.objectType);
+			return resolve(object?.properties.find((prop) => prop.name === object.primaryKey)?.type, path, optional, next);
+		}
+		if (path.length) return type.kind === "struct" ? resolve(type.value.fields.find((prop) => prop.name === path[0])?.type, path.slice(1), optional, next) : void 0;
+		if (type.kind === "list") return {
+			elementFamily: resolve(type.value.elementType, [], false, next)?.family,
+			optional
+		};
+		switch (type.kind) {
+			case "string":
+			case "boolean":
+			case "date":
+			case "timestamp": return {
+				family: type.kind,
+				optional
+			};
+			case "integer":
+			case "float":
+			case "double": return {
+				family: "number",
+				optional
+			};
+			default: return;
+		}
+	};
+	const value = (expression) => {
+		if (expression.type === "ref") {
+			const path = IR.getPropRefPropertyPath(expression);
+			if (!path.length) return void 0;
+			const type = objects.get(objectType ?? "")?.properties.find((prop) => prop.name === path[0])?.type;
+			const resolved = resolve(type, path.slice(1));
+			return resolved && {
+				operand: field(...path),
+				...resolved
+			};
+		}
+		if (expression.type !== "val") return void 0;
+		const literal = expression.value;
+		if (literal == null) return {
+			operand: q.literal(literal),
+			optional: true
+		};
+		if (typeof literal === "string" || typeof literal === "boolean") return {
+			operand: q.literal(literal),
+			family: typeof literal,
+			optional: false
+		};
+		if (typeof literal === "number" && Number.isFinite(literal)) return {
+			operand: q.literal(literal),
+			family: "number",
+			optional: false
+		};
+		if (typeof literal === "object") {
+			const tag = Reflect.get(literal, Symbol.toStringTag);
+			if (tag === "Temporal.Instant" || tag === "Temporal.PlainDate") return {
+				operand: q.literal(literal),
+				family: tag === "Temporal.Instant" ? "timestamp" : "date",
+				optional: false
+			};
+		}
+	};
+	const present = (v) => !v.optional ? true : isField(v.operand) ? q.ne(v.operand, q.literal(void 0)) : false;
+	const truth = (expression) => {
+		if (expression.type === "val" && (typeof expression.value === "boolean" || expression.value == null)) return {
+			yes: expression.value === true,
+			no: expression.value === false,
+			exact: true
+		};
+		if (expression.type === "ref") {
+			const v = value(expression);
+			return v?.family === "boolean" ? {
+				yes: q.eq(v.operand, q.literal(true)),
+				no: q.eq(v.operand, q.literal(false)),
+				exact: true
+			} : unknown;
+		}
+		if (expression.type !== "func") return unknown;
+		const { name, args } = expression;
+		if (name === "and" || name === "or") {
+			const children = args.map(truth);
+			return {
+				yes: combine(name, children.map((c) => c.yes)),
+				no: combine(name === "and" ? "or" : "and", children.map((c) => c.no)),
+				exact: children.every((c) => c.exact)
+			};
+		}
+		if (name === "not" && args.length === 1) {
+			const child = truth(args[0]);
+			return {
+				yes: child.no,
+				no: child.yes,
+				exact: child.exact
+			};
+		}
+		const left = args[0] && value(args[0]);
+		if (!left) return unknown;
+		if ((name === "isNull" || name === "isUndefined") && args.length === 1) {
+			const yes = q.eq(left.operand, q.literal(name === "isNull" ? null : void 0));
+			return {
+				yes,
+				no: negate(yes),
+				exact: true
+			};
+		}
+		if (left.family === "date" && (name === "eq" || name === "in")) return unknown;
+		if (name === "in" && args[1]?.type === "ref") {
+			const array = value(args[1]);
+			if (!array?.elementFamily || !isField(array.operand)) return unknown;
+			if (!left.family) return {
+				yes: false,
+				no: false,
+				exact: true
+			};
+			if (left.family !== array.elementFamily) return unknown;
+			const yes = q.contains(array.operand, left.operand);
+			return {
+				yes: combine("and", [present(left), yes]),
+				no: combine("and", [present(left), negate(yes)]),
+				exact: true
+			};
+		}
+		if (name === "in" && args[1]?.type === "val" && Array.isArray(args[1].value)) {
+			const items = args[1].value.filter((item) => item != null).map((item) => value(new IR.Value(item)));
+			if (items.some((item) => !item || item.family !== left.family)) return unknown;
+			const yes = q.inArray(left.operand, q.literal(items.map((item) => item.operand.value.value)));
+			return {
+				yes: combine("and", [present(left), yes]),
+				no: combine("and", [present(left), negate(yes)]),
+				exact: true
+			};
+		}
+		if (![
+			"eq",
+			"gt",
+			"gte",
+			"lt",
+			"lte",
+			"like",
+			"ilike"
+		].includes(name)) return unknown;
+		const right = args[1] && value(args[1]);
+		if (!right || args.length !== 2) return unknown;
+		if (!left.family || !right.family) return {
+			yes: false,
+			no: false,
+			exact: true
+		};
+		if (left.family !== right.family) return unknown;
+		const guard = combine("and", [present(left), present(right)]);
+		let yes;
+		if (name === "eq" || name === "gt" || name === "gte" || name === "lt" || name === "lte") yes = q[name](left.operand, right.operand);
+		else if ((name === "like" || name === "ilike") && left.family === "string") yes = q[name](left.operand, right.operand);
+		else return unknown;
+		return {
+			yes: name === "eq" && (!left.optional || !right.optional) ? yes : combine("and", [guard, yes]),
+			no: combine("and", [guard, negate(yes)]),
+			exact: true
+		};
+	};
+	const filter = subset.where ? truth(subset.where) : {
+		yes: true,
+		exact: true
+	};
+	const cursor = subset.cursor ? truth(new IR.Func("or", [subset.cursor.whereFrom, subset.cursor.whereCurrent])) : void 0;
+	const orderBy = [];
+	let ordered = true;
+	let homogeneousOrder = true;
+	for (const order of subset.orderBy ?? []) {
+		const v = value(order.expression);
+		const compare = order.compareOptions;
+		homogeneousOrder &&= !!v?.family && (compare.nulls === "first" || compare.nulls === "last");
+		if (order.expression.type !== "ref" || !v || compare.stringSort === "custom" || v.family === "string" && compare.stringSort !== "lexical") {
+			ordered = false;
+			break;
+		}
+		orderBy.push({
+			expression: v.operand,
+			direction: compare.direction,
+			nulls: compare.nulls
+		});
+	}
+	const bounded = filter.exact && ordered && !cursor;
+	const limit = bounded && subset.limit !== void 0 ? subset.limit + (subset.offset ?? 0) : void 0;
+	const finalOrder = subset.orderBy?.at(-1)?.expression;
+	const finalPath = finalOrder?.type === "ref" ? IR.getPropRefPropertyPath(finalOrder) : [];
+	const finalValue = finalOrder && value(finalOrder);
+	const orderedWindowExact = bounded && homogeneousOrder && subset.limit !== void 0 && Number.isSafeInteger(subset.limit) && subset.limit >= 0 && limit !== void 0 && Number.isSafeInteger(limit) && limit >= 0 && Number.isSafeInteger(subset.offset ?? 0) && (subset.offset ?? 0) >= 0 && finalPath.length === 1 && finalPath[0] === objects.get(objectType ?? "")?.primaryKey && !!finalValue && !finalValue.optional && (finalValue.family === "string" || finalValue.family === "number");
+	return {
+		subset: {
+			where: predicate(combine("and", [filter.yes, cursor?.yes ?? true])),
+			...ordered && orderBy.length ? { orderBy } : {},
+			...limit !== void 0 && Number.isSafeInteger(limit) ? { page: { limit } } : {}
+		},
+		exact: filter.exact && ordered && !cursor,
+		filterExact: filter.exact,
+		orderExact: ordered,
+		orderedWindowExact
+	};
+}
+/** Raw Tables/transaction adapter. Only serializes nodes constructed by the analyzer above. */
+function storageScan(subset) {
+	const operand = (e) => e.kind === "getAt" ? {
+		_tag: "Field",
+		path: e.value.path
+	} : e.value.value;
+	const predicate = (e) => {
+		if (e.kind === "and" || e.kind === "or") return {
+			op: e.kind,
+			predicates: e.value.expressions.map(predicate)
+		};
+		if (e.kind === "not") return {
+			op: "not",
+			predicate: predicate(e.value.expression)
+		};
+		if (e.kind === "in") return {
+			op: "in",
+			left: operand(e.value.left),
+			values: e.value.right.value.value
+		};
+		const binary = e;
+		return {
+			op: binary.kind,
+			left: operand(binary.value.left),
+			right: operand(binary.value.right)
+		};
+	};
+	return {
+		where: subset.where ? predicate(subset.where) : void 0,
+		...subset.orderBy ? { orderBy: subset.orderBy.map((o) => ({
+			field: operand(o.expression),
+			direction: o.direction,
+			nulls: o.nulls
+		})) } : {},
+		...subset.page?.limit !== void 0 ? { limit: subset.page.limit } : {}
+	};
+}
+function analyzeStorageSubset(subset, ir, objectType) {
+	const analysis = analyzeOntologySubset(subset, ir, objectType);
+	return {
+		...analysis,
+		query: storageScan(analysis.subset)
+	};
+}
+function storageSubset(subset, ir, objectType) {
+	return analyzeStorageSubset(subset, ir, objectType).query;
+}
+function ontologySubset(subset, ir, objectType) {
+	return {
+		from: {
+			source: { objectType },
+			binding: "row"
+		},
+		...analyzeOntologySubset(subset, ir, objectType).subset
+	};
+}
+//#endregion
+export { analyzeOntologySubset, analyzeStorageSubset, ontologySubset, storageSubset };
+
+//# sourceMappingURL=subset.js.map