@party-stack/ontology 0.20.0 → 0.21.0

package/lib/live/pins.js

@@ -0,0 +1,113 @@
+import { ontologySubset } from "../tanstack/subset.js";
+import { persistedCollectionOptions, scopedCollection } from "../tanstack/collections.js";
+import { BackendError } from "@party-stack/ontology-backend";
+import { Runtime } from "@party-stack/runtime";
+import { Effect, Fiber, Schema, Scope, Stream } from "effect";
+import { BasicIndex, and, createLiveQueryCollection, eq } from "@tanstack/db";
+import { makeReplica, pinDefinitionKey, pinMutators, pinOntology, pinRecordKey } from "@party-stack/ontology-replica";
+import { QueryDocumentSchema } from "@party-stack/ontology-spec/effect";
+//#region src/live/pins.ts
+/** Pure metadata; binding it does not request or replace a download. */
+function definePin(name, options) {
+	return {
+		name: Schema.decodeUnknownSync(Schema.NonEmptyString)(name),
+		query: Schema.decodeUnknownSync(QueryDocumentSchema)(options.query),
+		attachments: options.attachments ?? "none"
+	};
+}
+const makeOntologyPins = Effect.fnUntraced(function* (options) {
+	const runtime = yield* Runtime;
+	const owner = yield* Effect.scope;
+	const captured = yield* Effect.context();
+	const control = yield* Effect.cached(Scope.provide(Effect.gen(function* () {
+		const backend = yield* options.backend;
+		return yield* makeReplica({
+			id: JSON.stringify([runtime.namespace, "pin-view"]),
+			ir: pinOntology,
+			backend,
+			context: {},
+			mutators: pinMutators
+		});
+	}).pipe(Effect.provideService(Runtime, runtime)), owner));
+	const collection = yield* scopedCollection(yield* persistedCollectionOptions({
+		id: JSON.stringify([runtime.namespace, "pins"]),
+		getKey: (row) => row.id,
+		primaryKey: "id",
+		changes: Stream.empty,
+		load: (subset) => Effect.flatMap(control, (replica) => replica.readSubset(ontologySubset(subset, pinOntology, "Pin"))).pipe(Effect.map((rows) => rows.map((row) => ({
+			key: row.key,
+			value: row.value
+		})))),
+		observe: (subset) => Stream.unwrap(Effect.map(control, (replica) => replica.observeSubset(ontologySubset(subset, pinOntology, "Pin")))).pipe(Stream.map((batch) => ({
+			...batch,
+			rows: batch.rows.map((row) => ({
+				key: row.key,
+				value: row.value
+			}))
+		}))),
+		acquireDemand: (subset) => Effect.flatMap(control, (replica) => replica.demand.acquire(ontologySubset(subset, pinOntology, "Pin")))
+	}), options.dbClient);
+	const update = (change) => Effect.runPromiseWith(captured)(Effect.suspend(() => owner.state._tag === "Closed" ? Effect.fail(new BackendError({
+		operation: "pins",
+		kind: "Unavailable",
+		retryable: false,
+		message: "Ontology view is closed."
+	})) : Effect.flatMap(Effect.forkIn(control.pipe(Effect.flatMap((replica) => replica.actions.apply({
+		id: crypto.randomUUID(),
+		name: "updatePins",
+		parameters: { change }
+	})), Effect.asVoid), owner, { startImmediately: true }), Fiber.join)));
+	const families = /* @__PURE__ */ new Map();
+	yield* Effect.addFinalizer(() => Effect.promise(async () => {
+		for (const family of families.values()) await family.collection.cleanup({ dependents: true });
+		families.clear();
+	}));
+	const bind = (descriptor) => {
+		const definition = pinDefinitionKey(descriptor);
+		const key = JSON.stringify([descriptor.name, definition]);
+		const previous = families.get(key);
+		if (previous) return previous;
+		const write = (inputs) => ({
+			...descriptor,
+			inputs: inputs ?? {}
+		});
+		const family = {
+			collection: createLiveQueryCollection({
+				id: `${collection.id}:${key}`,
+				autoIndex: "eager",
+				defaultIndexType: BasicIndex,
+				query: (q) => q.from({ pin: collection }).where(({ pin }) => and(eq(pin.name, descriptor.name), eq(pin.definition, definition))).select(({ pin }) => ({
+					id: pin.id,
+					name: pin.name,
+					definition: pin.definition,
+					query: pin.query,
+					inputs: pin.inputs,
+					attachments: pin.attachments,
+					generation: pin.generation,
+					ready: pin.ready,
+					error: pin.error
+				})),
+				getKey: (pin) => pin.id
+			}),
+			id: (inputs) => pinRecordKey(write(inputs)),
+			set: (inputs) => update({ set: [write(inputs)] }),
+			remove: (inputs) => update({ remove: [pinRecordKey(write(inputs))] }),
+			update: (change) => update({
+				set: change.set?.map(write),
+				remove: change.remove?.map((input) => pinRecordKey(write(input)))
+			}),
+			clear: () => update({ clearName: descriptor.name })
+		};
+		families.set(key, family);
+		return family;
+	};
+	return Object.assign(bind, {
+		collection,
+		remove: (id) => update({ remove: [id] }),
+		clear: (name) => update({ clearName: name })
+	});
+});
+//#endregion
+export { definePin, makeOntologyPins };
+
+//# sourceMappingURL=pins.js.map

package/lib/live/pins.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pins.js","names":[],"sources":["../../src/live/pins.ts"],"sourcesContent":["import { BackendError } from \"@party-stack/ontology-backend\";\nimport {\n    makeReplica,\n    pinOntology,\n    pinMutators,\n    pinRecordKey,\n    pinDefinitionKey,\n    type PinRecord,\n    type PinWrite,\n} from \"@party-stack/ontology-replica\";\nimport { QueryDocumentSchema } from \"@party-stack/ontology-spec/effect\";\nimport { Runtime } from \"@party-stack/runtime\";\nimport { BasicIndex, createLiveQueryCollection, eq, and, type Collection } from \"@tanstack/db\";\nimport { Effect, Fiber, Scope, Stream, Schema } from \"effect\";\nimport { persistedCollectionOptions, scopedCollection } from \"../tanstack/collections.js\";\nimport { ontologySubset } from \"../tanstack/subset.js\";\nimport type { OntologyBackendService } from \"@party-stack/ontology-backend\";\nimport type { QueryDocument } from \"@party-stack/ontology-spec\";\nimport type { DbClient } from \"@tanstack/db\";\n\nexport type PinInputs = Readonly<Record<string, unknown>>;\nexport type NoPinInputs = Record<string, never>;\ndeclare const pinInputType: unique symbol;\nexport interface PinDescriptor<Inputs extends PinInputs = NoPinInputs> {\n    readonly name: string;\n    readonly query: QueryDocument;\n    readonly attachments: \"none\" | \"all\";\n    readonly [pinInputType]?: Inputs;\n}\n/** Pure metadata; binding it does not request or replace a download. */\nexport function definePin<Inputs extends PinInputs = NoPinInputs>(\n    name: string,\n    options: { readonly query: QueryDocument; readonly attachments?: \"none\" | \"all\" }\n): PinDescriptor<Inputs> {\n    return {\n        name: Schema.decodeUnknownSync(Schema.NonEmptyString)(name),\n        query: Schema.decodeUnknownSync(QueryDocumentSchema)(options.query),\n        attachments: options.attachments ?? \"none\",\n    };\n}\nexport type PinInputArgs<Inputs extends PinInputs> = {} extends Inputs ? [inputs?: Inputs] : [inputs: Inputs];\nexport interface BoundPins<Inputs extends PinInputs> {\n    readonly collection: Collection<PinRecord<Inputs>>;\n    readonly id: (...args: PinInputArgs<Inputs>) => string;\n    readonly set: (...args: PinInputArgs<Inputs>) => Promise<void>;\n    readonly remove: (...args: PinInputArgs<Inputs>) => Promise<void>;\n    readonly update: (change: {\n        readonly set?: readonly Inputs[];\n        readonly remove?: readonly Inputs[];\n    }) => Promise<void>;\n    /** Remove this named family across all query revisions. */\n    readonly clear: () => Promise<void>;\n}\nexport interface OntologyPins {\n    <Inputs extends PinInputs>(definition: PinDescriptor<Inputs>): BoundPins<Inputs>;\n    readonly collection: Collection<PinRecord, string>;\n    readonly remove: (id: string) => Promise<void>;\n    readonly clear: (name: string) => Promise<void>;\n}\n\nexport const makeOntologyPins = Effect.fnUntraced(function* (options: {\n    readonly backend: Effect.Effect<OntologyBackendService, BackendError, Scope.Scope>;\n    readonly dbClient: DbClient;\n}) {\n    const runtime = yield* Runtime;\n    const owner = yield* Effect.scope;\n    const captured = yield* Effect.context<Runtime>();\n    // This is a scoped replica resource, not a result cache. Merely opening an\n    // application view does not open the administrative transport or acquire pins.\n    const control = yield* Effect.cached(\n        Scope.provide(\n            Effect.gen(function* () {\n                const backend = yield* options.backend;\n                return yield* makeReplica({\n                    id: JSON.stringify([runtime.namespace, \"pin-view\"]),\n                    ir: pinOntology,\n                    backend,\n                    context: {},\n                    mutators: pinMutators,\n                });\n            }).pipe(Effect.provideService(Runtime, runtime)),\n            owner\n        )\n    );\n    const collection = yield* scopedCollection(\n        yield* persistedCollectionOptions<PinRecord, string>({\n            id: JSON.stringify([runtime.namespace, \"pins\"]),\n            getKey: (row) => row.id,\n            primaryKey: \"id\",\n            changes: Stream.empty,\n            load: (subset) =>\n                Effect.flatMap(control, (replica) =>\n                    replica.readSubset(ontologySubset(subset, pinOntology, \"Pin\"))\n                ).pipe(\n                    Effect.map((rows) =>\n                        rows.map((row) => ({ key: row.key, value: row.value as unknown as PinRecord }))\n                    )\n                ),\n            observe: (subset) =>\n                Stream.unwrap(\n                    Effect.map(control, (replica) =>\n                        replica.observeSubset(ontologySubset(subset, pinOntology, \"Pin\"))\n                    )\n                ).pipe(\n                    Stream.map((batch) => ({\n                        ...batch,\n                        rows: batch.rows.map((row) => ({\n                            key: row.key,\n                            value: row.value as unknown as PinRecord,\n                        })),\n                    }))\n                ),\n            acquireDemand: (subset) =>\n                Effect.flatMap(control, (replica) =>\n                    replica.demand.acquire(ontologySubset(subset, pinOntology, \"Pin\"))\n                ),\n        }),\n        options.dbClient\n    );\n    const update = (change: { set?: readonly PinWrite[]; remove?: readonly string[]; clearName?: string }) =>\n        Effect.runPromiseWith(captured)(\n            Effect.suspend(() =>\n                owner.state._tag === \"Closed\"\n                    ? Effect.fail(\n                          new BackendError({\n                              operation: \"pins\",\n                              kind: \"Unavailable\",\n                              retryable: false,\n                              message: \"Ontology view is closed.\",\n                          })\n                      )\n                    : Effect.flatMap(\n                          Effect.forkIn(\n                              control.pipe(\n                                  Effect.flatMap((replica) =>\n                                      replica.actions.apply({\n                                          id: crypto.randomUUID(),\n                                          name: \"updatePins\",\n                                          parameters: { change },\n                                      })\n                                  ),\n                                  Effect.asVoid\n                              ),\n                              owner,\n                              { startImmediately: true }\n                          ),\n                          Fiber.join\n                      )\n            )\n        );\n    const families = new Map<string, BoundPins<PinInputs>>();\n    yield* Effect.addFinalizer(() =>\n        Effect.promise(async () => {\n            for (const family of families.values()) await family.collection.cleanup({ dependents: true });\n            families.clear();\n        })\n    );\n    const bind = <Inputs extends PinInputs>(descriptor: PinDescriptor<Inputs>): BoundPins<Inputs> => {\n        const definition = pinDefinitionKey(descriptor);\n        const key = JSON.stringify([descriptor.name, definition]);\n        const previous = families.get(key);\n        if (previous) return previous as BoundPins<Inputs>;\n        const write = (inputs?: PinInputs): PinWrite => ({ ...descriptor, inputs: inputs ?? {} });\n        const family: BoundPins<PinInputs> = {\n            collection: createLiveQueryCollection({\n                id: `${collection.id}:${key}`,\n                autoIndex: \"eager\",\n                defaultIndexType: BasicIndex,\n                query: (q) =>\n                    q\n                        .from({ pin: collection })\n                        .where(({ pin }) =>\n                            and(eq(pin.name, descriptor.name), eq(pin.definition, definition))\n                        )\n                        .select(({ pin }) => ({\n                            id: pin.id,\n                            name: pin.name,\n                            definition: pin.definition,\n                            query: pin.query,\n                            inputs: pin.inputs,\n                            attachments: pin.attachments,\n                            generation: pin.generation,\n                            ready: pin.ready,\n                            error: pin.error,\n                        })),\n                getKey: (pin) => pin.id,\n                // DB adds virtual columns to live-query rows. The public view keeps\n                // the validated Pin shape, narrowed to this descriptor's inputs.\n            }) as unknown as BoundPins<PinInputs>[\"collection\"],\n            id: (inputs) => pinRecordKey(write(inputs)),\n            set: (inputs) => update({ set: [write(inputs)] }),\n            remove: (inputs) => update({ remove: [pinRecordKey(write(inputs))] }),\n            update: (change) =>\n                update({\n                    set: change.set?.map(write),\n                    remove: change.remove?.map((input) => pinRecordKey(write(input))),\n                }),\n            clear: () => update({ clearName: descriptor.name }),\n        };\n        families.set(key, family);\n        return family as BoundPins<Inputs>;\n    };\n    return Object.assign(bind, {\n        collection,\n        remove: (id: string) => update({ remove: [id] }),\n        clear: (name: string) => update({ clearName: name }),\n    }) satisfies OntologyPins;\n});\n\nexport type { PinRecord } from \"@party-stack/ontology-replica\";\n"],"mappings":"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"}

package/lib/live/storageBackend.d.ts

@@ -0,0 +1,50 @@
+import { OntologyMutatorRegistry, OntologyQueryFunctionRegistry } from "./mutators/types.js";
+import { BackendError } from "@party-stack/ontology-backend";
+import { Effect } from "effect";
+import { StorageBackendOptions } from "@party-stack/ontology-backend/storage";
+//#region src/live/storageBackend.d.ts
+export interface StorageOntologyBackendOptions extends Omit<StorageBackendOptions, "mutators" | "queryFunctions"> {
+  readonly mutators?: OntologyMutatorRegistry;
+  readonly queryFunctions?: OntologyQueryFunctionRegistry;
+}
+/** SDK authoring adapter only; authoritative bytes, encryption and storage stay native. */
+export declare const makeStorageOntologyBackend: (options: StorageOntologyBackendOptions) => Effect.Effect<{
+  name: string;
+  sourceId: string;
+  supportsIdempotency: boolean;
+  loadSubset: (subset: import("@party-stack/ontology-spec/query").ObjectSubset) => Effect.Effect<import("@party-stack/ontology-backend").BackendSnapshot, BackendError>;
+  subscribeSelection?: (selection: import("@party-stack/ontology-backend").ObjectSelection, policy?: import("@party-stack/ontology-backend/delivery").DeliveryPolicy, resume?: import("@party-stack/ontology-backend/delivery").DeliveryPosition) => Effect.Effect<import("@party-stack/ontology-backend/delivery").DeliverySubscription, BackendError, import("effect/Scope").Scope>;
+  acknowledgeDelivery?: (position: import("@party-stack/ontology-backend/delivery").DeliveryPosition) => Effect.Effect<void, BackendError>;
+  watchSubset?: (subset: import("@party-stack/ontology-spec/query").ObjectSubset) => Effect.Effect<import("effect/Stream").Stream<import("@party-stack/ontology-backend").SubsetWatchEvent, BackendError>, BackendError, import("effect/Scope").Scope> | undefined;
+  refresh?: (subset: import("@party-stack/ontology-spec/query").ObjectSubset) => {
+    readonly pollIntervalMs?: number | false;
+    readonly maxCoverageAgeMs?: number;
+  } | undefined;
+  validateAction?: (name: string, parameters: Record<string, unknown>, options?: {
+    readonly knownParameters?: readonly string[];
+  }) => Effect.Effect<import("@party-stack/ontology-backend").ValidationReport, BackendError>;
+  queryFunction: (name: string, parameters: Record<string, unknown>) => Effect.Effect<unknown, BackendError>;
+  changes?: {
+    readonly pull: (options: {
+      readonly cursor?: string;
+      readonly limit?: number;
+    }) => Effect.Effect<import("@party-stack/ontology-backend").BackendChangePage, BackendError>;
+    readonly watch?: Effect.Effect<import("effect/Stream").Stream<void, BackendError>, BackendError, import("effect/Scope").Scope>;
+  };
+  attachments?: import("@party-stack/ontology-backend").BackendAttachments;
+  encrypted?: import("@party-stack/ontology-backend").BackendEncryptedValues;
+  storage: import("@party-stack/ontology-backend/owned").OwnedStorageService;
+  maintenance: Effect.Effect<void, BackendError<"Conflict" | "Forbidden" | "HistoryExpired" | "Internal" | "InvalidConfiguration" | "InvalidRequest" | "InvalidResponse" | "NotFound" | "NotImplemented" | "RateLimited" | "ResultExpired" | "SchemaMismatch" | "SessionExpired" | "SessionReplaced" | "SourceMismatch" | "Unauthenticated" | "Unavailable" | "ValidationFailed" | "ViewReplaced">, never>;
+  query: (document: import("@party-stack/ontology-spec").QueryDocument, options?: {
+    readonly inputs?: Record<string, unknown>;
+  }) => Effect.Effect<Record<string, unknown>, BackendError>;
+  applyAction: (invocation: import("@party-stack/ontology-backend").ActionRequest) => Effect.Effect<import("@party-stack/ontology-backend").ActionReceipt, BackendError<"Conflict" | "Forbidden" | "HistoryExpired" | "Internal" | "InvalidConfiguration" | "InvalidRequest" | "InvalidResponse" | "NotFound" | "NotImplemented" | "RateLimited" | "ResultExpired" | "SchemaMismatch" | "SessionExpired" | "SessionReplaced" | "SourceMismatch" | "Unauthenticated" | "Unavailable" | "ValidationFailed" | "ViewReplaced">, never>;
+  blobs: import("@party-stack/ontology-storage/blobs").BlobStorageService;
+  resolveActionParameters: (name: string, parameters: Record<string, unknown>) => Effect.Effect<Record<string, unknown>, BackendError<any>, never>;
+  collectGarbage: (options?: {
+    readonly orphanGraceMs?: number;
+    readonly limit?: number;
+  }) => Effect.Effect<number, BackendError<"Conflict" | "Forbidden" | "HistoryExpired" | "Internal" | "InvalidConfiguration" | "InvalidRequest" | "InvalidResponse" | "NotFound" | "NotImplemented" | "RateLimited" | "ResultExpired" | "SchemaMismatch" | "SessionExpired" | "SessionReplaced" | "SourceMismatch" | "Unauthenticated" | "Unavailable" | "ValidationFailed" | "ViewReplaced">, never>;
+}, BackendError<"Conflict" | "Forbidden" | "HistoryExpired" | "Internal" | "InvalidConfiguration" | "InvalidRequest" | "InvalidResponse" | "NotFound" | "NotImplemented" | "RateLimited" | "ResultExpired" | "SchemaMismatch" | "SessionExpired" | "SessionReplaced" | "SourceMismatch" | "Unauthenticated" | "Unavailable" | "ValidationFailed" | "ViewReplaced">, import("effect/Scope").Scope>;
+//#endregion
+//# sourceMappingURL=storageBackend.d.ts.map

package/lib/live/storageBackend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storageBackend.d.ts","names":[],"sources":["../../src/live/storageBackend.ts"],"mappings":";;;;;iBAQiB,sCAAsC,KACnD;WAGS,WAAW;WACX,iBAAiB;;;qBAiBjB,6BAA0B,SAAA,kCAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CrC,wXAAA"}

package/lib/live/storageBackend.js

@@ -0,0 +1,42 @@
+import { createReadTx } from "./mutators/createReadTx.js";
+import { executeTransactionMutator, withTransactionCollections } from "../runtime/transactions.js";
+import { BackendError } from "@party-stack/ontology-backend";
+import { Effect } from "effect";
+import { CurrentExecutionContext } from "@party-stack/ontology-backend/policy";
+import { makeStorageBackend } from "@party-stack/ontology-backend/storage";
+//#region src/live/storageBackend.ts
+const promise = (body) => Effect.tryPromise({
+	try: body,
+	catch: (cause) => cause instanceof BackendError ? cause : new BackendError({
+		operation: "queryFunction",
+		kind: "Internal",
+		message: "Query function failed.",
+		retryable: false,
+		cause
+	})
+});
+/** SDK authoring adapter only; authoritative bytes, encryption and storage stay native. */
+const makeStorageOntologyBackend = Effect.fn("StorageOntology.make")(function* (options) {
+	return yield* makeStorageBackend({
+		...options,
+		mutators: Object.fromEntries(options.ir.actionTypes.filter((action) => action.logic.length || options.mutators?.[action.name]).map((action) => [action.name, (tx, invocation) => Effect.flatMap(CurrentExecutionContext, (context) => executeTransactionMutator({
+			ir: options.ir,
+			tx,
+			name: invocation.name,
+			parameters: invocation.parameters,
+			operationId: invocation.id,
+			replay: invocation.replay,
+			context: context ?? options.context,
+			mutators: options.mutators
+		}))])),
+		queryFunctions: Object.fromEntries(Object.entries(options.queryFunctions ?? {}).map(([name, handler]) => [name, (tx, parameters) => Effect.flatMap(CurrentExecutionContext, (context) => withTransactionCollections(options.ir, tx, (objects, ensureLoaded) => promise(async () => handler({
+			tx: createReadTx(objects, ensureLoaded),
+			args: parameters,
+			context: context ?? options.context ?? {}
+		}))))]))
+	});
+});
+//#endregion
+export { makeStorageOntologyBackend };
+
+//# sourceMappingURL=storageBackend.js.map

package/lib/live/storageBackend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storageBackend.js","names":[],"sources":["../../src/live/storageBackend.ts"],"sourcesContent":["import { BackendError } from \"@party-stack/ontology-backend\";\nimport { CurrentExecutionContext } from \"@party-stack/ontology-backend/policy\";\nimport { makeStorageBackend } from \"@party-stack/ontology-backend/storage\";\nimport { Effect } from \"effect\";\nimport { executeTransactionMutator, withTransactionCollections } from \"../runtime/transactions.js\";\nimport { createReadTx } from \"./mutators/createReadTx.js\";\nimport type { OntologyMutatorRegistry, OntologyQueryFunctionRegistry } from \"./mutators/types.js\";\nimport type { StorageBackendOptions } from \"@party-stack/ontology-backend/storage\";\nexport interface StorageOntologyBackendOptions extends Omit<\n    StorageBackendOptions,\n    \"mutators\" | \"queryFunctions\"\n> {\n    readonly mutators?: OntologyMutatorRegistry;\n    readonly queryFunctions?: OntologyQueryFunctionRegistry;\n}\nconst promise = <A>(body: () => Promise<A>) =>\n    Effect.tryPromise({\n        try: body,\n        catch: (cause) =>\n            cause instanceof BackendError\n                ? cause\n                : new BackendError({\n                      operation: \"queryFunction\",\n                      kind: \"Internal\",\n                      message: \"Query function failed.\",\n                      retryable: false,\n                      cause,\n                  }),\n    });\n/** SDK authoring adapter only; authoritative bytes, encryption and storage stay native. */\nexport const makeStorageOntologyBackend = Effect.fn(\"StorageOntology.make\")(function* (\n    options: StorageOntologyBackendOptions\n) {\n    return yield* makeStorageBackend({\n        ...options,\n        mutators: Object.fromEntries(\n            options.ir.actionTypes\n                .filter((action) => action.logic.length || options.mutators?.[action.name])\n                .map((action) => [\n                    action.name,\n                    (tx, invocation) =>\n                        Effect.flatMap(CurrentExecutionContext, (context) =>\n                            executeTransactionMutator({\n                                ir: options.ir,\n                                tx,\n                                name: invocation.name,\n                                parameters: invocation.parameters,\n                                operationId: invocation.id,\n                                replay: invocation.replay,\n                                context: context ?? options.context,\n                                mutators: options.mutators,\n                            })\n                        ),\n                ])\n        ),\n        queryFunctions: Object.fromEntries(\n            Object.entries(options.queryFunctions ?? {}).map(([name, handler]) => [\n                name,\n                (tx, parameters) =>\n                    Effect.flatMap(CurrentExecutionContext, (context) =>\n                        withTransactionCollections(options.ir, tx, (objects, ensureLoaded) =>\n                            promise(async () =>\n                                handler({\n                                    tx: createReadTx(objects, ensureLoaded),\n                                    args: parameters,\n                                    context: context ?? options.context ?? {},\n                                })\n                            )\n                        )\n                    ),\n            ])\n        ),\n    });\n});\n"],"mappings":";;;;;;;AAeA,MAAM,WAAc,SAChB,OAAO,WAAW;CACd,KAAK;CACL,QAAQ,UACJ,iBAAiB,eACX,QACA,IAAI,aAAa;EACb,WAAW;EACX,MAAM;EACN,SAAS;EACT,WAAW;EACX;CACJ,CAAC;AACf,CAAC;;AAEL,MAAa,6BAA6B,OAAO,GAAG,sBAAsB,CAAC,CAAC,WACxE,SACF;CACE,OAAO,OAAO,mBAAmB;EAC7B,GAAG;EACH,UAAU,OAAO,YACb,QAAQ,GAAG,YACN,QAAQ,WAAW,OAAO,MAAM,UAAU,QAAQ,WAAW,OAAO,KAAK,CAAC,CAC1E,KAAK,WAAW,CACb,OAAO,OACN,IAAI,eACD,OAAO,QAAQ,0BAA0B,YACrC,0BAA0B;GACtB,IAAI,QAAQ;GACZ;GACA,MAAM,WAAW;GACjB,YAAY,WAAW;GACvB,aAAa,WAAW;GACxB,QAAQ,WAAW;GACnB,SAAS,WAAW,QAAQ;GAC5B,UAAU,QAAQ;EACtB,CAAC,CACL,CACR,CAAC,CACT;EACA,gBAAgB,OAAO,YACnB,OAAO,QAAQ,QAAQ,kBAAkB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,aAAa,CAClE,OACC,IAAI,eACD,OAAO,QAAQ,0BAA0B,YACrC,2BAA2B,QAAQ,IAAI,KAAK,SAAS,iBACjD,QAAQ,YACJ,QAAQ;GACJ,IAAI,aAAa,SAAS,YAAY;GACtC,MAAM;GACN,SAAS,WAAW,QAAQ,WAAW,CAAC;EAC5C,CAAC,CACL,CACJ,CACJ,CACR,CAAC,CACL;CACJ,CAAC;AACL,CAAC"}

package/lib/local.d.ts

@@ -0,0 +1,15 @@
+import { BackendError } from "@party-stack/ontology-backend";
+import { Effect, Scope } from "effect";
+import { OntologyServer } from "@party-stack/ontology-server";
+import { OntologyServerClient } from "@party-stack/ontology-server/rpc";
+//#region src/local.d.ts
+export interface LocalClientOptions {
+  readonly ontology?: string;
+}
+/** Same-process client over the normal server routes and RPC handlers.
+ * An Effect factory is acquired with the client and closed with its scope.
+ * An already acquired server is borrowed and keeps its existing lifetime.
+ */
+export declare const localClient: <R = never, E = never, ROpen = never>(server: Effect.Effect<OntologyServer<R>, E, ROpen> | OntologyServer<R>, options?: LocalClientOptions | undefined) => Effect.Effect<OntologyServerClient, BackendError<"Conflict" | "Forbidden" | "HistoryExpired" | "Internal" | "InvalidConfiguration" | "InvalidRequest" | "InvalidResponse" | "NotFound" | "NotImplemented" | "RateLimited" | "ResultExpired" | "SchemaMismatch" | "SessionExpired" | "SessionReplaced" | "SourceMismatch" | "Unauthenticated" | "Unavailable" | "ValidationFailed" | "ViewReplaced">, R | ROpen | Scope.Scope>;
+//#endregion
+//# sourceMappingURL=local.d.ts.map

package/lib/local.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local.d.ts","names":[],"sources":["../src/local.ts"],"mappings":";;;;;iBAOiB;WACJ;;;;;;qBAOA,cAA2C,WAAW,WAAW,eAAK,QAAA,OAAA,OAAA,eAAA,IAAA,GAAA,SAAA,eAAA,IAAA,UAAA,mCAAA,OAAA,OAAA,sBAAA,iWAAA,IAAA,QAAA,MAAA"}

package/lib/local.js

@@ -0,0 +1,19 @@
+import { classifyBackendFailure } from "@party-stack/ontology-backend";
+import { Effect, Exit, Scope } from "effect";
+import { makeOntologyLocalClient } from "@party-stack/ontology-server/rpc/local";
+//#region src/local.ts
+/** Same-process client over the normal server routes and RPC handlers.
+* An Effect factory is acquired with the client and closed with its scope.
+* An already acquired server is borrowed and keeps its existing lifetime.
+*/
+const localClient = Effect.fnUntraced(function* (server, options) {
+	const scope = yield* Scope.fork(yield* Effect.scope);
+	return yield* Scope.provide(Effect.gen(function* () {
+		const opened = yield* Effect.isEffect(server) ? server : Effect.succeed(server);
+		return yield* makeOntologyLocalClient(opened, options);
+	}).pipe(Effect.mapError((cause) => classifyBackendFailure("ontology.local", cause))), scope).pipe(Effect.onExit((exit) => Exit.isFailure(exit) ? Scope.close(scope, exit) : Effect.void));
+});
+//#endregion
+export { localClient };
+
+//# sourceMappingURL=local.js.map

package/lib/local.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"local.js","names":[],"sources":["../src/local.ts"],"sourcesContent":["import { classifyBackendFailure } from \"@party-stack/ontology-backend\";\nimport { makeOntologyLocalClient } from \"@party-stack/ontology-server/rpc/local\";\nimport { Effect, Exit, Scope } from \"effect\";\nimport type { BackendError } from \"@party-stack/ontology-backend\";\nimport type { OntologyServer } from \"@party-stack/ontology-server\";\nimport type { OntologyServerClient } from \"@party-stack/ontology-server/rpc\";\n\nexport interface LocalClientOptions {\n    readonly ontology?: string;\n}\n\n/** Same-process client over the normal server routes and RPC handlers.\n * An Effect factory is acquired with the client and closed with its scope.\n * An already acquired server is borrowed and keeps its existing lifetime.\n */\nexport const localClient = Effect.fnUntraced(function* <R = never, E = never, ROpen = never>(\n    server: OntologyServer<R> | Effect.Effect<OntologyServer<R>, E, ROpen>,\n    options?: LocalClientOptions\n): Effect.fn.Return<OntologyServerClient, BackendError, R | ROpen | Scope.Scope> {\n    const scope = yield* Scope.fork(yield* Effect.scope);\n    return yield* Scope.provide(\n        Effect.gen(function* () {\n            const opened = yield* Effect.isEffect(server) ? server : Effect.succeed(server);\n            return yield* makeOntologyLocalClient(opened, options);\n        }).pipe(Effect.mapError((cause) => classifyBackendFailure(\"ontology.local\", cause))),\n        scope\n    ).pipe(Effect.onExit((exit) => (Exit.isFailure(exit) ? Scope.close(scope, exit) : Effect.void)));\n});\n"],"mappings":";;;;;;;;AAeA,MAAa,cAAc,OAAO,WAAW,WACzC,QACA,SAC6E;CAC7E,MAAM,QAAQ,OAAO,MAAM,KAAK,OAAO,OAAO,KAAK;CACnD,OAAO,OAAO,MAAM,QAChB,OAAO,IAAI,aAAa;EACpB,MAAM,SAAS,OAAO,OAAO,SAAS,MAAM,IAAI,SAAS,OAAO,QAAQ,MAAM;EAC9E,OAAO,OAAO,wBAAwB,QAAQ,OAAO;CACzD,CAAC,CAAC,CAAC,KAAK,OAAO,UAAU,UAAU,uBAAuB,kBAAkB,KAAK,CAAC,CAAC,GACnF,KACJ,CAAC,CAAC,KAAK,OAAO,QAAQ,SAAU,KAAK,UAAU,IAAI,IAAI,MAAM,MAAM,OAAO,IAAI,IAAI,OAAO,IAAK,CAAC;AACnG,CAAC"}

package/lib/meta/generated/collections.d.ts

@@ -0,0 +1,7 @@
+import { OntologyCollectionDescriptors } from "../../tanstack/descriptors.js";
+import "../../index.js";
+import { MetaOntology } from "@party-stack/ontology-spec/meta";
+//#region src/meta/generated/collections.d.ts
+export declare const objects: OntologyCollectionDescriptors<MetaOntology, Record<never, never>>, cachedObjects: OntologyCollectionDescriptors<MetaOntology, Record<never, never>>;
+//#endregion
+//# sourceMappingURL=collections.d.ts.map

package/lib/meta/generated/collections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collections.d.ts","names":["_$______index_js0.OntologyCollectionDescriptors"],"sources":["../../../src/meta/generated/collections.ts"],"mappings":";;;;qBAKe,SAAOA,8BAAA,cAAA,uBAAE,eAAaA,8BAAA,cAAA"}

package/lib/meta/generated/collections.js

@@ -0,0 +1,15 @@
+import { ontologyCollections } from "../../tanstack/descriptors.js";
+import "../../index.js";
+//#region src/meta/generated/collections.ts
+const { objects, cachedObjects } = ontologyCollections({
+	Ontology: "id",
+	ValueType: "name",
+	ObjectType: "name",
+	LinkType: "id",
+	ActionType: "name",
+	QueryFunctionType: "name"
+});
+//#endregion
+export { cachedObjects, objects };
+
+//# sourceMappingURL=collections.js.map

package/lib/meta/generated/collections.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collections.js","names":[],"sources":["../../../src/meta/generated/collections.ts"],"sourcesContent":["// Auto-generated file - do not edit manually\n\nimport { ontologyCollections } from \"../../index.js\";\nimport type { MetaOntology } from \"@party-stack/ontology-spec/meta\";\n\nexport const { objects, cachedObjects } = ontologyCollections<MetaOntology>({\n    Ontology: \"id\",\n    ValueType: \"name\",\n    ObjectType: \"name\",\n    LinkType: \"id\",\n    ActionType: \"name\",\n    QueryFunctionType: \"name\",\n});\n"],"mappings":";;;AAKA,MAAa,EAAE,SAAS,kBAAkB,oBAAkC;CACxE,UAAU;CACV,WAAW;CACX,YAAY;CACZ,UAAU;CACV,YAAY;CACZ,mBAAmB;AACvB,CAAC"}

package/lib/meta/generated/live.d.ts

@@ -1,7 +1,7 @@
-import { CreateLiveOntologyOpts, LiveOntology } from "../../live/LiveOntology.js";
-import { MetaOntology, MetaOntologyContext } from "./types.js";
+import { LiveOntology, LiveOntologyFactoryOptions } from "../../live/LiveOntology.js";
 import "../../index.js";
+import { MetaOntology, MetaOntologyContext } from "@party-stack/ontology-spec/meta";
 //#region src/meta/generated/live.d.ts
-export declare function createMetaLiveOntology(opts: Omit<CreateLiveOntologyOpts<MetaOntologyContext>, "ir">): Promise<LiveOntology<MetaOntology>>;
+export declare function createMetaLiveOntology(opts: LiveOntologyFactoryOptions<MetaOntologyContext>): Promise<LiveOntology<MetaOntology>>;
 //#endregion
 //# sourceMappingURL=live.d.ts.map

package/lib/meta/generated/live.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"live.d.ts","names":[],"sources":["../../../src/meta/generated/live.ts"],"mappings":";;;;wBAMsB,uBAClB,MAAM,KAAK,uBAAuB,8BACnC,QAAQ,aAAa"}
+{"version":3,"file":"live.d.ts","names":[],"sources":["../../../src/meta/generated/live.ts"],"mappings":";;;;wBAMsB,uBAClB,MAAM,2BAA2B,uBAClC,QAAQ,aAAa"}

package/lib/meta/generated/live.js

@@ -1,11 +1,11 @@
 import { createLiveOntology } from "../../live/LiveOntology.js";
-import ontology_default from "../ontology.js";
 import "../../index.js";
+import ontology from "@party-stack/ontology-spec/meta";
 //#region src/meta/generated/live.ts
 async function createMetaLiveOntology(opts) {
 	return createLiveOntology({
 		...opts,
-		ir: ontology_default
+		ir: ontology
 	});
 }
 //#endregion

package/lib/meta/generated/live.js.map

@@ -1 +1 @@
-{"version":3,"file":"live.js","names":["ontology"],"sources":["../../../src/meta/generated/live.ts"],"sourcesContent":["// Auto-generated file - do not edit manually\n\nimport { createLiveOntology, type CreateLiveOntologyOpts, type LiveOntology } from \"../../index.js\";\nimport ontology from \"../ontology.js\";\nimport type { MetaOntology, MetaOntologyContext } from \"./types.js\";\n\nexport async function createMetaLiveOntology(\n    opts: Omit<CreateLiveOntologyOpts<MetaOntologyContext>, \"ir\">\n): Promise<LiveOntology<MetaOntology>> {\n    return createLiveOntology<MetaOntology, MetaOntologyContext>({\n        ...opts,\n        ir: ontology,\n    });\n}\n"],"mappings":";;;;AAMA,eAAsB,uBAClB,MACmC;CACnC,OAAO,mBAAsD;EACzD,GAAG;EACH,IAAIA;CACR,CAAC;AACL"}
+{"version":3,"file":"live.js","names":[],"sources":["../../../src/meta/generated/live.ts"],"sourcesContent":["// Auto-generated file - do not edit manually\n\nimport ontology from \"@party-stack/ontology-spec/meta\";\nimport { createLiveOntology, type LiveOntologyFactoryOptions, type LiveOntology } from \"../../index.js\";\nimport type { MetaOntology, MetaOntologyContext } from \"@party-stack/ontology-spec/meta\";\n\nexport async function createMetaLiveOntology(\n    opts: LiveOntologyFactoryOptions<MetaOntologyContext>\n): Promise<LiveOntology<MetaOntology>> {\n    return createLiveOntology<MetaOntology, MetaOntologyContext>({\n        ...opts,\n        ir: ontology,\n    });\n}\n"],"mappings":";;;;AAMA,eAAsB,uBAClB,MACmC;CACnC,OAAO,mBAAsD;EACzD,GAAG;EACH,IAAI;CACR,CAAC;AACL"}

package/lib/meta/pull.d.ts

@@ -1,12 +1,8 @@
-import { OntologyIR } from "../ir/generated/types.js";
-import { LiveOntology } from "../live/LiveOntology.js";
-import { MetaOntology } from "./generated/types.js";
+import { OntologyBackendService } from "@party-stack/ontology-backend";
+import { PullOptions, PullOptions as PullOptions$1 } from "@party-stack/ontology-backend/meta";
 //#region src/meta/pull.d.ts
-export interface PullOptions {
-  objectTypeNames: string[];
-  actionTypeNames: string[];
-  queryFunctionTypeNames: string[];
-}
-export declare function pull(ontology: LiveOntology<MetaOntology>, options: PullOptions): Promise<OntologyIR>;
+/** Promise facade over native metadata queries; no replica or UI collections are acquired. */
+export declare function pull(backend: Pick<OntologyBackendService, "query">, options: PullOptions$1): Promise<import("@party-stack/ontology-spec").OntologyIR>;
 //#endregion
+export type { PullOptions };
 //# sourceMappingURL=pull.d.ts.map

package/lib/meta/pull.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pull.d.ts","names":[],"sources":["../../src/meta/pull.ts"],"mappings":";;;;iBAyCiB;EACb;EACA;EACA;;wBAGkB,KAAK,UAAU,aAAa,eAAe,SAAS,cAAc,QAAQ"}
+{"version":3,"file":"pull.d.ts","names":["PullOptions"],"sources":["../../src/meta/pull.ts"],"mappings":";;;;wBAOsB,KAAK,SAAS,KAAK,kCAAkC,SAASA,gBAAW,6CAAA"}

package/lib/meta/pull.js

@@ -1,47 +1,9 @@
-import { Query, and, inArray, queryOnce } from "@tanstack/db";
+import { Effect } from "effect";
+import { pull as pull$1 } from "@party-stack/ontology-backend/meta";
 //#region src/meta/pull.ts
-function getValueTypes(type) {
-	switch (type.kind) {
-		case "list": return getValueTypes(type.value.elementType);
-		case "map": return [...getValueTypes(type.value.keyType), ...getValueTypes(type.value.valueType)];
-		case "optional": return getValueTypes(type.value.type);
-		case "result": return [...getValueTypes(type.value.okType), ...getValueTypes(type.value.errType)];
-		case "struct": return type.value.fields.flatMap((field) => getValueTypes(field.type));
-		case "ref": return [type.value.name];
-		default: return [];
-	}
-}
-function getObjectTypeValueTypes(objectType) {
-	return Array.from(new Set(objectType.properties.flatMap((p) => getValueTypes(p.type))));
-}
-function getActionTypeValueTypes(actionType) {
-	return actionType.parameters.flatMap((parameter) => getValueTypes(parameter.type));
-}
-function getQueryFunctionTypeValueTypes(queryFunctionType) {
-	return [...queryFunctionType.parameters.flatMap((parameter) => getValueTypes(parameter.type)), ...getValueTypes(queryFunctionType.returnType)];
-}
-async function pull(ontology, options) {
-	const { ValueType, ObjectType, LinkType, ActionType, QueryFunctionType } = ontology.objects;
-	const { objectTypeNames, actionTypeNames, queryFunctionTypeNames } = options;
-	const objectTypesQuery = new Query().from({ ObjectType }).where(({ ObjectType }) => inArray(ObjectType.name, objectTypeNames));
-	const objectTypes = await queryOnce(() => objectTypesQuery);
-	const [linkTypes, actionTypes, queryFunctionTypes] = await Promise.all([
-		queryOnce((q) => q.from({ LinkType }).where(({ LinkType }) => and(inArray(LinkType.source.objectType, objectTypeNames), inArray(LinkType.target.objectType, objectTypeNames)))),
-		queryOnce((q) => q.from({ ActionType }).where(({ ActionType }) => inArray(ActionType.name, actionTypeNames))),
-		queryOnce((q) => q.from({ QueryFunctionType }).where(({ QueryFunctionType }) => inArray(QueryFunctionType.name, queryFunctionTypeNames)))
-	]);
-	const valueTypeNames = Array.from(/* @__PURE__ */ new Set([
-		...objectTypes.flatMap(getObjectTypeValueTypes),
-		...actionTypes.flatMap(getActionTypeValueTypes),
-		...queryFunctionTypes.flatMap(getQueryFunctionTypeValueTypes)
-	]));
-	return {
-		types: await queryOnce((q) => q.from({ ValueType }).where(({ ValueType }) => inArray(ValueType.name, valueTypeNames))),
-		objectTypes,
-		linkTypes,
-		actionTypes,
-		queryFunctionTypes
-	};
+/** Promise facade over native metadata queries; no replica or UI collections are acquired. */
+async function pull(backend, options) {
+	return Effect.runPromise(pull$1(backend, options));
 }
 //#endregion
 export { pull };

package/lib/meta/pull.js.map

@@ -1 +1 @@
-{"version":3,"file":"pull.js","names":[],"sources":["../../src/meta/pull.ts"],"sourcesContent":["import { and, inArray, Query, queryOnce } from \"@tanstack/db\";\nimport type { OntologyIR } from \"../ir/generated/types.js\";\nimport type { LiveOntology } from \"../live/LiveOntology.js\";\nimport type { ActionType, MetaOntology, ObjectType, QueryFunctionType, TypeDef } from \"./generated/types.js\";\n\nfunction getValueTypes(type: TypeDef): string[] {\n    switch (type.kind) {\n        case \"list\":\n            return getValueTypes(type.value.elementType);\n        case \"map\":\n            return [...getValueTypes(type.value.keyType), ...getValueTypes(type.value.valueType)];\n        case \"optional\":\n            return getValueTypes(type.value.type);\n        case \"result\":\n            return [...getValueTypes(type.value.okType), ...getValueTypes(type.value.errType)];\n        case \"struct\":\n            return type.value.fields.flatMap((field) => getValueTypes(field.type));\n        case \"ref\":\n            return [type.value.name];\n        default:\n            return [];\n    }\n}\n\nfunction getObjectTypeValueTypes(objectType: ObjectType): string[] {\n    return Array.from(new Set(objectType.properties.flatMap((p) => getValueTypes(p.type))));\n}\n\nfunction getActionTypeValueTypes(actionType: ActionType): string[] {\n    return actionType.parameters.flatMap((parameter) => getValueTypes(parameter.type));\n}\n\nfunction getQueryFunctionTypeValueTypes(queryFunctionType: QueryFunctionType): string[] {\n    return [\n        ...queryFunctionType.parameters.flatMap((parameter) => getValueTypes(parameter.type)),\n        ...getValueTypes(queryFunctionType.returnType),\n    ];\n}\n\n// TODO: port this to pure queries once we can do some sort of explode operation.\n\nexport interface PullOptions {\n    objectTypeNames: string[];\n    actionTypeNames: string[];\n    queryFunctionTypeNames: string[];\n}\n\nexport async function pull(ontology: LiveOntology<MetaOntology>, options: PullOptions): Promise<OntologyIR> {\n    const { ValueType, ObjectType, LinkType, ActionType, QueryFunctionType } = ontology.objects;\n    const { objectTypeNames, actionTypeNames, queryFunctionTypeNames } = options;\n\n    const objectTypesQuery = new Query()\n        .from({ ObjectType })\n        .where(({ ObjectType }) => inArray(ObjectType.name, objectTypeNames));\n\n    const objectTypes = await queryOnce(() => objectTypesQuery);\n\n    const [linkTypes, actionTypes, queryFunctionTypes] = await Promise.all([\n        queryOnce((q) =>\n            q\n                .from({ LinkType })\n                .where(({ LinkType }) =>\n                    and(\n                        inArray(LinkType.source.objectType, objectTypeNames),\n                        inArray(LinkType.target.objectType, objectTypeNames)\n                    )\n                )\n        ),\n        queryOnce((q) =>\n            q.from({ ActionType }).where(({ ActionType }) => inArray(ActionType.name, actionTypeNames))\n        ),\n        queryOnce((q) =>\n            q\n                .from({ QueryFunctionType })\n                .where(({ QueryFunctionType }) => inArray(QueryFunctionType.name, queryFunctionTypeNames))\n        ),\n    ]);\n\n    const valueTypeNames = Array.from(\n        new Set([\n            ...objectTypes.flatMap(getObjectTypeValueTypes),\n            ...actionTypes.flatMap(getActionTypeValueTypes),\n            ...queryFunctionTypes.flatMap(getQueryFunctionTypeValueTypes),\n        ])\n    );\n\n    const types = await queryOnce((q) =>\n        q.from({ ValueType }).where(({ ValueType }) => inArray(ValueType.name, valueTypeNames))\n    );\n\n    return {\n        types,\n        objectTypes,\n        linkTypes,\n        actionTypes,\n        queryFunctionTypes,\n    };\n}\n"],"mappings":";;AAKA,SAAS,cAAc,MAAyB;CAC5C,QAAQ,KAAK,MAAb;EACI,KAAK,QACD,OAAO,cAAc,KAAK,MAAM,WAAW;EAC/C,KAAK,OACD,OAAO,CAAC,GAAG,cAAc,KAAK,MAAM,OAAO,GAAG,GAAG,cAAc,KAAK,MAAM,SAAS,CAAC;EACxF,KAAK,YACD,OAAO,cAAc,KAAK,MAAM,IAAI;EACxC,KAAK,UACD,OAAO,CAAC,GAAG,cAAc,KAAK,MAAM,MAAM,GAAG,GAAG,cAAc,KAAK,MAAM,OAAO,CAAC;EACrF,KAAK,UACD,OAAO,KAAK,MAAM,OAAO,SAAS,UAAU,cAAc,MAAM,IAAI,CAAC;EACzE,KAAK,OACD,OAAO,CAAC,KAAK,MAAM,IAAI;EAC3B,SACI,OAAO,CAAC;CAChB;AACJ;AAEA,SAAS,wBAAwB,YAAkC;CAC/D,OAAO,MAAM,KAAK,IAAI,IAAI,WAAW,WAAW,SAAS,MAAM,cAAc,EAAE,IAAI,CAAC,CAAC,CAAC;AAC1F;AAEA,SAAS,wBAAwB,YAAkC;CAC/D,OAAO,WAAW,WAAW,SAAS,cAAc,cAAc,UAAU,IAAI,CAAC;AACrF;AAEA,SAAS,+BAA+B,mBAAgD;CACpF,OAAO,CACH,GAAG,kBAAkB,WAAW,SAAS,cAAc,cAAc,UAAU,IAAI,CAAC,GACpF,GAAG,cAAc,kBAAkB,UAAU,CACjD;AACJ;AAUA,eAAsB,KAAK,UAAsC,SAA2C;CACxG,MAAM,EAAE,WAAW,YAAY,UAAU,YAAY,sBAAsB,SAAS;CACpF,MAAM,EAAE,iBAAiB,iBAAiB,2BAA2B;CAErE,MAAM,mBAAmB,IAAI,MAAM,CAAC,CAC/B,KAAK,EAAE,WAAW,CAAC,CAAC,CACpB,OAAO,EAAE,iBAAiB,QAAQ,WAAW,MAAM,eAAe,CAAC;CAExE,MAAM,cAAc,MAAM,gBAAgB,gBAAgB;CAE1D,MAAM,CAAC,WAAW,aAAa,sBAAsB,MAAM,QAAQ,IAAI;EACnE,WAAW,MACP,EACK,KAAK,EAAE,SAAS,CAAC,CAAC,CAClB,OAAO,EAAE,eACN,IACI,QAAQ,SAAS,OAAO,YAAY,eAAe,GACnD,QAAQ,SAAS,OAAO,YAAY,eAAe,CACvD,CACJ,CACR;EACA,WAAW,MACP,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,OAAO,EAAE,iBAAiB,QAAQ,WAAW,MAAM,eAAe,CAAC,CAC9F;EACA,WAAW,MACP,EACK,KAAK,EAAE,kBAAkB,CAAC,CAAC,CAC3B,OAAO,EAAE,wBAAwB,QAAQ,kBAAkB,MAAM,sBAAsB,CAAC,CACjG;CACJ,CAAC;CAED,MAAM,iBAAiB,MAAM,qBACzB,IAAI,IAAI;EACJ,GAAG,YAAY,QAAQ,uBAAuB;EAC9C,GAAG,YAAY,QAAQ,uBAAuB;EAC9C,GAAG,mBAAmB,QAAQ,8BAA8B;CAChE,CAAC,CACL;CAMA,OAAO;EACH,OAAA,MALgB,WAAW,MAC3B,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,OAAO,EAAE,gBAAgB,QAAQ,UAAU,MAAM,cAAc,CAAC,CAC1F;EAII;EACA;EACA;EACA;CACJ;AACJ"}
+{"version":3,"file":"pull.js","names":["pullNative"],"sources":["../../src/meta/pull.ts"],"sourcesContent":["import { pull as pullNative } from \"@party-stack/ontology-backend/meta\";\nimport { Effect } from \"effect\";\nimport type { OntologyBackendService } from \"@party-stack/ontology-backend\";\nimport type { PullOptions } from \"@party-stack/ontology-backend/meta\";\nexport type { PullOptions } from \"@party-stack/ontology-backend/meta\";\n\n/** Promise facade over native metadata queries; no replica or UI collections are acquired. */\nexport async function pull(backend: Pick<OntologyBackendService, \"query\">, options: PullOptions) {\n    return Effect.runPromise(pullNative(backend, options));\n}\n"],"mappings":";;;;AAOA,eAAsB,KAAK,SAAgD,SAAsB;CAC7F,OAAO,OAAO,WAAWA,OAAW,SAAS,OAAO,CAAC;AACzD"}

package/lib/query.d.ts

@@ -0,0 +1 @@
+export * from "@party-stack/ontology-spec/query";

package/lib/query.js

@@ -0,0 +1,2 @@
+export * from "@party-stack/ontology-spec/query";
+export {};

package/lib/runtime/host.d.ts

@@ -0,0 +1,35 @@
+import { LiveOntology, LiveOntologyWrites } from "../live/LiveOntology.js";
+import { ConnectionMonitor } from "@party-stack/connect";
+import { BackendError, OntologyBackendService } from "@party-stack/ontology-backend";
+import { Runtime } from "@party-stack/runtime";
+import { Effect, Scope } from "effect";
+import { OntologyIR } from "@party-stack/ontology-spec";
+import { ReplicaOptions, ReplicaService } from "@party-stack/ontology-replica";
+import { OntologySource } from "@party-stack/ontology-backend/protocol";
+//#region src/runtime/host.d.ts
+interface ReplicaHostCommonOptions {
+  readonly id?: string;
+  readonly live?: boolean;
+  readonly ir: OntologyIR;
+  readonly context: Record<string, unknown>;
+  readonly writes?: LiveOntologyWrites;
+  readonly authentication?: ConnectionMonitor;
+  readonly cache?: ReplicaOptions["cache"];
+  readonly demand?: ReplicaOptions["demand"];
+  readonly clientSessions?: ReplicaOptions["clientSessions"];
+}
+/** A native connection can additionally publish speculative parent state. */
+export type ReplicaHostOptions = ReplicaHostCommonOptions & {
+  readonly backend: OntologyBackendService;
+  readonly source?: OntologySource;
+};
+export interface ReplicaHostService {
+  readonly replica: ReplicaService;
+  readonly backend: OntologyBackendService;
+  readonly attachments: LiveOntology["attachments"];
+}
+/** Application facade: adapt authoring types and SDK promises around the native scoped host. */
+export declare const makeReplicaHost: (options: ReplicaHostOptions) => Effect.Effect<ReplicaHostService, BackendError<"Conflict" | "Forbidden" | "HistoryExpired" | "Internal" | "InvalidConfiguration" | "InvalidRequest" | "InvalidResponse" | "NotFound" | "NotImplemented" | "RateLimited" | "ResultExpired" | "SchemaMismatch" | "SessionExpired" | "SessionReplaced" | "SourceMismatch" | "Unauthenticated" | "Unavailable" | "ValidationFailed" | "ViewReplaced">, Runtime | Scope.Scope>;
+//#endregion
+export {};
+//# sourceMappingURL=host.d.ts.map

package/lib/runtime/host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.d.ts","names":[],"sources":["../../src/runtime/host.ts"],"mappings":";;;;;;;;;UAYU;WACG;WACA;WACA,IAAI;WACJ,SAAS;WACT,SAAS;WACT,iBAAiB;WACjB,QAAQ;WACR,SAAS;WACT,iBAAiB;;;YAGlB,qBAAqB;WACpB,SAAS;WACT,SAAS;;iBAEL;WACJ,SAAS;WACT,SAAS;WACT,aAAa;;;qBAIb,kBAAe,SAAA,uBAAA,OAAA,OAAA,oBAAA,iWAAA,UAAA,MAAA"}

package/lib/runtime/host.js

@@ -0,0 +1,39 @@
+import { createLiveOntologyAttachments } from "../live/attachments/createLiveOntologyAttachments.js";
+import { actionMutators } from "./transactions.js";
+import { Effect, Fiber } from "effect";
+import { makeReplica } from "@party-stack/ontology-replica";
+//#region src/runtime/host.ts
+/** Application facade: adapt authoring types and SDK promises around the native scoped host. */
+const makeReplicaHost = Effect.fn("OntologyHost.open")(function* (options) {
+	const backend = options.backend;
+	const replica = yield* makeReplica({
+		id: options.id,
+		live: options.live,
+		ir: options.ir,
+		context: options.context,
+		backend,
+		source: options.source,
+		mutators: actionMutators(options.ir, options.writes?.mutators),
+		outbox: options.writes?.outbox,
+		authentication: options.authentication,
+		cache: options.cache,
+		demand: options.demand,
+		clientSessions: options.clientSessions
+	});
+	const captured = yield* Effect.context();
+	const scope = yield* Effect.scope;
+	const run = (effect, signal) => Effect.runPromiseWith(captured)(Effect.flatMap(Effect.forkIn(effect, scope), (fiber) => Fiber.join(fiber).pipe(Effect.ensuring(Fiber.interrupt(fiber)))), { signal });
+	return {
+		replica,
+		backend,
+		attachments: createLiveOntologyAttachments({
+			attachments: replica.attachments,
+			run,
+			scope
+		})
+	};
+});
+//#endregion
+export { makeReplicaHost };
+
+//# sourceMappingURL=host.js.map

package/lib/runtime/host.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.js","names":[],"sources":["../../src/runtime/host.ts"],"sourcesContent":["import { makeReplica } from \"@party-stack/ontology-replica\";\nimport { Effect, Fiber } from \"effect\";\nimport { createLiveOntologyAttachments } from \"../live/attachments/createLiveOntologyAttachments.js\";\nimport { actionMutators } from \"./transactions.js\";\nimport type { LiveOntology, LiveOntologyWrites } from \"../live/LiveOntology.js\";\nimport type { ConnectionMonitor } from \"@party-stack/connect\";\nimport type { BackendError, OntologyBackendService } from \"@party-stack/ontology-backend\";\nimport type { OntologySource } from \"@party-stack/ontology-backend/protocol\";\nimport type { ReplicaOptions, ReplicaService } from \"@party-stack/ontology-replica\";\nimport type { OntologyIR } from \"@party-stack/ontology-spec\";\nimport type { Runtime } from \"@party-stack/runtime\";\nimport type { Scope } from \"effect\";\ninterface ReplicaHostCommonOptions {\n    readonly id?: string;\n    readonly live?: boolean;\n    readonly ir: OntologyIR;\n    readonly context: Record<string, unknown>;\n    readonly writes?: LiveOntologyWrites;\n    readonly authentication?: ConnectionMonitor;\n    readonly cache?: ReplicaOptions[\"cache\"];\n    readonly demand?: ReplicaOptions[\"demand\"];\n    readonly clientSessions?: ReplicaOptions[\"clientSessions\"];\n}\n/** A native connection can additionally publish speculative parent state. */\nexport type ReplicaHostOptions = ReplicaHostCommonOptions & {\n    readonly backend: OntologyBackendService;\n    readonly source?: OntologySource;\n};\nexport interface ReplicaHostService {\n    readonly replica: ReplicaService;\n    readonly backend: OntologyBackendService;\n    readonly attachments: LiveOntology[\"attachments\"];\n}\n\n/** Application facade: adapt authoring types and SDK promises around the native scoped host. */\nexport const makeReplicaHost = Effect.fn(\"OntologyHost.open\")(function* (\n    options: ReplicaHostOptions\n): Effect.fn.Return<ReplicaHostService, BackendError, Runtime | Scope.Scope> {\n    const backend = options.backend;\n    const replica = yield* makeReplica({\n        id: options.id,\n        live: options.live,\n        ir: options.ir,\n        context: options.context,\n        backend,\n        source: options.source,\n        mutators: actionMutators(options.ir, options.writes?.mutators),\n        outbox: options.writes?.outbox,\n        authentication: options.authentication,\n        cache: options.cache,\n        demand: options.demand,\n        clientSessions: options.clientSessions,\n    });\n    const captured = yield* Effect.context<never>();\n    const scope = yield* Effect.scope;\n    const run = <A>(effect: Effect.Effect<A, BackendError>, signal?: AbortSignal) =>\n        Effect.runPromiseWith(captured)(\n            Effect.flatMap(Effect.forkIn(effect, scope), (fiber) =>\n                Fiber.join(fiber).pipe(Effect.ensuring(Fiber.interrupt(fiber)))\n            ),\n            { signal }\n        );\n    return {\n        replica,\n        backend,\n        attachments: createLiveOntologyAttachments({ attachments: replica.attachments, run, scope }),\n    };\n});\n"],"mappings":";;;;;;AAmCA,MAAa,kBAAkB,OAAO,GAAG,mBAAmB,CAAC,CAAC,WAC1D,SACyE;CACzE,MAAM,UAAU,QAAQ;CACxB,MAAM,UAAU,OAAO,YAAY;EAC/B,IAAI,QAAQ;EACZ,MAAM,QAAQ;EACd,IAAI,QAAQ;EACZ,SAAS,QAAQ;EACjB;EACA,QAAQ,QAAQ;EAChB,UAAU,eAAe,QAAQ,IAAI,QAAQ,QAAQ,QAAQ;EAC7D,QAAQ,QAAQ,QAAQ;EACxB,gBAAgB,QAAQ;EACxB,OAAO,QAAQ;EACf,QAAQ,QAAQ;EAChB,gBAAgB,QAAQ;CAC5B,CAAC;CACD,MAAM,WAAW,OAAO,OAAO,QAAe;CAC9C,MAAM,QAAQ,OAAO,OAAO;CAC5B,MAAM,OAAU,QAAwC,WACpD,OAAO,eAAe,QAAQ,CAAC,CAC3B,OAAO,QAAQ,OAAO,OAAO,QAAQ,KAAK,IAAI,UAC1C,MAAM,KAAK,KAAK,CAAC,CAAC,KAAK,OAAO,SAAS,MAAM,UAAU,KAAK,CAAC,CAAC,CAClE,GACA,EAAE,OAAO,CACb;CACJ,OAAO;EACH;EACA;EACA,aAAa,8BAA8B;GAAE,aAAa,QAAQ;GAAa;GAAK;EAAM,CAAC;CAC/F;AACJ,CAAC"}

package/lib/runtime/index.d.ts

@@ -0,0 +1,2 @@
+import { makeLiveOntology } from "../live/LiveOntology.js";
+export { makeLiveOntology };

package/lib/runtime/index.js

@@ -0,0 +1 @@
+export { makeLiveOntology } from "../live/LiveOntology.js";

package/lib/runtime/live.d.ts

@@ -0,0 +1,25 @@
+import { LiveOntology } from "../live/LiveOntology.js";
+import "../index.js";
+import { ReplicaHostOptions } from "./host.js";
+import { Effect, Tracer } from "effect";
+import { TraceRecordingMode } from "@party-stack/runtime/tracing";
+//#region src/runtime/live.d.ts
+export type ReplicaLiveOptions = ReplicaHostOptions & {
+  readonly traceRecording?: TraceRecordingMode;
+};
+/** Native host acquisition with an independently configured tracer. No UI collections. */
+export declare const makeReplicaResource: (options: ReplicaLiveOptions) => Effect.Effect<{
+  replica: import("@party-stack/ontology-replica").ReplicaService;
+  backend: import("@party-stack/ontology-backend").OntologyBackendService;
+  attachments: LiveOntology["attachments"];
+  traces: {
+    tracer: Tracer.Tracer;
+    getSnapshot: () => readonly import("@party-stack/runtime/tracing").TraceRecord[];
+    subscribe: (listener: (record?: import("@party-stack/runtime/tracing").TraceRecord) => void) => () => void;
+    clear: () => void;
+  } | undefined;
+}, import("@party-stack/ontology-backend").BackendError<"Conflict" | "Forbidden" | "HistoryExpired" | "Internal" | "InvalidConfiguration" | "InvalidRequest" | "InvalidResponse" | "NotFound" | "NotImplemented" | "RateLimited" | "ResultExpired" | "SchemaMismatch" | "SessionExpired" | "SessionReplaced" | "SourceMismatch" | "Unauthenticated" | "Unavailable" | "ValidationFailed" | "ViewReplaced">, import("@party-stack/runtime").Runtime | import("effect/Scope").Scope>;
+/** SDK view over a scoped native host. */
+export declare const makeReplicaLiveOntology: (options: ReplicaLiveOptions) => Effect.Effect<Omit<LiveOntology<import("@party-stack/ontology-spec").OntologyDefinition>, "cleanup">, import("@party-stack/ontology-backend").BackendError<"Conflict" | "Forbidden" | "HistoryExpired" | "Internal" | "InvalidConfiguration" | "InvalidRequest" | "InvalidResponse" | "NotFound" | "NotImplemented" | "RateLimited" | "ResultExpired" | "SchemaMismatch" | "SessionExpired" | "SessionReplaced" | "SourceMismatch" | "Unauthenticated" | "Unavailable" | "ValidationFailed" | "ViewReplaced">, import("@party-stack/runtime").Runtime | import("effect/Scope").Scope>;
+//#endregion
+//# sourceMappingURL=live.d.ts.map