@party-stack/ontology 0.19.1 → 0.21.0

package/lib/json/index.js

@@ -1,132 +1,2 @@
-import { resolveType } from "../utils/types.js";
-import { invariant } from "@bobbyfidz/panic";
-import { Temporal } from "temporal-polyfill";
-//#region src/json/index.ts
-function assertRecord(value) {
-	invariant(typeof value === "object" && value !== null && !Array.isArray(value), "Expected JSON object.");
-}
-function assertArray(value) {
-	invariant(Array.isArray(value), "Expected JSON array.");
-}
-function getNamedType(ir, name) {
-	const namedType = ir.types.find((candidate) => candidate.name === name);
-	invariant(namedType, `Unknown ontology type "${name}".`);
-	return namedType.type;
-}
-function getObjectType(ir, name) {
-	const objectType = ir.objectTypes.find((candidate) => candidate.name === name);
-	invariant(objectType, `Unknown object type "${name}".`);
-	return objectType;
-}
-function getActionType(ir, name) {
-	const actionType = ir.actionTypes.find((candidate) => candidate.name === name);
-	invariant(actionType, `Unknown action type "${name}".`);
-	return actionType;
-}
-function getQueryFunctionType(ir, name) {
-	const queryFunctionType = ir.queryFunctionTypes.find((candidate) => candidate.name === name);
-	invariant(queryFunctionType, `Unknown query function type "${name}".`);
-	return queryFunctionType;
-}
-function resolveTargetType(ir, target) {
-	switch (target.kind) {
-		case "type": return getNamedType(ir, target.name);
-		case "object":
-		case "actionParameters":
-		case "queryFunctionParameters": return;
-		case "queryFunctionReturn": return getQueryFunctionType(ir, target.queryFunctionType).returnType;
-	}
-}
-function decodeValue(ir, type, value, normalizeOptionalNull = false) {
-	const resolvedType = resolveType(ir, type);
-	if (value === void 0) return void 0;
-	if (value === null) return normalizeOptionalNull && resolvedType.kind === "optional" ? void 0 : null;
-	switch (resolvedType.kind) {
-		case "timestamp": return typeof value === "string" ? Temporal.Instant.from(value) : value;
-		case "date": return typeof value === "string" ? Temporal.PlainDate.from(value) : value;
-		case "optional": return decodeValue(ir, resolvedType.value.type, value, normalizeOptionalNull);
-		case "list":
-			assertArray(value);
-			return value.map((item) => decodeValue(ir, resolvedType.value.elementType, item, normalizeOptionalNull));
-		case "map":
-			assertRecord(value);
-			return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, decodeValue(ir, resolvedType.value.valueType, entry, normalizeOptionalNull)]));
-		case "struct":
-			assertRecord(value);
-			return Object.fromEntries(Object.entries(value).map(([key, entry]) => {
-				const field = resolvedType.value.fields.find((candidate) => candidate.name === key);
-				return [key, field ? decodeValue(ir, field.type, entry, normalizeOptionalNull) : entry];
-			}));
-		default: return value;
-	}
-}
-function encodeValue(ir, type, value) {
-	if (value === void 0 || value === null) return value;
-	const resolvedType = resolveType(ir, type);
-	switch (resolvedType.kind) {
-		case "timestamp":
-		case "date":
-			invariant(typeof value === "object" && value !== null && typeof value.toString === "function", `Expected ${resolvedType.kind} value.`);
-			return value.toString();
-		case "optional": return encodeValue(ir, resolvedType.value.type, value);
-		case "list":
-			assertArray(value);
-			return value.map((item) => encodeValue(ir, resolvedType.value.elementType, item));
-		case "map":
-			assertRecord(value);
-			return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, encodeValue(ir, resolvedType.value.valueType, entry)]));
-		case "struct":
-			assertRecord(value);
-			return Object.fromEntries(Object.entries(value).map(([key, entry]) => {
-				const field = resolvedType.value.fields.find((candidate) => candidate.name === key);
-				return [key, field ? encodeValue(ir, field.type, entry) : entry];
-			}));
-		default: return value;
-	}
-}
-function decodeObject(ir, objectTypeName, value) {
-	assertRecord(value);
-	const objectType = getObjectType(ir, objectTypeName);
-	return Object.fromEntries(Object.entries(value).map(([key, entry]) => {
-		const property = objectType.properties.find((candidate) => candidate.name === key);
-		return [key, property ? decodeValue(ir, property.type, entry, true) : entry];
-	}));
-}
-function encodeObject(ir, objectTypeName, value) {
-	assertRecord(value);
-	const objectType = getObjectType(ir, objectTypeName);
-	return Object.fromEntries(Object.entries(value).map(([key, entry]) => {
-		const property = objectType.properties.find((candidate) => candidate.name === key);
-		return [key, property ? encodeValue(ir, property.type, entry) : entry];
-	}));
-}
-function decodeParameters(ir, parameters, value) {
-	assertRecord(value);
-	return Object.fromEntries(Object.entries(value).map(([key, entry]) => {
-		const parameter = parameters.find((candidate) => candidate.name === key);
-		return [key, parameter ? decodeValue(ir, parameter.type, entry) : entry];
-	}));
-}
-function encodeParameters(ir, parameters, value) {
-	assertRecord(value);
-	return Object.fromEntries(Object.entries(value).map(([key, entry]) => {
-		const parameter = parameters.find((candidate) => candidate.name === key);
-		return [key, parameter ? encodeValue(ir, parameter.type, entry) : entry];
-	}));
-}
-function decode(opts) {
-	if (opts.target.kind === "object") return decodeObject(opts.ir, opts.target.name, opts.value);
-	if (opts.target.kind === "actionParameters") return decodeParameters(opts.ir, getActionType(opts.ir, opts.target.actionType).parameters, opts.value);
-	if (opts.target.kind === "queryFunctionParameters") return decodeParameters(opts.ir, getQueryFunctionType(opts.ir, opts.target.queryFunctionType).parameters, opts.value);
-	return decodeValue(opts.ir, resolveTargetType(opts.ir, opts.target), opts.value, opts.target.kind === "queryFunctionReturn");
-}
-function encode(opts) {
-	if (opts.target.kind === "object") return encodeObject(opts.ir, opts.target.name, opts.value);
-	if (opts.target.kind === "actionParameters") return encodeParameters(opts.ir, getActionType(opts.ir, opts.target.actionType).parameters, opts.value);
-	if (opts.target.kind === "queryFunctionParameters") return encodeParameters(opts.ir, getQueryFunctionType(opts.ir, opts.target.queryFunctionType).parameters, opts.value);
-	return encodeValue(opts.ir, resolveTargetType(opts.ir, opts.target), opts.value);
-}
-//#endregion
-export { decode, encode };
-
-//# sourceMappingURL=index.js.map
+export * from "@party-stack/ontology-spec/json";
+export {};

package/lib/live/LiveOntology.d.ts

@@ -1,78 +1,142 @@
-import { OntologyIR } from "../ir/generated/types.js";
-import "../ir/index.js";
-import { OntologyBackendAdapterProvider } from "./OntologyBackendAdapter.js";
-import { LiveOntologyAttachments } from "./attachments/createLiveOntologyAttachments.js";
-import { OntologyObject } from "./objects/OntologyObject.js";
-import { OntologyCollection } from "./objects/createLiveOntologyObjectCollection.js";
 import { OntologyOutbox } from "./outbox/types.js";
 import { LiveOntologyAction, LiveOntologyActionOptions } from "./actions/createLiveOntologyAction.js";
+import { LiveOntologyAttachments } from "./attachments/createLiveOntologyAttachments.js";
 import { OntologyMutatorRegistry } from "./mutators/types.js";
-import { RuntimeAdapterProvider } from "@party-stack/runtime";
-import { ConnectionMonitor } from "@party-stack/connections";
+import { OntologyCollection } from "./objects/types.js";
+import { OntologyPins } from "./pins.js";
+import { ConnectionMonitor } from "@party-stack/connect";
+import { BackendError, OntologyBackendService } from "@party-stack/ontology-backend";
+import { Runtime, Runtimes, RuntimesLayer } from "@party-stack/runtime";
+import { Effect, Scope } from "effect";
+import { DbClient } from "@tanstack/db";
+import { OntologyDefinition, OntologyDefinition as OntologyDefinition$1, OntologyIR, QueryDocument } from "@party-stack/ontology-spec";
+import { TraceRecordingMode, TraceStore } from "@party-stack/runtime/tracing";
+import { DemandPolicy, PinGraph, PinOptions, PinOptions as PinOptions$1, PinStatus, PinStatus as PinStatus$1, ReplicaConfiguration, ReplicaMonitor, ReplicaOptions, ReplicaService } from "@party-stack/ontology-replica";
+import { OntologyClient, OntologyServerClient } from "@party-stack/ontology-server/rpc";
+import { Encrypted } from "@party-stack/ontology-spec/values";
 //#region src/live/LiveOntology.d.ts
-export type LiveOntologyWriteMode = "direct" | "outbox";
 export type LiveOntologyWriteVisibility = "confirmed" | "optimistic";
 export type LiveOntologyOutboxFailureStrategy = "pause" | "discard-all";
-export interface LiveOntologyOutboxOptions {
-  failureStrategy?: LiveOntologyOutboxFailureStrategy;
-  maxRetries?: number;
-}
+export type LiveOntologyOutboxOptions = NonNullable<ReplicaConfiguration["outbox"]>;
 export interface LiveOntologyWrites {
-  defaultMode?: LiveOntologyWriteMode;
   defaultVisibility?: LiveOntologyWriteVisibility;
   mutators?: OntologyMutatorRegistry;
   outbox?: LiveOntologyOutboxOptions;
 }
-export interface OntologyDefinition {
-  context?: Record<string, unknown>;
-  objectTypes: Record<string, OntologyObject>;
-  actionTypes: Record<string, {
-    parameters: Record<string, unknown>;
-  }>;
-  queryFunctionTypes: Record<string, {
-    parameters: Record<string, unknown>;
-    returnType: unknown;
-  }>;
-}
-type OntologyContext<Ontology extends OntologyDefinition> = Ontology extends {
+type OntologyContext<Ontology extends OntologyDefinition$1> = Ontology extends {
   context: infer Context extends Record<string, unknown>;
 } ? Context : Record<string, unknown>;
 export type LiveOntologyQueryFunction<Parameters extends Record<string, unknown> = Record<string, unknown>, Return = unknown> = (parameters: Parameters) => Promise<Return>;
-export type LiveOntologyObjects<ObjectTypes extends OntologyDefinition["objectTypes"] = OntologyDefinition["objectTypes"]> = { [ObjectTypeName in keyof ObjectTypes]: OntologyCollection<ObjectTypes[ObjectTypeName]>; };
-export type LiveOntologyActions<ActionTypes extends OntologyDefinition["actionTypes"]> = { [ActionTypeName in keyof ActionTypes]: LiveOntologyAction<ActionTypes[ActionTypeName]["parameters"]>; };
-export type LiveOntologyQueryFunctions<QueryFunctionTypes extends OntologyDefinition["queryFunctionTypes"]> = { [QueryFunctionTypeName in keyof QueryFunctionTypes]: LiveOntologyQueryFunction<QueryFunctionTypes[QueryFunctionTypeName]["parameters"], QueryFunctionTypes[QueryFunctionTypeName]["returnType"]>; };
-export interface LiveOntology<Ontology extends OntologyDefinition = OntologyDefinition> {
+export type LiveOntologyObjects<ObjectTypes extends OntologyDefinition$1["objectTypes"] = OntologyDefinition$1["objectTypes"]> = { readonly [ObjectTypeName in keyof ObjectTypes]: OntologyCollection<ObjectTypes[ObjectTypeName]>; };
+export type LiveOntologyActions<ActionTypes extends OntologyDefinition$1["actionTypes"]> = { [ActionTypeName in keyof ActionTypes]: LiveOntologyAction<ActionTypes[ActionTypeName]["parameters"], ActionTypes[ActionTypeName] extends {
+  returnType: infer Return;
+} ? Return : unknown, ActionTypes[ActionTypeName] extends {
+  inputParameters: infer Input extends Record<string, unknown>;
+} ? Input : ActionTypes[ActionTypeName]["parameters"]>; };
+export type LiveOntologyQueryFunctions<QueryFunctionTypes extends OntologyDefinition$1["queryFunctionTypes"]> = { [QueryFunctionTypeName in keyof QueryFunctionTypes]: LiveOntologyQueryFunction<QueryFunctionTypes[QueryFunctionTypeName]["parameters"], QueryFunctionTypes[QueryFunctionTypeName]["returnType"]>; };
+export interface OntologyDiagnostics {
+  readonly label?: string;
+  readonly role?: "host" | "replica";
+  readonly location?: string;
+  readonly replica: ReplicaMonitor;
+  readonly traces?: TraceStore;
+  readonly parent?: OntologyDiagnostics;
+}
+export interface DecryptOptions {
+  /** Default false: bypass the persistent decrypted-value cache. True permits a device-encrypted
+   * copy when the response is bound to this ciphertext (see the documented Foundry assumption).
+   * Cached device copies are removed with their replica rows.
+   */
+  readonly cache?: boolean;
+  readonly signal?: AbortSignal;
+}
+export type LiveOntologyDecrypt = <A>(value: Encrypted<A>, options?: DecryptOptions) => Promise<A>;
+export interface LiveOntologyPins extends OntologyPins {
+  /** The application's current offline graph, including its readiness. */
+  get(): Promise<PinStatus$1 | undefined>;
+  /** Replace the offline graph, retaining the previous graph until the replacement is ready.
+   * Server-backed clients target the parent's persistent replica, including from a memory tab.
+   * Standalone clients target their own replica. Attachments default to "none".
+   */
+  set(query: QueryDocument, options?: PinOptions$1): Promise<void>;
+  clear(name?: string): Promise<void>;
+  /** Receives the current pin and subsequent updates. Unsubscribe releases its stream.
+   * Native pin failures appear on status.error; transport failures call onError.
+   */
+  subscribe(listener: (status: PinStatus$1 | undefined) => void, onError?: (cause: unknown) => void): () => void;
+}
+export interface LiveOntology<Ontology extends OntologyDefinition$1 = OntologyDefinition$1> {
+  /** Scoped source-collection and query-identity owner. Supply to React's DbProvider or query options.
+   * The current TanStack release does not register browser hook queries for client cleanup.
+   */
+  readonly dbClient: DbClient;
   readonly ir: OntologyIR;
   readonly context: OntologyContext<Ontology>;
-  /**
-   * Resolves once outbox and blob metadata subsystems have finished starting.
-   * Object collections remain on-demand unless explicitly preloaded.
-   */
-  readonly ready: Promise<void>;
-  objects: LiveOntologyObjects<Ontology["objectTypes"]>;
+  /** Lazy typed collections. Consuming queries acquire upstream subset demand. */
+  readonly objects: LiveOntologyObjects<Ontology["objectTypes"]>;
+  /** Lazy cache inspection. These collections retain/observe local visible rows without upstream demand. */
+  readonly cachedObjects: LiveOntologyObjects<Ontology["objectTypes"]>;
+  traces?: TraceStore;
+  diagnostics?: OntologyDiagnostics;
+  readonly replica: ReplicaService;
   actions: LiveOntologyActions<Ontology["actionTypes"]>;
   queryFunctions: LiveOntologyQueryFunctions<Ontology["queryFunctionTypes"]>;
   attachments: LiveOntologyAttachments<Ontology>;
+  /** Explicit decryption of a top-level encrypted property handle. Ordinary queries never decrypt.
+   * A provider that only decrypts the property's current value may return a newer value than this
+   * handle; without identity evidence that response is never cached, even with cache:true.
+   */
+  decrypt: LiveOntologyDecrypt;
   outbox: OntologyOutbox;
+  readonly pins: LiveOntologyPins;
   cleanup: () => Promise<void>;
-  destroy: () => Promise<void>;
 }
-export interface CreateLiveOntologyOpts<Context extends Record<string, unknown> = Record<string, unknown>> {
+interface LiveOntologySettings<Context extends Record<string, unknown>> {
   id?: string;
-  ir: OntologyIR;
-  backend: OntologyBackendAdapterProvider<NoInfer<Context>>;
-  runtime?: RuntimeAdapterProvider;
-  persistObjects?: boolean;
+  live?: boolean;
+  /** Opt-in devtools trace history or a live-only diagnostic feed. */
+  traceRecording?: TraceRecordingMode;
+  demand?: DemandPolicy;
+  cache?: ReplicaOptions["cache"];
   writes?: LiveOntologyWrites;
   context?: Context;
-  connection?: ConnectionMonitor;
+  authentication?: ConnectionMonitor;
+  label?: string;
+  /** Attach parent diagnostics, including for committed-only clients.
+   * The endpoint must permit internal diagnostics for this caller.
+   */
+  parent?: {
+    readonly label?: string;
+    readonly location?: string;
+  };
+}
+interface BackendOntologyOptions<Context extends Record<string, unknown>> extends LiveOntologySettings<Context> {
+  ir: OntologyIR;
+  /** Borrow an acquired backend, or acquire one in the view's Scope with its Runtime. */
+  backend: OntologyBackendService | Effect.Effect<OntologyBackendService, BackendError, Scope.Scope | Runtime | Runtimes>;
+  client?: never;
+  ontology?: never;
+}
+interface ClientOntologyOptions<Context extends Record<string, unknown>> extends LiveOntologySettings<Context> {
+  /** Defaults to the authenticated server definition. Supply IR to verify it matches this client. */
+  ir?: OntologyIR;
+  client: OntologyServerClient | Effect.Effect<OntologyClient | OntologyServerClient, BackendError, Scope.Scope>;
+  /** Select a target on a shared server client; omission selects a single-ontology endpoint. */
+  ontology?: string;
+  backend?: never;
 }
-/**
- * Waits for LiveOntology subsystems required before safe use.
- * Starts on-demand object collection sync without loading subsets.
- */
-export declare function waitForLiveOntologyReady(ontology: LiveOntology): Promise<void>;
-export declare function createLiveOntology<Ontology extends OntologyDefinition = OntologyDefinition, Context extends Record<string, unknown> = Record<string, unknown>>(opts: CreateLiveOntologyOpts<Context>): Promise<LiveOntology<Ontology>>;
+export type LiveOntologyOptions<Context extends Record<string, unknown> = Record<string, unknown>> = BackendOntologyOptions<Context> | ClientOntologyOptions<Context>;
+export type CreateLiveOntologyOpts<Context extends Record<string, unknown> = Record<string, unknown>> = LiveOntologyOptions<Context> & {
+  runtime?: RuntimesLayer;
+};
+/** Generated factories supply their IR while preserving the backend/client choice. */
+export type LiveOntologyFactoryOptions<Context extends Record<string, unknown> = Record<string, unknown>> = (Omit<BackendOntologyOptions<Context>, "ir"> | Omit<ClientOntologyOptions<Context>, "ir">) & {
+  runtime?: RuntimesLayer;
+};
+/** SDK acquisition materializes collections only for callers requesting a view. */
+export declare const makeLiveOntology: <Ontology extends OntologyDefinition$1 = OntologyDefinition$1, Context extends Record<string, unknown> = Record<string, unknown>>(opts: LiveOntologyOptions<Context>) => Effect.Effect<LiveOntology<Ontology>, BackendError<"Conflict" | "Forbidden" | "HistoryExpired" | "Internal" | "InvalidConfiguration" | "InvalidRequest" | "InvalidResponse" | "NotFound" | "NotImplemented" | "RateLimited" | "ResultExpired" | "SchemaMismatch" | "SessionExpired" | "SessionReplaced" | "SourceMismatch" | "Unauthenticated" | "Unavailable" | "ValidationFailed" | "ViewReplaced"> | import("@party-stack/runtime").RuntimeAcquisitionError, Runtimes | Scope.Scope>;
+/** UI/SDK boundary; the native service above owns all implementation and cleanup. */
+export declare function createLiveOntology<Ontology extends OntologyDefinition$1 = OntologyDefinition$1, Context extends Record<string, unknown> = Record<string, unknown>>(opts: CreateLiveOntologyOpts<Context>): Promise<LiveOntology<Ontology>>;
 //#endregion
-export type { LiveOntologyAction, LiveOntologyActionOptions, LiveOntologyAttachments, OntologyCollection };
+export type { LiveOntologyAction, LiveOntologyActionOptions, LiveOntologyAttachments, OntologyCollection, OntologyDefinition, PinGraph, PinOptions, PinStatus };
 //# sourceMappingURL=LiveOntology.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"LiveOntology.d.ts","names":[],"sources":["../../src/live/LiveOntology.ts"],"mappings":";;;;;;;;;;;;YA0BY;YAEA;YAEA;iBAEK;EACb,kBAAkB;EAClB;;iBAGa;EACb,cAAc;EACd,oBAAoB;EACpB,WAAW;EACX,SAAS;;iBAGI;EACb,UAAU;EACV,aAAa,eAAe;EAC5B,aAAa;IAGL,YAAY;;EAGpB,oBAAoB;IAGZ,YAAY;IACZ;;;KAKP,gBAAgB,iBAAiB,sBAAsB;EACxD,eAAe,gBAAgB;IAE7B,UACA;YAEM,0BACR,mBAAmB,0BAA0B,yBAC7C,qBACC,YAAY,eAAe,QAAQ;YAE5B,oBACR,oBAAoB,oCAAoC,wCAEvD,wBAAwB,cAAc,mBAAmB,YAAY;YAG9D,oBAAoB,oBAAoB,wCAC/C,wBAAwB,cAAc,mBAAmB,YAAY;YAG9D,2BAA2B,2BAA2B,+CAEzD,+BAA+B,qBAAqB,0BACjD,mBAAmB,sCACnB,mBAAmB;iBAId,aAAa,iBAAiB,qBAAqB;WACvD,IAAI;WACJ,SAAS,gBAAgB;;;;;WAKzB,OAAO;EAChB,SAAS,oBAAoB;EAC7B,SAAS,oBAAoB;EAC7B,gBAAgB,2BAA2B;EAC3C,aAAa,wBAAwB;EACrC,QAAQ;EACR,eAAe;EACf,eAAe;;iBAGF,uBAAuB,gBAAgB,0BAA0B;EAC9E;EACA,IAAI;EACJ,SAAS,+BAA+B,QAAQ;EAChD,UAAU;EACV;EACA,SAAS;EACT,UAAU;EACV,aAAa;;;;;;wBAWK,yBAAyB,UAAU,eAAe;wBAOlD,mBAClB,iBAAiB,qBAAqB,oBACtC,gBAAgB,0BAA0B,yBAC5C,MAAM,uBAAuB,WAAW,QAAQ,aAAa"}
+{"version":3,"file":"LiveOntology.d.ts","names":["OntologyDefinition","PinStatus","PinOptions"],"sources":["../../src/live/LiveOntology.ts"],"mappings":";;;;;;;;;;;;;;;;;YAmCY;YAEA;YAEA,4BAA4B,YAAY;iBAEnC;EACb,oBAAoB;EACpB,WAAW;EACX,SAAS;;KAGR,gBAAgB,iBAAiBA,wBAAsB;EACxD,eAAe,gBAAgB;IAE7B,UACA;YAEM,0BACR,mBAAmB,0BAA0B,yBAC7C,qBACC,YAAY,eAAe,QAAQ;YAE5B,oBACR,oBAAoBA,sCAAoCA,mDAE9C,wBAAwB,cAAc,mBAAmB,YAAY;YAGvE,oBAAoB,oBAAoBA,0CAC/C,wBAAwB,cAAc,mBACnC,YAAY,+BACZ,YAAY;EAA0B,kBAAkB;IAAW,kBACnE,YAAY;EAA0B,uBAAuB,cAAc;IACrE,QACA,YAAY;YAId,2BAA2B,2BAA2BA,iDAEzD,+BAA+B,qBAAqB,0BACjD,mBAAmB,sCACnB,mBAAmB;iBAId;WACJ;WACA;WACA;WACA,SAAS;WACT,SAAS;WACT,SAAS;;iBAGL;;;;;WAKJ;WACA,SAAS;;YAEV,uBAAuB,GAAG,OAAO,UAAU,IAAI,UAAU,mBAAmB,QAAQ;iBAE/E,yBAAyB;;EAEtC,OAAO,QAAQC;;;;;EAKf,IAAI,OAAO,eAAe,UAAUC,eAAa;EACjD,MAAM,gBAAgB;;;;EAItB,UACI,WAAW,QAAQD,kCACnB,WAAW;;iBAIF,aAAa,iBAAiBD,uBAAqBA;;;;WAIvD,UAAU;WACV,IAAI;WACJ,SAAS,gBAAgB;;WAEzB,SAAS,oBAAoB;;WAE7B,eAAe,oBAAoB;EAC5C,SAAS;EACT,cAAc;WACL,SAAS;EAClB,SAAS,oBAAoB;EAC7B,gBAAgB,2BAA2B;EAC3C,aAAa,wBAAwB;;;;;EAKrC,SAAS;EACT,QAAQ;WACC,MAAM;EACf,eAAe;;UAGT,qBAAqB,gBAAgB;EAC3C;EACA;;EAEA,iBAAiB;EACjB,SAAS;EACT,QAAQ;EACR,SAAS;EACT,UAAU;EACV,iBAAiB;EACjB;;;;EAIA;aAAoB;aAAyB;;;UAGvC,uBACN,gBAAgB,iCACV,qBAAqB;EAC3B,IAAI;;EAEJ,SACM,yBACA,OAAO,OAAO,wBAAwB,cAAc,MAAM,QAAQ,UAAU;EAClF;EACA;;UAEM,sBACN,gBAAgB,iCACV,qBAAqB;;EAE3B,KAAK;EACL,QACM,uBACA,OAAO,OAAO,iBAAiB,sBAAsB,cAAc,MAAM;;EAE/E;EACA;;YAEQ,oBAAoB,gBAAgB,0BAA0B,2BACpE,uBAAuB,WACvB,sBAAsB;YAEhB,uBAAuB,gBAAgB,0BAA0B,2BACzE,oBAAoB;EAAa,UAAU;;;YAGnC,2BAA2B,gBAAgB,0BAA0B,4BAC3E,KAAK,uBAAuB,kBAC5B,KAAK,sBAAsB;EAC3B,UAAU;;;qBAGH,mBACT,iBAAiBA,uBAAkBA,sBACnC,gBAAgB,0BAAuB,yBAAA,MAAA,oBAAA,aAAA,OAAA,OAAA,aAAA,WAAA,iYAAA,yBAAA,WAAA,MAAA;;wBAOrB,mBAClB,iBAAiBA,uBAAqBA,sBACtC,gBAAgB,0BAA0B,yBAC5C,MAAM,uBAAuB,WAAW,QAAQ,aAAa"}

package/lib/live/LiveOntology.js

@@ -1,109 +1,29 @@
-import { provide } from "../utils/provide.js";
-import { createLiveOntologyActions } from "./actions/createLiveOntologyActions.js";
-import { createLiveOntologyAttachments } from "./attachments/createLiveOntologyAttachments.js";
-import { unsupportedOntologyAttachmentsAdapter } from "./attachments/unsupportedOntologyAttachmentsAdapter.js";
-import { createLiveOntologyObjectCollection } from "./objects/createLiveOntologyObjectCollection.js";
-import { waitForCollectionsReady } from "./waitForCollectionReady.js";
-import { createBlobManager } from "@party-stack/blobs";
-import { createDefaultRuntime } from "@party-stack/runtime";
+import { makeOntologyResource } from "../runtime/resource.js";
+import { MemoryRuntime, Runtimes } from "@party-stack/runtime";
+import { Effect, Exit, Layer, Scope } from "effect";
 //#region src/live/LiveOntology.ts
-function getContextUserId(context) {
-	return typeof context.user === "string" ? context.user : void 0;
-}
-/**
-* Waits for LiveOntology subsystems required before safe use.
-* Starts on-demand object collection sync without loading subsets.
-*/
-async function waitForLiveOntologyReady(ontology) {
-	await ontology.ready;
-	await waitForCollectionsReady(Object.values(ontology.objects));
-}
+/** SDK acquisition materializes collections only for callers requesting a view. */
+const makeLiveOntology = Effect.fn("Ontology.make")(function* (opts) {
+	return yield* (yield* makeOntologyResource(opts)).view;
+});
+/** UI/SDK boundary; the native service above owns all implementation and cleanup. */
 async function createLiveOntology(opts) {
-	const ontologyId = opts.id ?? "default";
-	const context = opts.context ?? {};
-	const owner = getContextUserId(context) ?? "anonymous";
-	const backendAdapter = await provide(opts.backend, opts.ir, context);
-	const runtime = await provide(opts.runtime ?? createDefaultRuntime, owner, ontologyId);
-	const attachmentsAdapter = backendAdapter.attachments ?? unsupportedOntologyAttachmentsAdapter;
-	const blobManager = createBlobManager({
-		runtime,
-		remote: {
-			read: (id, readOptions) => {
-				const attachmentValue = readOptions?.meta?.attachment;
-				return attachmentsAdapter.getAttachmentContent(attachmentValue ?? { id });
-			},
-			metadata: attachmentsAdapter.getAttachmentMetadata ? (id, readOptions) => attachmentsAdapter.getAttachmentMetadata(readOptions?.meta?.attachment ?? { id }, readOptions?.select ?? [
-				"size",
-				"type",
-				"name"
-			]) : void 0
-		}
-	});
-	const attachments = createLiveOntologyAttachments({
-		ir: opts.ir,
-		attachmentsAdapter,
-		blobManager
-	});
-	const objects = Object.fromEntries(opts.ir.objectTypes.map((objectType) => [objectType.name, createLiveOntologyObjectCollection({
-		ir: opts.ir,
-		objectType,
-		backendAdapter,
-		runtime,
-		persistObjects: opts.persistObjects ?? false
-	})]));
-	const actionsSubsystem = createLiveOntologyActions({
-		ir: opts.ir,
-		backendAdapter,
-		runtime,
-		context,
-		objects,
-		blobManager,
-		writes: opts.writes,
-		connection: opts.connection
-	});
-	const queryFunctions = Object.fromEntries(opts.ir.queryFunctionTypes.map((queryFunctionType) => [queryFunctionType.name, (parameters) => backendAdapter.runQueryFunction(queryFunctionType.name, parameters, {
-		objects,
-		context
-	})]));
-	const ready = Promise.all([actionsSubsystem.outbox.ready, blobManager.ready]).then(() => void 0);
-	ready.catch(() => void 0);
-	let cleanupPromise;
-	const cleanup = () => {
-		cleanupPromise ??= (async () => {
-			await Promise.allSettled([ready]);
-			await actionsSubsystem.outbox.cleanup();
-			await Promise.all(Object.values(objects).map(async (collection) => {
-				const status = collection.status;
-				if (status === "cleaned-up") return;
-				if (status === "loading") await Promise.allSettled([collection.preload()]);
-				try {
-					await collection.cleanup();
-				} catch {}
-			}));
-			await Promise.all([blobManager.cleanup(), backendAdapter.cleanup?.()]);
-			await runtime.cleanup?.();
-		})();
-		return cleanupPromise;
-	};
-	let destroyPromise;
-	const destroy = () => {
-		destroyPromise ??= cleanup().then(() => runtime.destroy?.()).then(() => void 0);
-		return destroyPromise;
-	};
-	return {
-		ir: opts.ir,
-		context,
-		ready,
-		objects,
-		actions: actionsSubsystem.actions,
-		queryFunctions,
-		attachments,
-		outbox: actionsSubsystem.outbox,
-		destroy,
-		cleanup
-	};
+	const scope = Effect.runSync(Scope.make());
+	try {
+		const context = await Effect.runPromise(Layer.buildWithScope(opts.runtime ?? Runtimes.layer(MemoryRuntime.layer), scope));
+		const live = await Effect.runPromise(Scope.provide(makeLiveOntology(opts).pipe(Effect.provideContext(context)), scope));
+		let closing;
+		const cleanup = () => closing ??= Effect.runPromise(Scope.close(scope, Exit.void));
+		return {
+			...live,
+			cleanup
+		};
+	} catch (cause) {
+		await Effect.runPromise(Scope.close(scope, Exit.fail(cause)));
+		throw cause;
+	}
 }
 //#endregion
-export { createLiveOntology, waitForLiveOntologyReady };
+export { createLiveOntology, makeLiveOntology };
 
 //# sourceMappingURL=LiveOntology.js.map

package/lib/live/LiveOntology.js.map

@@ -1 +1 @@
-{"version":3,"file":"LiveOntology.js","names":[],"sources":["../../src/live/LiveOntology.ts"],"sourcesContent":["import { createBlobManager, type BlobManager } from \"@party-stack/blobs\";\nimport { createDefaultRuntime, type RuntimeAdapterProvider } from \"@party-stack/runtime\";\nimport { type Collection } from \"@tanstack/db\";\nimport { provide } from \"../utils/provide.js\";\nimport { createLiveOntologyActions } from \"./actions/createLiveOntologyActions.js\";\nimport {\n    createLiveOntologyAttachments,\n    type LiveOntologyAttachments,\n} from \"./attachments/createLiveOntologyAttachments.js\";\nimport { unsupportedOntologyAttachmentsAdapter } from \"./attachments/unsupportedOntologyAttachmentsAdapter.js\";\nimport { createLiveOntologyObjectCollection } from \"./objects/createLiveOntologyObjectCollection.js\";\nimport { waitForCollectionsReady } from \"./waitForCollectionReady.js\";\nimport type { OntologyIR } from \"../ir/index.js\";\nimport type { attachment } from \"../utils/values.js\";\nimport type { LiveOntologyAction } from \"./actions/createLiveOntologyAction.js\";\nimport type { OntologyMutatorRegistry } from \"./mutators/types.js\";\nimport type { OntologyCollection } from \"./objects/createLiveOntologyObjectCollection.js\";\nimport type { OntologyObject } from \"./objects/OntologyObject.js\";\nimport type { OntologyBackendAdapter, OntologyBackendAdapterProvider } from \"./OntologyBackendAdapter.js\";\nimport type { OntologyOutbox } from \"./outbox/types.js\";\nimport type { ConnectionMonitor } from \"@party-stack/connections\";\n\nexport type { LiveOntologyAction, LiveOntologyActionOptions } from \"./actions/createLiveOntologyAction.js\";\nexport type { LiveOntologyAttachments } from \"./attachments/createLiveOntologyAttachments.js\";\nexport type { OntologyCollection } from \"./objects/createLiveOntologyObjectCollection.js\";\n\nexport type LiveOntologyWriteMode = \"direct\" | \"outbox\";\n\nexport type LiveOntologyWriteVisibility = \"confirmed\" | \"optimistic\";\n\nexport type LiveOntologyOutboxFailureStrategy = \"pause\" | \"discard-all\";\n\nexport interface LiveOntologyOutboxOptions {\n    failureStrategy?: LiveOntologyOutboxFailureStrategy;\n    maxRetries?: number;\n}\n\nexport interface LiveOntologyWrites {\n    defaultMode?: LiveOntologyWriteMode;\n    defaultVisibility?: LiveOntologyWriteVisibility;\n    mutators?: OntologyMutatorRegistry;\n    outbox?: LiveOntologyOutboxOptions;\n}\n\nexport interface OntologyDefinition {\n    context?: Record<string, unknown>;\n    objectTypes: Record<string, OntologyObject>;\n    actionTypes: Record<\n        string,\n        {\n            parameters: Record<string, unknown>;\n        }\n    >;\n    queryFunctionTypes: Record<\n        string,\n        {\n            parameters: Record<string, unknown>;\n            returnType: unknown;\n        }\n    >;\n}\n\ntype OntologyContext<Ontology extends OntologyDefinition> = Ontology extends {\n    context: infer Context extends Record<string, unknown>;\n}\n    ? Context\n    : Record<string, unknown>;\n\nexport type LiveOntologyQueryFunction<\n    Parameters extends Record<string, unknown> = Record<string, unknown>,\n    Return = unknown,\n> = (parameters: Parameters) => Promise<Return>;\n\nexport type LiveOntologyObjects<\n    ObjectTypes extends OntologyDefinition[\"objectTypes\"] = OntologyDefinition[\"objectTypes\"],\n> = {\n    [ObjectTypeName in keyof ObjectTypes]: OntologyCollection<ObjectTypes[ObjectTypeName]>;\n};\n\nexport type LiveOntologyActions<ActionTypes extends OntologyDefinition[\"actionTypes\"]> = {\n    [ActionTypeName in keyof ActionTypes]: LiveOntologyAction<ActionTypes[ActionTypeName][\"parameters\"]>;\n};\n\nexport type LiveOntologyQueryFunctions<QueryFunctionTypes extends OntologyDefinition[\"queryFunctionTypes\"]> =\n    {\n        [QueryFunctionTypeName in keyof QueryFunctionTypes]: LiveOntologyQueryFunction<\n            QueryFunctionTypes[QueryFunctionTypeName][\"parameters\"],\n            QueryFunctionTypes[QueryFunctionTypeName][\"returnType\"]\n        >;\n    };\n\nexport interface LiveOntology<Ontology extends OntologyDefinition = OntologyDefinition> {\n    readonly ir: OntologyIR;\n    readonly context: OntologyContext<Ontology>;\n    /**\n     * Resolves once outbox and blob metadata subsystems have finished starting.\n     * Object collections remain on-demand unless explicitly preloaded.\n     */\n    readonly ready: Promise<void>;\n    objects: LiveOntologyObjects<Ontology[\"objectTypes\"]>;\n    actions: LiveOntologyActions<Ontology[\"actionTypes\"]>;\n    queryFunctions: LiveOntologyQueryFunctions<Ontology[\"queryFunctionTypes\"]>;\n    attachments: LiveOntologyAttachments<Ontology>;\n    outbox: OntologyOutbox;\n    cleanup: () => Promise<void>;\n    destroy: () => Promise<void>;\n}\n\nexport interface CreateLiveOntologyOpts<Context extends Record<string, unknown> = Record<string, unknown>> {\n    id?: string;\n    ir: OntologyIR;\n    backend: OntologyBackendAdapterProvider<NoInfer<Context>>;\n    runtime?: RuntimeAdapterProvider;\n    persistObjects?: boolean;\n    writes?: LiveOntologyWrites;\n    context?: Context;\n    connection?: ConnectionMonitor;\n}\n\nfunction getContextUserId(context: Record<string, unknown>): string | undefined {\n    return typeof context.user === \"string\" ? context.user : undefined;\n}\n\n/**\n * Waits for LiveOntology subsystems required before safe use.\n * Starts on-demand object collection sync without loading subsets.\n */\nexport async function waitForLiveOntologyReady(ontology: LiveOntology): Promise<void> {\n    await ontology.ready;\n    await waitForCollectionsReady(\n        Object.values(ontology.objects) as Collection<Record<string, unknown>, string | number>[]\n    );\n}\n\nexport async function createLiveOntology<\n    Ontology extends OntologyDefinition = OntologyDefinition,\n    Context extends Record<string, unknown> = Record<string, unknown>,\n>(opts: CreateLiveOntologyOpts<Context>): Promise<LiveOntology<Ontology>> {\n    const ontologyId = opts.id ?? \"default\";\n    const context = (opts.context ?? {}) as Context;\n    const owner = getContextUserId(context) ?? \"anonymous\";\n    // TODO(errors): Decorate backend operations and collection options so\n    // normalized errors (especially UnauthenticatedError) are reported through\n    // the ConnectionMonitor. Promise-based calls can be wrapped directly;\n    // long-running sync handlers need a lifecycle-aware supervisor that pauses\n    // on needs-auth and restarts from a checkpoint after reconnection.\n    const backendAdapter: OntologyBackendAdapter = await provide(opts.backend, opts.ir, context);\n    const runtime = await provide(opts.runtime ?? createDefaultRuntime, owner, ontologyId);\n    const attachmentsAdapter = backendAdapter.attachments ?? unsupportedOntologyAttachmentsAdapter;\n    const blobManager: BlobManager = createBlobManager({\n        runtime,\n        remote: {\n            read: (id, readOptions) => {\n                const attachmentValue = readOptions?.meta?.attachment as attachment | undefined;\n                return attachmentsAdapter.getAttachmentContent(attachmentValue ?? { id });\n            },\n            metadata: attachmentsAdapter.getAttachmentMetadata\n                ? (id, readOptions) =>\n                      attachmentsAdapter.getAttachmentMetadata!(\n                          (readOptions?.meta?.attachment as attachment | undefined) ?? { id },\n                          readOptions?.select ?? [\"size\", \"type\", \"name\"]\n                      )\n                : undefined,\n        },\n    });\n    const attachments = createLiveOntologyAttachments<Ontology>({\n        ir: opts.ir,\n        attachmentsAdapter,\n        blobManager,\n    });\n    const objects = Object.fromEntries(\n        opts.ir.objectTypes.map((objectType) => [\n            objectType.name,\n            createLiveOntologyObjectCollection({\n                ir: opts.ir,\n                objectType,\n                backendAdapter,\n                runtime,\n                persistObjects: opts.persistObjects ?? false,\n            }),\n        ])\n    ) as Record<string, OntologyCollection<OntologyObject>>;\n    const actionsSubsystem = createLiveOntologyActions({\n        ir: opts.ir,\n        backendAdapter,\n        runtime,\n        context,\n        objects,\n        blobManager,\n        writes: opts.writes,\n        connection: opts.connection,\n    });\n    const queryFunctions = Object.fromEntries(\n        opts.ir.queryFunctionTypes.map((queryFunctionType) => [\n            queryFunctionType.name,\n            (parameters: Record<string, unknown>) =>\n                backendAdapter.runQueryFunction(queryFunctionType.name, parameters, {\n                    objects: objects,\n                    context,\n                }),\n        ])\n    );\n    const ready = Promise.all([actionsSubsystem.outbox.ready, blobManager.ready]).then(() => undefined);\n    void ready.catch(() => undefined);\n\n    let cleanupPromise: Promise<void> | undefined;\n    const cleanup = (): Promise<void> => {\n        cleanupPromise ??= (async () => {\n            // Settle subsystem startups before tearing down persistence.\n            await Promise.allSettled([ready]);\n            await actionsSubsystem.outbox.cleanup();\n            await Promise.all(\n                Object.values(objects).map(async (collection) => {\n                    const status = collection.status;\n                    if (status === \"cleaned-up\") {\n                        return;\n                    }\n                    // Settle in-flight startup only; ready/idle need no preload.\n                    if (status === \"loading\") {\n                        await Promise.allSettled([collection.preload()]);\n                    }\n                    try {\n                        await collection.cleanup();\n                    } catch {\n                        // Idempotent: already cleaned up during preload race.\n                    }\n                })\n            );\n            await Promise.all([blobManager.cleanup(), backendAdapter.cleanup?.()]);\n            await runtime.cleanup?.();\n        })();\n        return cleanupPromise;\n    };\n    let destroyPromise: Promise<void> | undefined;\n    const destroy = (): Promise<void> => {\n        destroyPromise ??= cleanup()\n            .then(() => runtime.destroy?.())\n            .then(() => undefined);\n        return destroyPromise;\n    };\n\n    return {\n        ir: opts.ir,\n        context: context as unknown as OntologyContext<Ontology>,\n        ready,\n        objects: objects as unknown as LiveOntologyObjects<Ontology[\"objectTypes\"]>,\n        actions: actionsSubsystem.actions as unknown as LiveOntologyActions<Ontology[\"actionTypes\"]>,\n        queryFunctions: queryFunctions as unknown as LiveOntologyQueryFunctions<\n            Ontology[\"queryFunctionTypes\"]\n        >,\n        attachments,\n        outbox: actionsSubsystem.outbox,\n        destroy,\n        cleanup,\n    };\n}\n"],"mappings":";;;;;;;;;AAuHA,SAAS,iBAAiB,SAAsD;CAC5E,OAAO,OAAO,QAAQ,SAAS,WAAW,QAAQ,OAAO,KAAA;AAC7D;;;;;AAMA,eAAsB,yBAAyB,UAAuC;CAClF,MAAM,SAAS;CACf,MAAM,wBACF,OAAO,OAAO,SAAS,OAAO,CAClC;AACJ;AAEA,eAAsB,mBAGpB,MAAwE;CACtE,MAAM,aAAa,KAAK,MAAM;CAC9B,MAAM,UAAW,KAAK,WAAW,CAAC;CAClC,MAAM,QAAQ,iBAAiB,OAAO,KAAK;CAM3C,MAAM,iBAAyC,MAAM,QAAQ,KAAK,SAAS,KAAK,IAAI,OAAO;CAC3F,MAAM,UAAU,MAAM,QAAQ,KAAK,WAAW,sBAAsB,OAAO,UAAU;CACrF,MAAM,qBAAqB,eAAe,eAAe;CACzD,MAAM,cAA2B,kBAAkB;EAC/C;EACA,QAAQ;GACJ,OAAO,IAAI,gBAAgB;IACvB,MAAM,kBAAkB,aAAa,MAAM;IAC3C,OAAO,mBAAmB,qBAAqB,mBAAmB,EAAE,GAAG,CAAC;GAC5E;GACA,UAAU,mBAAmB,yBACtB,IAAI,gBACD,mBAAmB,sBACd,aAAa,MAAM,cAAyC,EAAE,GAAG,GAClE,aAAa,UAAU;IAAC;IAAQ;IAAQ;GAAM,CAClD,IACJ,KAAA;EACV;CACJ,CAAC;CACD,MAAM,cAAc,8BAAwC;EACxD,IAAI,KAAK;EACT;EACA;CACJ,CAAC;CACD,MAAM,UAAU,OAAO,YACnB,KAAK,GAAG,YAAY,KAAK,eAAe,CACpC,WAAW,MACX,mCAAmC;EAC/B,IAAI,KAAK;EACT;EACA;EACA;EACA,gBAAgB,KAAK,kBAAkB;CAC3C,CAAC,CACL,CAAC,CACL;CACA,MAAM,mBAAmB,0BAA0B;EAC/C,IAAI,KAAK;EACT;EACA;EACA;EACA;EACA;EACA,QAAQ,KAAK;EACb,YAAY,KAAK;CACrB,CAAC;CACD,MAAM,iBAAiB,OAAO,YAC1B,KAAK,GAAG,mBAAmB,KAAK,sBAAsB,CAClD,kBAAkB,OACjB,eACG,eAAe,iBAAiB,kBAAkB,MAAM,YAAY;EACvD;EACT;CACJ,CAAC,CACT,CAAC,CACL;CACA,MAAM,QAAQ,QAAQ,IAAI,CAAC,iBAAiB,OAAO,OAAO,YAAY,KAAK,CAAC,CAAC,CAAC,WAAW,KAAA,CAAS;CAClG,MAAW,YAAY,KAAA,CAAS;CAEhC,IAAI;CACJ,MAAM,gBAA+B;EACjC,oBAAoB,YAAY;GAE5B,MAAM,QAAQ,WAAW,CAAC,KAAK,CAAC;GAChC,MAAM,iBAAiB,OAAO,QAAQ;GACtC,MAAM,QAAQ,IACV,OAAO,OAAO,OAAO,CAAC,CAAC,IAAI,OAAO,eAAe;IAC7C,MAAM,SAAS,WAAW;IAC1B,IAAI,WAAW,cACX;IAGJ,IAAI,WAAW,WACX,MAAM,QAAQ,WAAW,CAAC,WAAW,QAAQ,CAAC,CAAC;IAEnD,IAAI;KACA,MAAM,WAAW,QAAQ;IAC7B,QAAQ,CAER;GACJ,CAAC,CACL;GACA,MAAM,QAAQ,IAAI,CAAC,YAAY,QAAQ,GAAG,eAAe,UAAU,CAAC,CAAC;GACrE,MAAM,QAAQ,UAAU;EAC5B,EAAA,CAAG;EACH,OAAO;CACX;CACA,IAAI;CACJ,MAAM,gBAA+B;EACjC,mBAAmB,QAAQ,CAAC,CACvB,WAAW,QAAQ,UAAU,CAAC,CAAC,CAC/B,WAAW,KAAA,CAAS;EACzB,OAAO;CACX;CAEA,OAAO;EACH,IAAI,KAAK;EACA;EACT;EACS;EACT,SAAS,iBAAiB;EACV;EAGhB;EACA,QAAQ,iBAAiB;EACzB;EACA;CACJ;AACJ"}
+{"version":3,"file":"LiveOntology.js","names":[],"sources":["../../src/live/LiveOntology.ts"],"sourcesContent":["import type { ReplicaService } from \"@party-stack/ontology-replica\";\nimport type {\n    ReplicaConfiguration,\n    ReplicaOptions,\n    DemandPolicy,\n    ReplicaMonitor,\n    PinOptions,\n    PinStatus,\n} from \"@party-stack/ontology-replica\";\nimport type { OntologyDefinition } from \"@party-stack/ontology-spec\";\nimport type { Encrypted } from \"@party-stack/ontology-spec/values\";\nimport type { TraceStore, TraceRecordingMode } from \"@party-stack/runtime/tracing\";\nimport type { DbClient } from \"@tanstack/db\";\nexport type { OntologyDefinition } from \"@party-stack/ontology-spec\";\nexport type { PinOptions, PinStatus, PinGraph } from \"@party-stack/ontology-replica\";\nimport { MemoryRuntime, Runtimes, type RuntimesLayer } from \"@party-stack/runtime\";\nimport { Effect, Exit, Scope, Layer } from \"effect\";\nimport { makeOntologyResource } from \"../runtime/resource.js\";\nimport type { LiveOntologyAction } from \"./actions/createLiveOntologyAction.js\";\nimport type { LiveOntologyAttachments } from \"./attachments/createLiveOntologyAttachments.js\";\nimport type { OntologyMutatorRegistry } from \"./mutators/types.js\";\nimport type { OntologyCollection } from \"./objects/types.js\";\nimport type { OntologyOutbox } from \"./outbox/types.js\";\nimport type { OntologyPins } from \"./pins.js\";\nimport type { ConnectionMonitor } from \"@party-stack/connect\";\nimport type { OntologyBackendService } from \"@party-stack/ontology-backend\";\nimport type { BackendError } from \"@party-stack/ontology-backend\";\nimport type { OntologyClient, OntologyServerClient } from \"@party-stack/ontology-server/rpc\";\nimport type { OntologyIR, QueryDocument } from \"@party-stack/ontology-spec\";\nimport type { Runtime } from \"@party-stack/runtime\";\n\nexport type { LiveOntologyAction, LiveOntologyActionOptions } from \"./actions/createLiveOntologyAction.js\";\nexport type { LiveOntologyAttachments } from \"./attachments/createLiveOntologyAttachments.js\";\nexport type { OntologyCollection } from \"./objects/types.js\";\n\nexport type LiveOntologyWriteVisibility = \"confirmed\" | \"optimistic\";\n\nexport type LiveOntologyOutboxFailureStrategy = \"pause\" | \"discard-all\";\n\nexport type LiveOntologyOutboxOptions = NonNullable<ReplicaConfiguration[\"outbox\"]>;\n\nexport interface LiveOntologyWrites {\n    defaultVisibility?: LiveOntologyWriteVisibility;\n    mutators?: OntologyMutatorRegistry;\n    outbox?: LiveOntologyOutboxOptions;\n}\n\ntype OntologyContext<Ontology extends OntologyDefinition> = Ontology extends {\n    context: infer Context extends Record<string, unknown>;\n}\n    ? Context\n    : Record<string, unknown>;\n\nexport type LiveOntologyQueryFunction<\n    Parameters extends Record<string, unknown> = Record<string, unknown>,\n    Return = unknown,\n> = (parameters: Parameters) => Promise<Return>;\n\nexport type LiveOntologyObjects<\n    ObjectTypes extends OntologyDefinition[\"objectTypes\"] = OntologyDefinition[\"objectTypes\"],\n> = {\n    readonly [ObjectTypeName in keyof ObjectTypes]: OntologyCollection<ObjectTypes[ObjectTypeName]>;\n};\n\nexport type LiveOntologyActions<ActionTypes extends OntologyDefinition[\"actionTypes\"]> = {\n    [ActionTypeName in keyof ActionTypes]: LiveOntologyAction<\n        ActionTypes[ActionTypeName][\"parameters\"],\n        ActionTypes[ActionTypeName] extends { returnType: infer Return } ? Return : unknown,\n        ActionTypes[ActionTypeName] extends { inputParameters: infer Input extends Record<string, unknown> }\n            ? Input\n            : ActionTypes[ActionTypeName][\"parameters\"]\n    >;\n};\n\nexport type LiveOntologyQueryFunctions<QueryFunctionTypes extends OntologyDefinition[\"queryFunctionTypes\"]> =\n    {\n        [QueryFunctionTypeName in keyof QueryFunctionTypes]: LiveOntologyQueryFunction<\n            QueryFunctionTypes[QueryFunctionTypeName][\"parameters\"],\n            QueryFunctionTypes[QueryFunctionTypeName][\"returnType\"]\n        >;\n    };\n\nexport interface OntologyDiagnostics {\n    readonly label?: string;\n    readonly role?: \"host\" | \"replica\";\n    readonly location?: string;\n    readonly replica: ReplicaMonitor;\n    readonly traces?: TraceStore;\n    readonly parent?: OntologyDiagnostics;\n}\n\nexport interface DecryptOptions {\n    /** Default false: bypass the persistent decrypted-value cache. True permits a device-encrypted\n     * copy when the response is bound to this ciphertext (see the documented Foundry assumption).\n     * Cached device copies are removed with their replica rows.\n     */\n    readonly cache?: boolean;\n    readonly signal?: AbortSignal;\n}\nexport type LiveOntologyDecrypt = <A>(value: Encrypted<A>, options?: DecryptOptions) => Promise<A>;\n\nexport interface LiveOntologyPins extends OntologyPins {\n    /** The application's current offline graph, including its readiness. */\n    get(): Promise<PinStatus | undefined>;\n    /** Replace the offline graph, retaining the previous graph until the replacement is ready.\n     * Server-backed clients target the parent's persistent replica, including from a memory tab.\n     * Standalone clients target their own replica. Attachments default to \"none\".\n     */\n    set(query: QueryDocument, options?: PinOptions): Promise<void>;\n    clear(name?: string): Promise<void>;\n    /** Receives the current pin and subsequent updates. Unsubscribe releases its stream.\n     * Native pin failures appear on status.error; transport failures call onError.\n     */\n    subscribe(\n        listener: (status: PinStatus | undefined) => void,\n        onError?: (cause: unknown) => void\n    ): () => void;\n}\n\nexport interface LiveOntology<Ontology extends OntologyDefinition = OntologyDefinition> {\n    /** Scoped source-collection and query-identity owner. Supply to React's DbProvider or query options.\n     * The current TanStack release does not register browser hook queries for client cleanup.\n     */\n    readonly dbClient: DbClient;\n    readonly ir: OntologyIR;\n    readonly context: OntologyContext<Ontology>;\n    /** Lazy typed collections. Consuming queries acquire upstream subset demand. */\n    readonly objects: LiveOntologyObjects<Ontology[\"objectTypes\"]>;\n    /** Lazy cache inspection. These collections retain/observe local visible rows without upstream demand. */\n    readonly cachedObjects: LiveOntologyObjects<Ontology[\"objectTypes\"]>;\n    traces?: TraceStore;\n    diagnostics?: OntologyDiagnostics;\n    readonly replica: ReplicaService;\n    actions: LiveOntologyActions<Ontology[\"actionTypes\"]>;\n    queryFunctions: LiveOntologyQueryFunctions<Ontology[\"queryFunctionTypes\"]>;\n    attachments: LiveOntologyAttachments<Ontology>;\n    /** Explicit decryption of a top-level encrypted property handle. Ordinary queries never decrypt.\n     * A provider that only decrypts the property's current value may return a newer value than this\n     * handle; without identity evidence that response is never cached, even with cache:true.\n     */\n    decrypt: LiveOntologyDecrypt;\n    outbox: OntologyOutbox;\n    readonly pins: LiveOntologyPins;\n    cleanup: () => Promise<void>;\n}\n\ninterface LiveOntologySettings<Context extends Record<string, unknown>> {\n    id?: string;\n    live?: boolean;\n    /** Opt-in devtools trace history or a live-only diagnostic feed. */\n    traceRecording?: TraceRecordingMode;\n    demand?: DemandPolicy;\n    cache?: ReplicaOptions[\"cache\"];\n    writes?: LiveOntologyWrites;\n    context?: Context;\n    authentication?: ConnectionMonitor;\n    label?: string;\n    /** Attach parent diagnostics, including for committed-only clients.\n     * The endpoint must permit internal diagnostics for this caller.\n     */\n    parent?: { readonly label?: string; readonly location?: string };\n}\n\ninterface BackendOntologyOptions<\n    Context extends Record<string, unknown>,\n> extends LiveOntologySettings<Context> {\n    ir: OntologyIR;\n    /** Borrow an acquired backend, or acquire one in the view's Scope with its Runtime. */\n    backend:\n        | OntologyBackendService\n        | Effect.Effect<OntologyBackendService, BackendError, Scope.Scope | Runtime | Runtimes>;\n    client?: never;\n    ontology?: never;\n}\ninterface ClientOntologyOptions<\n    Context extends Record<string, unknown>,\n> extends LiveOntologySettings<Context> {\n    /** Defaults to the authenticated server definition. Supply IR to verify it matches this client. */\n    ir?: OntologyIR;\n    client:\n        | OntologyServerClient\n        | Effect.Effect<OntologyClient | OntologyServerClient, BackendError, Scope.Scope>;\n    /** Select a target on a shared server client; omission selects a single-ontology endpoint. */\n    ontology?: string;\n    backend?: never;\n}\nexport type LiveOntologyOptions<Context extends Record<string, unknown> = Record<string, unknown>> =\n    | BackendOntologyOptions<Context>\n    | ClientOntologyOptions<Context>;\n\nexport type CreateLiveOntologyOpts<Context extends Record<string, unknown> = Record<string, unknown>> =\n    LiveOntologyOptions<Context> & { runtime?: RuntimesLayer };\n\n/** Generated factories supply their IR while preserving the backend/client choice. */\nexport type LiveOntologyFactoryOptions<Context extends Record<string, unknown> = Record<string, unknown>> = (\n    | Omit<BackendOntologyOptions<Context>, \"ir\">\n    | Omit<ClientOntologyOptions<Context>, \"ir\">\n) & { runtime?: RuntimesLayer };\n\n/** SDK acquisition materializes collections only for callers requesting a view. */\nexport const makeLiveOntology = Effect.fn(\"Ontology.make\")(function* <\n    Ontology extends OntologyDefinition = OntologyDefinition,\n    Context extends Record<string, unknown> = Record<string, unknown>,\n>(opts: LiveOntologyOptions<Context>) {\n    const resource = yield* makeOntologyResource<Ontology, Context>(opts);\n    return yield* resource.view;\n});\n\n/** UI/SDK boundary; the native service above owns all implementation and cleanup. */\nexport async function createLiveOntology<\n    Ontology extends OntologyDefinition = OntologyDefinition,\n    Context extends Record<string, unknown> = Record<string, unknown>,\n>(opts: CreateLiveOntologyOpts<Context>): Promise<LiveOntology<Ontology>> {\n    const scope = Effect.runSync(Scope.make());\n    try {\n        const context = await Effect.runPromise(\n            Layer.buildWithScope(opts.runtime ?? Runtimes.layer(MemoryRuntime.layer), scope)\n        );\n        const live = await Effect.runPromise(\n            Scope.provide(\n                makeLiveOntology<Ontology, Context>(opts).pipe(Effect.provideContext(context)),\n                scope\n            )\n        );\n        let closing: Promise<void> | undefined;\n        const cleanup = () => (closing ??= Effect.runPromise(Scope.close(scope, Exit.void)));\n        return {\n            ...live,\n            cleanup,\n        };\n    } catch (cause) {\n        await Effect.runPromise(Scope.close(scope, Exit.fail(cause)));\n        throw cause;\n    }\n}\n"],"mappings":";;;;;AAwMA,MAAa,mBAAmB,OAAO,GAAG,eAAe,CAAC,CAAC,WAGzD,MAAoC;CAElC,OAAO,QAAO,OADU,qBAAwC,IAAI,EAAA,CAC7C;AAC3B,CAAC;;AAGD,eAAsB,mBAGpB,MAAwE;CACtE,MAAM,QAAQ,OAAO,QAAQ,MAAM,KAAK,CAAC;CACzC,IAAI;EACA,MAAM,UAAU,MAAM,OAAO,WACzB,MAAM,eAAe,KAAK,WAAW,SAAS,MAAM,cAAc,KAAK,GAAG,KAAK,CACnF;EACA,MAAM,OAAO,MAAM,OAAO,WACtB,MAAM,QACF,iBAAoC,IAAI,CAAC,CAAC,KAAK,OAAO,eAAe,OAAO,CAAC,GAC7E,KACJ,CACJ;EACA,IAAI;EACJ,MAAM,gBAAiB,YAAY,OAAO,WAAW,MAAM,MAAM,OAAO,KAAK,IAAI,CAAC;EAClF,OAAO;GACH,GAAG;GACH;EACJ;CACJ,SAAS,OAAO;EACZ,MAAM,OAAO,WAAW,MAAM,MAAM,OAAO,KAAK,KAAK,KAAK,CAAC,CAAC;EAC5D,MAAM;CACV;AACJ"}

package/lib/live/actions/createLiveOntologyAction.d.ts

@@ -1,34 +1,33 @@
-import { Result } from "../../utils/values.js";
-import { OntologyIR } from "../../ir/generated/types.js";
-import { ValidationIssue } from "../../utils/validation.js";
-import "../../ir/index.js";
-import { Uncertain } from "../../utils/uncertain.js";
-import { OntologyApplyActionResult } from "../OntologyBackendAdapter.js";
-import { OntologyObject } from "../objects/OntologyObject.js";
-import { OntologyCollection } from "../objects/createLiveOntologyObjectCollection.js";
+import { OntologyApplyActionResult } from "./types.js";
 import { OntologyActionRequest } from "../outbox/types.js";
-import { LiveOntologyWriteMode, LiveOntologyWriteVisibility } from "../LiveOntology.js";
+import { LiveOntologyWriteVisibility } from "../LiveOntology.js";
+import { ActionRequest } from "@party-stack/ontology-backend";
+import { OntologyIR } from "@party-stack/ontology-spec";
+import { Uncertain, ValidationIssue } from "@party-stack/ontology-spec/utils";
+import { Result } from "@party-stack/ontology-spec/values";
 //#region src/live/actions/createLiveOntologyAction.d.ts
 export interface LiveOntologyActionOptions {
   idempotencyKey?: string;
-  mode?: LiveOntologyWriteMode;
+  /** Portable inputs supplied by a forwarding ontology. */
+  replay?: NonNullable<ActionRequest["replay"]>;
   visibility?: LiveOntologyWriteVisibility;
 }
 export interface LiveOntologyActionDraftValidationOptions<Parameters extends Record<string, unknown>> {
   knownParameters?: readonly (keyof Parameters)[];
 }
-export type LiveOntologyAction<Parameters extends Record<string, unknown> = Record<string, unknown>> = {
-  (parameters: Parameters, options?: LiveOntologyActionOptions): Promise<OntologyApplyActionResult | void>;
+export type LiveOntologyAction<Parameters extends Record<string, unknown> = Record<string, unknown>, Return = unknown, Input extends Record<string, unknown> = Parameters> = {
+  /** Queue in the replica's outbox, including offline. Visibility controls prediction;
+   * the Promise resolves after authoritative confirmation and local reconciliation.
+   */
+  (parameters: Input, options?: LiveOntologyActionOptions): Promise<OntologyApplyActionResult<Return>>;
   resolveParameters(parameters: Partial<Parameters>): Promise<Partial<Parameters>>;
   validate(parameters: Parameters): Promise<Uncertain<Result<void, readonly ValidationIssue[]>>>;
   validateDraft(parameters: Partial<Parameters>, options?: LiveOntologyActionDraftValidationOptions<Parameters>): Promise<Uncertain<Result<void, readonly ValidationIssue[]>>>;
 };
 export declare function createLiveOntologyAction(options: {
-  ir: OntologyIR;
   action: OntologyIR["actionTypes"][number];
-  context?: Record<string, unknown>;
-  objects: Record<string, OntologyCollection<OntologyObject>>;
-  submit(request: OntologyActionRequest, options?: LiveOntologyActionOptions): Promise<OntologyApplyActionResult | void>;
+  resolveParameters: (name: string, parameters: Record<string, unknown>) => Promise<Record<string, unknown>>;
+  submit(request: OntologyActionRequest, options?: LiveOntologyActionOptions): Promise<OntologyApplyActionResult>;
   validate(actionTypeName: string, parameters: Record<string, unknown>): Promise<Uncertain<Result<void, readonly ValidationIssue[]>>>;
   validateDraft(actionTypeName: string, parameters: Record<string, unknown>, validationOptions?: LiveOntologyActionDraftValidationOptions<Record<string, unknown>>): Promise<Uncertain<Result<void, readonly ValidationIssue[]>>>;
 }): LiveOntologyAction;

package/lib/live/actions/createLiveOntologyAction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createLiveOntologyAction.d.ts","names":[],"sources":["../../../src/live/actions/createLiveOntologyAction.ts"],"mappings":";;;;;;;;;;;iBAYiB;EACb;EACA,OAAO;EACP,aAAa;;iBAGA,yCAAyC,mBAAmB;EACzE,kCAAkC;;YAG1B,mBAAmB,mBAAmB,0BAA0B;GACvE,YAAY,YAAY,UAAU,4BAA4B,QAAQ;EACvE,kBAAkB,YAAY,QAAQ,cAAc,QAAQ,QAAQ;EACpE,SAAS,YAAY,aAAa,QAAQ,UAAU,sBAAsB;EAC1E,cACI,YAAY,QAAQ,aACpB,UAAU,yCAAyC,cACpD,QAAQ,UAAU,sBAAsB;;wBAG/B,yBAAyB;EACrC,IAAI;EACJ,QAAQ;EACR,UAAU;EACV,SAAS,eAAe,mBAAmB;EAC3C,OACI,SAAS,uBACT,UAAU,4BACX,QAAQ;EACX,SACI,wBACA,YAAY,0BACb,QAAQ,UAAU,sBAAsB;EAC3C,cACI,wBACA,YAAY,yBACZ,oBAAoB,yCAAyC,2BAC9D,QAAQ,UAAU,sBAAsB;IAC3C"}
+{"version":3,"file":"createLiveOntologyAction.d.ts","names":[],"sources":["../../../src/live/actions/createLiveOntologyAction.ts"],"mappings":";;;;;;;;iBASiB;EACb;;EAEA,SAAS,YAAY;EACrB,aAAa;;iBAGA,yCAAyC,mBAAmB;EACzE,kCAAkC;;YAG1B,mBACR,mBAAmB,0BAA0B,yBAC7C,kBACA,cAAc,0BAA0B;;;;GAKvC,YAAY,OAAO,UAAU,4BAA4B,QAAQ,0BAA0B;EAC5F,kBAAkB,YAAY,QAAQ,cAAc,QAAQ,QAAQ;EACpE,SAAS,YAAY,aAAa,QAAQ,UAAU,sBAAsB;EAC1E,cACI,YAAY,QAAQ,aACpB,UAAU,yCAAyC,cACpD,QAAQ,UAAU,sBAAsB;;wBAG/B,yBAAyB;EACrC,QAAQ;EACR,oBACI,cACA,YAAY,4BACX,QAAQ;EACb,OACI,SAAS,uBACT,UAAU,4BACX,QAAQ;EACX,SACI,wBACA,YAAY,0BACb,QAAQ,UAAU,sBAAsB;EAC3C,cACI,wBACA,YAAY,yBACZ,oBAAoB,yCAAyC,2BAC9D,QAAQ,UAAU,sBAAsB;IAC3C"}

package/lib/live/actions/createLiveOntologyAction.js

@@ -1,24 +1,16 @@
-import { resolveActionParameters } from "../expression.js";
-import { createReadTx } from "../mutators/createMutatorTx.js";
 //#region src/live/actions/createLiveOntologyAction.ts
 function createLiveOntologyAction(options) {
-	const resolveParameters = (providedParameters) => resolveActionParameters({
-		ir: options.ir,
-		actionTypeName: options.action.name,
-		initialParameters: providedParameters,
-		context: options.context ?? {},
-		tx: createReadTx(options.objects)
-	});
 	const apply = async (providedParameters, executionOptions) => {
 		const idempotencyKey = executionOptions?.idempotencyKey ?? crypto.randomUUID();
 		return options.submit({
 			actionTypeName: options.action.name,
 			parameters: providedParameters,
-			idempotencyKey
+			idempotencyKey,
+			replay: executionOptions?.replay
 		}, executionOptions);
 	};
 	apply.validate = async (providedParameters) => options.validate(options.action.name, providedParameters);
-	apply.resolveParameters = resolveParameters;
+	apply.resolveParameters = (parameters) => options.resolveParameters(options.action.name, parameters);
 	apply.validateDraft = async (parameters, validationOptions) => options.validateDraft(options.action.name, parameters, validationOptions);
 	return apply;
 }