@party-stack/foundry-ontology 0.19.0 → 0.20.0

package/README.md

@@ -1,28 +1,50 @@
 # foundry-ontology
 
-Foundry adapter and metadata conversion for Party Stack LiveOntology.
+Native Foundry data, metadata, and account-connection capabilities.
 
-## Metadata polling
+## Metadata queries
 
-Set `metaRefetchInterval` on a metadata-only route included in your Foundry installation:
+Open a native metadata backend with selected Connect egress:
 
 ```ts
-createFoundryOntologyRoute({
-    ontologyId: "ri.ontology.main.ontology.example",
-    metaRefetchInterval: 30_000,
-});
+import { makeFoundryMetadataBackend } from "@party-stack/foundry-ontology";
+
+const backend =
+    yield *
+    makeFoundryMetadataBackend({
+        baseUrl,
+        ontologyId: "ri.ontology.main.ontology.example",
+        egress,
+        refetchInterval: 30_000,
+    });
 ```
 
-Calling `installation.openMetaOntology({ userId, ontologyId })` uses that route's
-interval for the shared object/value/link metadata collection, action types, and
-query function types. The interval is in milliseconds; `false` disables polling,
-and omitting it preserves the default of no polling. Repeated opens return the
-cached meta ontology with the same route configuration. Routes with supplied `ir`
-project local metadata and do not poll Foundry.
-
-You can also set `refetchInterval` directly on
-`createFoundryMetaOntologyBackendAdapter` when creating a meta ontology without an
-installation.
+Object-type name and RID filters use Foundry's batch lookup endpoints. Value-type
+name filters use direct lookups. Link queries constrained by an object type load
+that type's outgoing links and the inverse definitions needed to reconstruct each
+link. Unbounded queries use the corresponding listing endpoints.
+
+The backend narrows provider requests where it can prove they include every
+matching row. The shared query engine then applies residual predicates, ordering,
+and limits. A bounded fetch never certifies that the whole object type is loaded.
+
+`refetchInterval` supplies a recommended polling interval, in milliseconds. The
+replica schedules polling; the adapter does not run a separate timer. `false`
+disables the recommendation, and omission defaults to no polling. An explicit
+replica demand refresh policy takes precedence.
+
+Metadata is an ordinary backend, usable directly for native pull or
+with the shared meta ontology IR in a replica. `makeFoundryBackend` opens a data
+backend; `makeFoundryAdminBackend` from the `users` export opens the explicit users
+ontology. These helpers do not create SDK views or installations.
+
+For saved connections, register `makeFoundryServiceConnector` with Connect and
+acquire authenticated egress through `connect.connections.acquire(connectionRef)`.
+Pass that egress to the normal backend constructor. `makeOntologyServer` routes
+Connect and managed replicas through the same ontology protocol;
+`serveOntologyWorker(server)` binds it to a worker transport. In tabs, `createAuthenticationClient`
+handles authentication and `OntologyEnvironmentProvider` opens named views. See the
+[Foundry guide](../../apps/website/content/docs/foundry.mdx) for the complete setup.
 
 ## Link metadata
 
@@ -45,21 +67,20 @@ are preserved as suggestions. Object-query and struct-field prefills are omitted
 until the expression model supports them, and failures from the private endpoint
 do not prevent public action metadata from loading.
 
-## Refreshing objects
-
-Foundry object collections expose an awaitable full-source refresh:
+## Native backend integration
 
-```ts
-await ontology.objects.Employee.utils.refresh?.();
-```
+Object, metadata, and Admin Users reads use the native backend's Effect-valued
+`loadSubset` interface. Replica owns demand, persistent rows, action receipts,
+confirmation reads, and optimistic state; TanStack collections materialize that
+state for applications. Provider collection-option helpers are no longer exported.
 
-`refresh` is an optional adapter utility on the generic ontology collection API.
-Foundry fetches a fresh snapshot and replaces cached rows in one sync transaction,
-while keeping live subscriptions active and applying updates received during the
-fetch. The promise waits for the commit and rejects on failure. Ontology
-collections start their sync before refreshing; when using
-`objectCollectionOptions` directly, preload the collection first.
+The Foundry backend uses the scoped Effect object-set watcher. Watch messages are
+invalidation hints; Replica refreshes the affected demand. They do not establish a
+durable edits-history cursor. Actions save receipts before confirmation reads, so
+a failed read does not cause the action to be submitted again.
 
-When edit history is unavailable, reconnection and action acknowledgement also
-request a fresh snapshot. Acknowledgement waits for that snapshot's commit; it
-cannot confirm a specific edit-history operation ID in this mode.
+`makeFoundryServiceConnector(options)` registers native OAuth exchange, refresh,
+identity verification, and authenticated HTTP/WebSocket egress. Credentials remain
+beside the backend. Interactive OAuth uses the ordinary Connect actions and the
+tab runtime's browser presentation capability. Opening a saved connection does
+not start interactive authentication.

package/lib/adapter/backend.d.ts

@@ -0,0 +1,35 @@
+import { OntologyClient } from "@party-stack/foundry-client";
+import { Effect } from "effect";
+import { Actions } from "@osdk/foundry.ontologies";
+import { ActionRequest, BackendError, BackendSnapshot, OntologyBackendService } from "@party-stack/ontology-backend";
+import { OntologyIR } from "@party-stack/ontology-spec";
+import { Query } from "@party-stack/ontology-storage";
+//#region src/adapter/backend.d.ts
+/** One scoped watcher multiplexes the live object types used by this binding.
+ * Watch messages invalidate snapshots; they do not pretend to be durable journal cursors.
+ */
+export declare const makeFoundryBackend: (options: {
+  client: OntologyClient;
+  ir: OntologyIR;
+  context: Record<string, unknown>;
+  watch?: boolean;
+  users?: {
+    objectType: string;
+    loadSubset: (query: Query, signal: AbortSignal) => Promise<BackendSnapshot>;
+  };
+  submitAction: (invocation: ActionRequest, signal: AbortSignal) => Promise<{
+    result: Awaited<ReturnType<typeof Actions.applyWithOverrides>> & {
+      operationId?: string;
+    };
+    attachmentIdMappings: readonly {
+      localId: string;
+      remoteId: string;
+    }[];
+  }>;
+  queryFunction?: (name: string, parameters: Record<string, unknown>, signal: AbortSignal) => Promise<unknown>;
+  attachments?: OntologyBackendService["attachments"];
+  encrypted?: OntologyBackendService["encrypted"];
+  decodeObject: (objectType: string, value: Record<string, unknown>) => Record<string, unknown>;
+}) => Effect.Effect<OntologyBackendService, 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=backend.d.ts.map

package/lib/adapter/backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend.d.ts","names":[],"sources":["../../src/adapter/backend.ts"],"mappings":";;;;;;;;;;qBAwGa,qBAAkB;EACnB,QAAA;EACJ,IAAA;EACK,SAAA;EACD;EACA;IACJ;IACA,aAAa,OAAO,OAAO,QAAQ,gBAAgB,QAAQ;;EAEjD,eACV,YAAY,eACZ,QAAQ,gBACP;IACD,QAAQ,QAAQ,kBAAkB,QAAQ;MAAyB;;IACnE;MAAiC;MAAiB;;;EAEtC,iBACZ,cACA,YAAY,yBACZ,QAAQ,gBACP;EACS,cAAA;EACF,YAAA;EACE,eAAC,oBAAoB,OAAO,4BAA4B;MAuMxE,OAAA,OAAA,wBAAA,wXAAA"}

package/lib/adapter/backend.js

@@ -0,0 +1,210 @@
+import { searchFoundryObjects } from "./foundryObjectSearch.js";
+import { analyzeSubsetFilter, subsetFilter } from "./subsetFilter.js";
+import { Deferred, Effect, Queue, Redacted, Schema, Stream } from "effect";
+import { BackendError, classifyBackendFailure, makeOntologyBackend } from "@party-stack/ontology-backend";
+import { makeObjectSetWatcher } from "@party-stack/foundry-object-set-watcher";
+import { compileObjectSubset, objectSubset } from "@party-stack/ontology-backend/subset";
+import { QuerySchema } from "@party-stack/ontology-storage";
+import { isField } from "@party-stack/ontology-storage/tables";
+//#region src/adapter/backend.ts
+const KeySchema = Schema.Union([Schema.String, Schema.Finite]);
+const ObjectTarget = Schema.Struct({
+	objectType: Schema.String,
+	primaryKey: Schema.Unknown
+});
+const ActionResult = Schema.Struct({
+	operationId: Schema.optional(Schema.String),
+	edits: Schema.optional(Schema.Union([Schema.Struct({
+		type: Schema.Literal("largeScaleEdits"),
+		editedObjectTypes: Schema.Array(Schema.String)
+	}), Schema.Struct({
+		type: Schema.Literal("edits"),
+		edits: Schema.Array(Schema.Union([Schema.Struct({
+			type: Schema.Literals([
+				"addObject",
+				"modifyObject",
+				"deleteObject"
+			]),
+			...ObjectTarget.fields
+		}), Schema.Struct({
+			type: Schema.Literals(["addLink", "deleteLink"]),
+			aSideObject: ObjectTarget,
+			bSideObject: ObjectTarget
+		})]))
+	})]))
+});
+const invalidResponse = (operation, cause) => new BackendError({
+	operation,
+	kind: "InvalidResponse",
+	message: "Foundry returned an invalid response.",
+	retryable: false,
+	actionOutcome: "unknown",
+	cause: Redacted.make(cause)
+});
+const unavailable = (cause) => classifyBackendFailure("foundry.sync", cause);
+/** Each logical object set has its own acknowledgement. Pump before returning so
+* changes between that acknowledgement and the snapshot read remain observable.
+*/
+const acquireWatch = Effect.fn("Foundry.acquireWatch")(function* (messages) {
+	const ready = yield* Deferred.make();
+	const events = yield* Effect.acquireRelease(Queue.sliding(1), (queue) => Queue.shutdown(queue).pipe(Effect.asVoid));
+	const interrupted = () => new BackendError({
+		operation: "foundry.watchSubset",
+		kind: "Unavailable",
+		retryable: true,
+		message: "The Foundry object-set subscription is no longer active."
+	});
+	const receive = Stream.runForEach(messages, (message) => {
+		if (message.type !== "state") return Queue.offer(events, void 0).pipe(Effect.asVoid);
+		return message.status === "open" ? Deferred.succeed(ready, void 0).pipe(Effect.asVoid) : Effect.fail(interrupted());
+	}).pipe(Effect.mapError(unavailable), Effect.andThen(Effect.fail(interrupted())), Effect.catchCause((cause) => Deferred.failCause(ready, cause).pipe(Effect.andThen(Queue.failCause(events, cause)), Effect.asVoid)));
+	yield* Effect.forkScoped(receive, { startImmediately: true });
+	yield* Deferred.await(ready);
+	return Stream.fromQueue(events);
+});
+/** One scoped watcher multiplexes the live object types used by this binding.
+* Watch messages invalidate snapshots; they do not pretend to be durable journal cursors.
+*/
+const makeFoundryBackend = Effect.fn("FoundryBackend.make")(function* (options) {
+	const watcher = options.watch === false ? void 0 : yield* makeObjectSetWatcher(options.client).pipe(Effect.mapError(unavailable));
+	return makeOntologyBackend({
+		ir: options.ir,
+		context: options.context,
+		name: "foundry",
+		sourceId: `foundry:${options.client.baseUrl}:${options.client.ontologyRid}`,
+		supportsIdempotency: false,
+		queryFunction: (name, parameters) => options.queryFunction ? Effect.tryPromise({
+			try: (signal) => options.queryFunction(name, parameters, signal),
+			catch: unavailable
+		}) : Effect.fail(new BackendError({
+			operation: "queryFunction",
+			kind: "NotImplemented",
+			message: "No Foundry query function implementation.",
+			retryable: false
+		})),
+		attachments: options.attachments,
+		encrypted: options.encrypted,
+		loadSubset: Effect.fn("Foundry.loadSubset")(function* (request) {
+			const subset = yield* compileObjectSubset(options.ir, request, options.context);
+			yield* Effect.annotateCurrentSpan("objectType", subset.objectType);
+			yield* Schema.decodeUnknownEffect(QuerySchema)(subset.query ?? {}).pipe(Effect.mapError((cause) => new BackendError({
+				operation: "foundry.loadSubset",
+				kind: "InvalidRequest",
+				message: "Invalid subset query.",
+				retryable: false,
+				cause: Redacted.make(cause)
+			})));
+			if (subset.objectType === options.users?.objectType) return yield* Effect.tryPromise({
+				try: (signal) => options.users.loadSubset(subset.query ?? {}, signal),
+				catch: unavailable
+			});
+			const definition = options.ir.objectTypes.find((type) => type.name === subset.objectType);
+			if (!definition) return yield* new BackendError({
+				operation: "foundry.loadSubset",
+				kind: "InvalidRequest",
+				message: "Unknown Foundry object type.",
+				retryable: false
+			});
+			const predicate = subset.query?.where;
+			const candidates = predicate?.op === "in" && isField(predicate.left) && predicate.left.path.length === 1 && predicate.left.path[0] === definition.primaryKey ? predicate.values : predicate?.op === "eq" && isField(predicate.left) && predicate.left.path.length === 1 && predicate.left.path[0] === definition.primaryKey && !isField(predicate.right) ? [predicate.right] : void 0;
+			const keys = candidates?.every(Schema.is(KeySchema)) ? candidates : void 0;
+			const plan = analyzeSubsetFilter(predicate);
+			const pushed = keys ? {
+				type: "in",
+				field: definition.primaryKey,
+				value: [...new Set(keys)]
+			} : plan.query;
+			const values = yield* Effect.tryPromise({
+				try: (signal) => searchFoundryObjects(options.client, subset.objectType, definition.properties.map((property) => property.name), {
+					signal,
+					where: pushed
+				}, (value) => options.decodeObject(subset.objectType, value)),
+				catch: unavailable
+			});
+			const rows = yield* Effect.forEach(values, (value) => Schema.decodeUnknownEffect(KeySchema)(value[definition.primaryKey]).pipe(Effect.map((key) => ({
+				key,
+				value
+			})), Effect.mapError((cause) => invalidResponse("foundry.loadSubset", cause))));
+			return {
+				fulfilledSubset: objectSubset(subset.objectType, { where: subset.query?.where }),
+				fetchedRows: values.length,
+				pushdown: {
+					source: "Foundry",
+					predicates: plan.predicates.map((predicate) => ({
+						...predicate,
+						execution: predicate.execution === "adapter" ? "engine" : predicate.execution
+					})),
+					sorting: subset.query?.orderBy?.length ? "engine" : "none",
+					pagination: subset.query?.limit !== void 0 || subset.query?.offset !== void 0 || subset.query?.after ? "engine" : "none",
+					rechecksFilter: Boolean(predicate),
+					native: {
+						language: "json",
+						text: JSON.stringify(pushed ?? {
+							type: "and",
+							value: []
+						}, null, 2)
+					}
+				},
+				rows,
+				complete: true
+			};
+		}),
+		applyAction: Effect.fn("Foundry.applyAction")(function* (invocation) {
+			const { result: rawResult, attachmentIdMappings } = yield* Effect.tryPromise({
+				try: (signal) => options.submitAction(invocation, signal),
+				catch: (cause) => classifyBackendFailure("foundry.applyAction", cause)
+			});
+			const result = yield* Schema.decodeUnknownEffect(ActionResult)(rawResult).pipe(Effect.mapError((cause) => invalidResponse("foundry.applyAction", cause)));
+			return yield* Effect.try({
+				try: () => {
+					const targets = /* @__PURE__ */ new Map();
+					const add = (objectType, rawKey) => {
+						const definition = options.ir.objectTypes.find((type) => type.name === objectType);
+						if (!definition || objectType === options.users?.objectType) return;
+						const key = rawKey === void 0 ? void 0 : options.decodeObject(objectType, { [definition.primaryKey]: rawKey })[definition.primaryKey];
+						if (rawKey === void 0) targets.set(objectType, void 0);
+						else if (!Schema.is(KeySchema)(key)) throw new Error("Invalid edit identity.");
+						else if (!targets.has(objectType) || targets.get(objectType)) targets.set(objectType, /* @__PURE__ */ new Set([...targets.get(objectType) ?? [], key]));
+					};
+					if (!result.edits) for (const type of options.ir.objectTypes) add(type.name);
+					else if (result.edits.type === "largeScaleEdits") for (const type of result.edits.editedObjectTypes) add(type);
+					else for (const edit of result.edits.edits) if ("aSideObject" in edit) {
+						add(edit.aSideObject.objectType, edit.aSideObject.primaryKey);
+						add(edit.bSideObject.objectType, edit.bSideObject.primaryKey);
+					} else add(edit.objectType, edit.primaryKey);
+					return {
+						operationId: invocation.id,
+						outcome: "committed",
+						providerOperationId: result.operationId,
+						affected: [...targets].map(([objectType, keys]) => ({
+							objectType,
+							...keys ? { keys: [...keys] } : {}
+						})),
+						attachmentIdMappings: attachmentIdMappings.length ? attachmentIdMappings : void 0
+					};
+				},
+				catch: (cause) => invalidResponse("foundry.applyAction", cause)
+			});
+		}),
+		refresh: (subset) => subset.from.source.objectType === options.users?.objectType ? { pollIntervalMs: 6e4 } : void 0,
+		watchSubset: watcher ? (request) => request.from.source.objectType === options.users?.objectType ? void 0 : Effect.gen(function* () {
+			const subset = yield* compileObjectSubset(options.ir, request, options.context);
+			const filter = subsetFilter(subset.query?.where);
+			return yield* acquireWatch(watcher.subscribe(filter ? {
+				type: "filter",
+				objectSet: {
+					type: "base",
+					objectType: subset.objectType
+				},
+				where: filter
+			} : {
+				type: "base",
+				objectType: subset.objectType
+			}));
+		}) : void 0
+	});
+});
+//#endregion
+export { makeFoundryBackend };
+
+//# sourceMappingURL=backend.js.map

package/lib/adapter/backend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend.js","names":[],"sources":["../../src/adapter/backend.ts"],"sourcesContent":["import { makeObjectSetWatcher } from \"@party-stack/foundry-object-set-watcher\";\nimport { makeOntologyBackend } from \"@party-stack/ontology-backend\";\nimport { BackendError, classifyBackendFailure } from \"@party-stack/ontology-backend\";\nimport { compileObjectSubset, objectSubset } from \"@party-stack/ontology-backend/subset\";\nimport { QuerySchema } from \"@party-stack/ontology-storage\";\nimport { isField } from \"@party-stack/ontology-storage/tables\";\nimport { Deferred, Effect, Queue, Schema, Stream, Redacted } from \"effect\";\nimport { searchFoundryObjects } from \"./foundryObjectSearch.js\";\nimport { analyzeSubsetFilter, subsetFilter } from \"./subsetFilter.js\";\nimport type { Actions } from \"@osdk/foundry.ontologies\";\nimport type { OntologyClient } from \"@party-stack/foundry-client\";\nimport type { ObjectSetSubscriptionMessage, WatcherError } from \"@party-stack/foundry-object-set-watcher\";\nimport type {\n    OntologyBackendService,\n    ActionRequest,\n    ActionReceipt,\n    SourceQueryPlan,\n    SubsetWatchEvent,\n} from \"@party-stack/ontology-backend\";\nimport type { BackendSnapshot } from \"@party-stack/ontology-backend\";\nimport type { OntologyIR } from \"@party-stack/ontology-spec\";\nimport type { ObjectSubset } from \"@party-stack/ontology-spec/query\";\nimport type { Query } from \"@party-stack/ontology-storage\";\n\nconst KeySchema = Schema.Union([Schema.String, Schema.Finite]);\nconst ObjectTarget = Schema.Struct({ objectType: Schema.String, primaryKey: Schema.Unknown });\nconst ActionResult = Schema.Struct({\n    operationId: Schema.optional(Schema.String),\n    edits: Schema.optional(\n        Schema.Union([\n            Schema.Struct({\n                type: Schema.Literal(\"largeScaleEdits\"),\n                editedObjectTypes: Schema.Array(Schema.String),\n            }),\n            Schema.Struct({\n                type: Schema.Literal(\"edits\"),\n                edits: Schema.Array(\n                    Schema.Union([\n                        Schema.Struct({\n                            type: Schema.Literals([\"addObject\", \"modifyObject\", \"deleteObject\"]),\n                            ...ObjectTarget.fields,\n                        }),\n                        Schema.Struct({\n                            type: Schema.Literals([\"addLink\", \"deleteLink\"]),\n                            aSideObject: ObjectTarget,\n                            bSideObject: ObjectTarget,\n                        }),\n                    ])\n                ),\n            }),\n        ])\n    ),\n});\nconst invalidResponse = (operation: string, cause: unknown) =>\n    new BackendError({\n        operation,\n        kind: \"InvalidResponse\",\n        message: \"Foundry returned an invalid response.\",\n        retryable: false,\n        actionOutcome: \"unknown\",\n        cause: Redacted.make(cause),\n    });\nconst unavailable = (cause: unknown) => classifyBackendFailure(\"foundry.sync\", cause);\n\n/** Each logical object set has its own acknowledgement. Pump before returning so\n * changes between that acknowledgement and the snapshot read remain observable.\n */\nconst acquireWatch = Effect.fn(\"Foundry.acquireWatch\")(function* (\n    messages: Stream.Stream<ObjectSetSubscriptionMessage, WatcherError>\n) {\n    const ready = yield* Deferred.make<void, BackendError>();\n    const events = yield* Effect.acquireRelease(Queue.sliding<SubsetWatchEvent, BackendError>(1), (queue) =>\n        Queue.shutdown(queue).pipe(Effect.asVoid)\n    );\n    const interrupted = () =>\n        new BackendError({\n            operation: \"foundry.watchSubset\",\n            kind: \"Unavailable\",\n            retryable: true,\n            message: \"The Foundry object-set subscription is no longer active.\",\n        });\n    const receive = Stream.runForEach(messages, (message) => {\n        if (message.type !== \"state\") return Queue.offer(events, undefined).pipe(Effect.asVoid);\n        return message.status === \"open\"\n            ? Deferred.succeed(ready, undefined).pipe(Effect.asVoid)\n            : Effect.fail(interrupted());\n    }).pipe(\n        Effect.mapError(unavailable),\n        Effect.andThen(Effect.fail(interrupted())),\n        Effect.catchCause((cause) =>\n            Deferred.failCause(ready, cause).pipe(\n                Effect.andThen(Queue.failCause(events, cause)),\n                Effect.asVoid\n            )\n        )\n    );\n    yield* Effect.forkScoped(receive, { startImmediately: true });\n    yield* Deferred.await(ready);\n    return Stream.fromQueue(events);\n});\n\n/** One scoped watcher multiplexes the live object types used by this binding.\n * Watch messages invalidate snapshots; they do not pretend to be durable journal cursors.\n */\nexport const makeFoundryBackend = Effect.fn(\"FoundryBackend.make\")(function* (options: {\n    client: OntologyClient;\n    ir: OntologyIR;\n    context: Record<string, unknown>;\n    watch?: boolean;\n    users?: {\n        objectType: string;\n        loadSubset: (query: Query, signal: AbortSignal) => Promise<BackendSnapshot>;\n    };\n    submitAction: (\n        invocation: ActionRequest,\n        signal: AbortSignal\n    ) => Promise<{\n        result: Awaited<ReturnType<typeof Actions.applyWithOverrides>> & { operationId?: string };\n        attachmentIdMappings: readonly { localId: string; remoteId: string }[];\n    }>;\n    queryFunction?: (\n        name: string,\n        parameters: Record<string, unknown>,\n        signal: AbortSignal\n    ) => Promise<unknown>;\n    attachments?: OntologyBackendService[\"attachments\"];\n    encrypted?: OntologyBackendService[\"encrypted\"];\n    decodeObject: (objectType: string, value: Record<string, unknown>) => Record<string, unknown>;\n}) {\n    const watcher =\n        options.watch === false\n            ? undefined\n            : yield* makeObjectSetWatcher(options.client).pipe(Effect.mapError(unavailable));\n    return makeOntologyBackend({\n        ir: options.ir,\n        context: options.context,\n        name: \"foundry\",\n        sourceId: `foundry:${options.client.baseUrl}:${options.client.ontologyRid}`,\n        supportsIdempotency: false,\n        queryFunction: (name: string, parameters: Record<string, unknown>) =>\n            options.queryFunction\n                ? Effect.tryPromise({\n                      try: (signal) => options.queryFunction!(name, parameters, signal),\n                      catch: unavailable,\n                  })\n                : Effect.fail(\n                      new BackendError({\n                          operation: \"queryFunction\",\n                          kind: \"NotImplemented\",\n                          message: \"No Foundry query function implementation.\",\n                          retryable: false,\n                      })\n                  ),\n        attachments: options.attachments,\n        encrypted: options.encrypted,\n        loadSubset: Effect.fn(\"Foundry.loadSubset\")(function* (request: ObjectSubset) {\n            const subset = yield* compileObjectSubset(options.ir, request, options.context);\n            yield* Effect.annotateCurrentSpan(\"objectType\", subset.objectType);\n            yield* Schema.decodeUnknownEffect(QuerySchema)(subset.query ?? {}).pipe(\n                Effect.mapError(\n                    (cause) =>\n                        new BackendError({\n                            operation: \"foundry.loadSubset\",\n                            kind: \"InvalidRequest\",\n                            message: \"Invalid subset query.\",\n                            retryable: false,\n                            cause: Redacted.make(cause),\n                        })\n                )\n            );\n            if (subset.objectType === options.users?.objectType)\n                return yield* Effect.tryPromise({\n                    try: (signal) => options.users!.loadSubset(subset.query ?? {}, signal),\n                    catch: unavailable,\n                });\n            const definition = options.ir.objectTypes.find((type) => type.name === subset.objectType);\n            if (!definition)\n                return yield* new BackendError({\n                    operation: \"foundry.loadSubset\",\n                    kind: \"InvalidRequest\",\n                    message: \"Unknown Foundry object type.\",\n                    retryable: false,\n                });\n            const predicate = subset.query?.where;\n            const candidates =\n                predicate?.op === \"in\" &&\n                isField(predicate.left) &&\n                predicate.left.path.length === 1 &&\n                predicate.left.path[0] === definition.primaryKey\n                    ? predicate.values\n                    : predicate?.op === \"eq\" &&\n                        isField(predicate.left) &&\n                        predicate.left.path.length === 1 &&\n                        predicate.left.path[0] === definition.primaryKey &&\n                        !isField(predicate.right)\n                      ? [predicate.right]\n                      : undefined;\n            const keys = candidates?.every(Schema.is(KeySchema))\n                ? (candidates as readonly (string | number)[])\n                : undefined;\n            const plan = analyzeSubsetFilter(predicate);\n            const pushed = keys\n                ? { type: \"in\" as const, field: definition.primaryKey, value: [...new Set(keys)] }\n                : plan.query;\n            const values = yield* Effect.tryPromise({\n                try: (signal) =>\n                    searchFoundryObjects(\n                        options.client,\n                        subset.objectType,\n                        definition.properties.map((property) => property.name),\n                        {\n                            signal,\n                            where: pushed,\n                        },\n                        (value) => options.decodeObject(subset.objectType, value)\n                    ),\n                catch: unavailable,\n            });\n            const rows = yield* Effect.forEach(values, (value) =>\n                Schema.decodeUnknownEffect(KeySchema)(value[definition.primaryKey]).pipe(\n                    Effect.map((key) => ({ key, value })),\n                    Effect.mapError((cause) => invalidResponse(\"foundry.loadSubset\", cause))\n                )\n            );\n            return {\n                fulfilledSubset: objectSubset(subset.objectType, { where: subset.query?.where }),\n                fetchedRows: values.length,\n                pushdown: {\n                    source: \"Foundry\",\n                    predicates: plan.predicates.map((predicate) => ({\n                        ...predicate,\n                        execution:\n                            predicate.execution === \"adapter\" ? (\"engine\" as const) : predicate.execution,\n                    })),\n                    sorting: subset.query?.orderBy?.length ? \"engine\" : \"none\",\n                    pagination:\n                        subset.query?.limit !== undefined ||\n                        subset.query?.offset !== undefined ||\n                        subset.query?.after\n                            ? \"engine\"\n                            : \"none\",\n                    rechecksFilter: Boolean(predicate),\n                    native: {\n                        language: \"json\",\n                        text: JSON.stringify(pushed ?? { type: \"and\", value: [] }, null, 2),\n                    },\n                } satisfies SourceQueryPlan,\n                rows,\n                complete: true,\n            };\n        }),\n        applyAction: Effect.fn(\"Foundry.applyAction\")(function* (invocation: ActionRequest) {\n            const { result: rawResult, attachmentIdMappings } = yield* Effect.tryPromise({\n                try: (signal) => options.submitAction(invocation, signal),\n                catch: (cause) => classifyBackendFailure(\"foundry.applyAction\", cause),\n            });\n            const result = yield* Schema.decodeUnknownEffect(ActionResult)(rawResult).pipe(\n                Effect.mapError((cause) => invalidResponse(\"foundry.applyAction\", cause))\n            );\n            return yield* Effect.try({\n                try: () => {\n                    const targets = new Map<string, Set<string | number> | undefined>();\n                    const add = (objectType: string, rawKey?: unknown) => {\n                        const definition = options.ir.objectTypes.find((type) => type.name === objectType);\n                        if (!definition || objectType === options.users?.objectType) return;\n                        const key =\n                            rawKey === undefined\n                                ? undefined\n                                : options.decodeObject(objectType, { [definition.primaryKey]: rawKey })[\n                                      definition.primaryKey\n                                  ];\n                        if (rawKey === undefined) targets.set(objectType, undefined);\n                        else if (!Schema.is(KeySchema)(key)) throw new Error(\"Invalid edit identity.\");\n                        else if (!targets.has(objectType) || targets.get(objectType))\n                            targets.set(objectType, new Set([...(targets.get(objectType) ?? []), key]));\n                    };\n                    if (!result.edits) for (const type of options.ir.objectTypes) add(type.name);\n                    else if (result.edits.type === \"largeScaleEdits\")\n                        for (const type of result.edits.editedObjectTypes) add(type);\n                    else\n                        for (const edit of result.edits.edits) {\n                            if (\"aSideObject\" in edit) {\n                                add(edit.aSideObject.objectType, edit.aSideObject.primaryKey);\n                                add(edit.bSideObject.objectType, edit.bSideObject.primaryKey);\n                            } else add(edit.objectType, edit.primaryKey);\n                        }\n                    return {\n                        operationId: invocation.id,\n                        outcome: \"committed\",\n                        providerOperationId: result.operationId,\n                        affected: [...targets].map(([objectType, keys]) => ({\n                            objectType,\n                            ...(keys ? { keys: [...keys] } : {}),\n                        })),\n                        attachmentIdMappings: attachmentIdMappings.length ? attachmentIdMappings : undefined,\n                    } satisfies ActionReceipt;\n                },\n                catch: (cause) => invalidResponse(\"foundry.applyAction\", cause),\n            });\n        }),\n        // Admin users have no ontology websocket feed; the Replica owns this polling lifetime.\n        refresh: (subset: ObjectSubset) =>\n            subset.from.source.objectType === options.users?.objectType\n                ? { pollIntervalMs: 60_000 }\n                : undefined,\n        watchSubset: watcher\n            ? (request: ObjectSubset) =>\n                  request.from.source.objectType === options.users?.objectType\n                      ? undefined\n                      : Effect.gen(function* () {\n                            const subset = yield* compileObjectSubset(options.ir, request, options.context);\n                            const filter = subsetFilter(subset.query?.where);\n                            return yield* acquireWatch(\n                                watcher.subscribe(\n                                    filter\n                                        ? {\n                                              type: \"filter\",\n                                              objectSet: { type: \"base\", objectType: subset.objectType },\n                                              where: filter,\n                                          }\n                                        : { type: \"base\", objectType: subset.objectType }\n                                )\n                            );\n                        })\n            : undefined,\n    });\n});\n"],"mappings":"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"}

package/lib/adapter/encrypted.d.ts

@@ -0,0 +1,12 @@
+import { OntologyClient } from "@party-stack/foundry-client";
+import { BackendEncryptedValues } from "@party-stack/ontology-backend";
+import { OntologyIR } from "@party-stack/ontology-spec";
+import { Encrypted } from "@party-stack/ontology-spec/values";
+//#region src/adapter/encrypted.d.ts
+/** Ciphertext is an opaque identifier here, never implicitly decrypted or interpreted as plaintext. */
+export declare function decodeFoundryCiphertext(value: unknown, source?: Encrypted["source"]): Encrypted;
+export declare const encodeFoundryCiphertext: (value: unknown) => string;
+/** Foundry's property endpoint reads the property's current value; it does not decrypt an arbitrary blob. */
+export declare function makeFoundryEncryptedValues(client: OntologyClient, ir: OntologyIR): BackendEncryptedValues;
+//#endregion
+//# sourceMappingURL=encrypted.d.ts.map

package/lib/adapter/encrypted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encrypted.d.ts","names":[],"sources":["../../src/adapter/encrypted.ts"],"mappings":";;;;;;wBAkBgB,wBAAwB,gBAAgB,SAAS,sBAAsB;qBAO1E,0BAAuB;;wBAgCpB,2BAA2B,QAAQ,gBAAgB,IAAI,aAAa"}

package/lib/adapter/encrypted.js

@@ -0,0 +1,79 @@
+import { Effect, Predicate, Schema } from "effect";
+import { CipherTextProperties } from "@osdk/foundry.ontologies";
+import { BackendError, encryptedPropertyCodec } from "@party-stack/ontology-backend";
+import { resolveType } from "@party-stack/ontology-spec/utils";
+//#region src/adapter/encrypted.ts
+const Ciphertext = Schema.String.check(Schema.isPattern(/^CIPHER::[^:]+::.+::CIPHER$/u));
+const Source = Schema.Struct({
+	objectType: Schema.String,
+	primaryKey: Schema.Union([Schema.String, Schema.Finite]),
+	property: Schema.String
+});
+const Handle = Schema.Struct({
+	ciphertext: Ciphertext,
+	source: Schema.optional(Source)
+});
+/** Ciphertext is an opaque identifier here, never implicitly decrypted or interpreted as plaintext. */
+function decodeFoundryCiphertext(value, source) {
+	const handle = Predicate.isString(value) ? { ciphertext: Schema.decodeUnknownSync(Ciphertext)(value) } : Schema.decodeUnknownSync(Handle)(value);
+	return source ? {
+		...handle,
+		source
+	} : handle;
+}
+const encodeFoundryCiphertext = (value) => Schema.decodeUnknownSync(Handle)(value).ciphertext;
+const rejected = (operation, message, kind = "InvalidRequest") => new BackendError({
+	operation,
+	kind,
+	message,
+	retryable: false
+});
+function requestError(operation, cause) {
+	const status = Predicate.isObject(cause) ? cause.statusCode : void 0;
+	return new BackendError({
+		operation,
+		kind: status === 404 ? "NotFound" : status === 401 ? "Unauthenticated" : status === 403 ? "Forbidden" : status === 429 ? "RateLimited" : status === 400 ? "InvalidRequest" : status === 200 ? "InvalidResponse" : "Unavailable",
+		message: "Foundry CipherText request failed.",
+		retryable: status === void 0 || status === 429 || Predicate.isNumber(status) && status >= 500
+	});
+}
+/** Foundry's property endpoint reads the property's current value; it does not decrypt an arbitrary blob. */
+function makeFoundryEncryptedValues(client, ir) {
+	const requestClient = (signal) => ({
+		...client,
+		fetch: (input, init) => client.fetch(input, {
+			...init,
+			signal: init?.signal ? AbortSignal.any([signal, init.signal]) : signal
+		})
+	});
+	return { decrypt: Effect.fn("Foundry.decrypt")(function* (value) {
+		const handle = yield* Effect.try({
+			try: () => Schema.decodeUnknownSync(Handle)(value),
+			catch: () => rejected("foundry.decrypt", "Invalid Foundry encrypted handle.")
+		});
+		if (!handle.source) return yield* rejected("foundry.decrypt", "Foundry decryption requires an object property source.");
+		const codec = yield* Effect.try({
+			try: () => {
+				const codec = encryptedPropertyCodec(ir, handle);
+				if (resolveType(ir, codec.type).kind !== "string") throw new Error();
+				return codec;
+			},
+			catch: () => rejected("foundry.decrypt", "Expected a CipherText property with string plaintext.")
+		});
+		const result = yield* Effect.tryPromise({
+			try: (signal) => CipherTextProperties.decrypt(requestClient(signal), client.ontologyRid, handle.source.objectType, String(handle.source.primaryKey), handle.source.property),
+			catch: (cause) => requestError("foundry.decrypt", cause)
+		});
+		return yield* Effect.try({
+			try: () => ({
+				value: codec.encode(result.plaintext),
+				ciphertext: handle.ciphertext
+			}),
+			catch: () => rejected("foundry.decrypt", "Invalid decrypted plaintext.", "InvalidResponse")
+		});
+	}) };
+}
+//#endregion
+export { decodeFoundryCiphertext, encodeFoundryCiphertext, makeFoundryEncryptedValues };
+
+//# sourceMappingURL=encrypted.js.map

package/lib/adapter/encrypted.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encrypted.js","names":[],"sources":["../../src/adapter/encrypted.ts"],"sourcesContent":["import { CipherTextProperties } from \"@osdk/foundry.ontologies\";\nimport { BackendError, encryptedPropertyCodec } from \"@party-stack/ontology-backend\";\nimport { resolveType } from \"@party-stack/ontology-spec/utils\";\nimport { Effect, Predicate, Schema } from \"effect\";\nimport type { OntologyClient } from \"@party-stack/foundry-client\";\nimport type { BackendEncryptedValues } from \"@party-stack/ontology-backend\";\nimport type { OntologyIR } from \"@party-stack/ontology-spec\";\nimport type { Encrypted } from \"@party-stack/ontology-spec/values\";\n\nconst Ciphertext = Schema.String.check(Schema.isPattern(/^CIPHER::[^:]+::.+::CIPHER$/u));\nconst Source = Schema.Struct({\n    objectType: Schema.String,\n    primaryKey: Schema.Union([Schema.String, Schema.Finite]),\n    property: Schema.String,\n});\nconst Handle = Schema.Struct({ ciphertext: Ciphertext, source: Schema.optional(Source) });\n\n/** Ciphertext is an opaque identifier here, never implicitly decrypted or interpreted as plaintext. */\nexport function decodeFoundryCiphertext(value: unknown, source?: Encrypted[\"source\"]): Encrypted {\n    const handle = Predicate.isString(value)\n        ? { ciphertext: Schema.decodeUnknownSync(Ciphertext)(value) }\n        : Schema.decodeUnknownSync(Handle)(value);\n    return source ? { ...handle, source } : handle;\n}\n\nexport const encodeFoundryCiphertext = (value: unknown): string =>\n    Schema.decodeUnknownSync(Handle)(value).ciphertext;\n\nconst rejected = (operation: string, message: string, kind: BackendError[\"kind\"] = \"InvalidRequest\") =>\n    new BackendError({ operation, kind, message, retryable: false });\n\nfunction requestError(operation: string, cause: unknown): BackendError {\n    const status = Predicate.isObject(cause) ? cause.statusCode : undefined;\n    // Provider errors and decoder issues may contain sensitive bodies. Preserve the\n    // classification, without attaching raw requests, ciphertext or plaintext to traces.\n    return new BackendError({\n        operation,\n        kind:\n            status === 404\n                ? \"NotFound\"\n                : status === 401\n                  ? \"Unauthenticated\"\n                  : status === 403\n                    ? \"Forbidden\"\n                    : status === 429\n                      ? \"RateLimited\"\n                      : status === 400\n                        ? \"InvalidRequest\"\n                        : status === 200\n                          ? \"InvalidResponse\"\n                          : \"Unavailable\",\n        message: \"Foundry CipherText request failed.\",\n        retryable: status === undefined || status === 429 || (Predicate.isNumber(status) && status >= 500),\n    });\n}\n\n/** Foundry's property endpoint reads the property's current value; it does not decrypt an arbitrary blob. */\nexport function makeFoundryEncryptedValues(client: OntologyClient, ir: OntologyIR): BackendEncryptedValues {\n    const requestClient = (signal: AbortSignal): OntologyClient => ({\n        ...client,\n        fetch: (input, init) =>\n            client.fetch(input, {\n                ...init,\n                signal: init?.signal ? AbortSignal.any([signal, init.signal]) : signal,\n            }),\n    });\n    return {\n        decrypt: Effect.fn(\"Foundry.decrypt\")(function* (value) {\n            const handle = yield* Effect.try({\n                try: () => Schema.decodeUnknownSync(Handle)(value),\n                catch: () => rejected(\"foundry.decrypt\", \"Invalid Foundry encrypted handle.\"),\n            });\n            if (!handle.source)\n                return yield* rejected(\n                    \"foundry.decrypt\",\n                    \"Foundry decryption requires an object property source.\"\n                );\n            const codec = yield* Effect.try({\n                try: () => {\n                    const codec = encryptedPropertyCodec(ir, handle);\n                    if (resolveType(ir, codec.type).kind !== \"string\") throw new Error();\n                    return codec;\n                },\n                catch: () =>\n                    rejected(\"foundry.decrypt\", \"Expected a CipherText property with string plaintext.\"),\n            });\n            const result = yield* Effect.tryPromise({\n                try: (signal) =>\n                    CipherTextProperties.decrypt(\n                        requestClient(signal),\n                        client.ontologyRid,\n                        handle.source!.objectType,\n                        String(handle.source!.primaryKey),\n                        handle.source!.property\n                    ),\n                catch: (cause) => requestError(\"foundry.decrypt\", cause),\n            });\n            return yield* Effect.try({\n                // TODO(Foundry FR): require the decrypt response to echo its ciphertext.\n                // Until then, assume the property has not changed since this handle was read.\n                try: () => ({ value: codec.encode(result.plaintext), ciphertext: handle.ciphertext }),\n                catch: () => rejected(\"foundry.decrypt\", \"Invalid decrypted plaintext.\", \"InvalidResponse\"),\n            });\n        }),\n    };\n}\n"],"mappings":";;;;;AASA,MAAM,aAAa,OAAO,OAAO,MAAM,OAAO,UAAU,8BAA8B,CAAC;AACvF,MAAM,SAAS,OAAO,OAAO;CACzB,YAAY,OAAO;CACnB,YAAY,OAAO,MAAM,CAAC,OAAO,QAAQ,OAAO,MAAM,CAAC;CACvD,UAAU,OAAO;AACrB,CAAC;AACD,MAAM,SAAS,OAAO,OAAO;CAAE,YAAY;CAAY,QAAQ,OAAO,SAAS,MAAM;AAAE,CAAC;;AAGxF,SAAgB,wBAAwB,OAAgB,QAAyC;CAC7F,MAAM,SAAS,UAAU,SAAS,KAAK,IACjC,EAAE,YAAY,OAAO,kBAAkB,UAAU,CAAC,CAAC,KAAK,EAAE,IAC1D,OAAO,kBAAkB,MAAM,CAAC,CAAC,KAAK;CAC5C,OAAO,SAAS;EAAE,GAAG;EAAQ;CAAO,IAAI;AAC5C;AAEA,MAAa,2BAA2B,UACpC,OAAO,kBAAkB,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC;AAE5C,MAAM,YAAY,WAAmB,SAAiB,OAA6B,qBAC/E,IAAI,aAAa;CAAE;CAAW;CAAM;CAAS,WAAW;AAAM,CAAC;AAEnE,SAAS,aAAa,WAAmB,OAA8B;CACnE,MAAM,SAAS,UAAU,SAAS,KAAK,IAAI,MAAM,aAAa,KAAA;CAG9D,OAAO,IAAI,aAAa;EACpB;EACA,MACI,WAAW,MACL,aACA,WAAW,MACT,oBACA,WAAW,MACT,cACA,WAAW,MACT,gBACA,WAAW,MACT,mBACA,WAAW,MACT,oBACA;EACpB,SAAS;EACT,WAAW,WAAW,KAAA,KAAa,WAAW,OAAQ,UAAU,SAAS,MAAM,KAAK,UAAU;CAClG,CAAC;AACL;;AAGA,SAAgB,2BAA2B,QAAwB,IAAwC;CACvG,MAAM,iBAAiB,YAAyC;EAC5D,GAAG;EACH,QAAQ,OAAO,SACX,OAAO,MAAM,OAAO;GAChB,GAAG;GACH,QAAQ,MAAM,SAAS,YAAY,IAAI,CAAC,QAAQ,KAAK,MAAM,CAAC,IAAI;EACpE,CAAC;CACT;CACA,OAAO,EACH,SAAS,OAAO,GAAG,iBAAiB,CAAC,CAAC,WAAW,OAAO;EACpD,MAAM,SAAS,OAAO,OAAO,IAAI;GAC7B,WAAW,OAAO,kBAAkB,MAAM,CAAC,CAAC,KAAK;GACjD,aAAa,SAAS,mBAAmB,mCAAmC;EAChF,CAAC;EACD,IAAI,CAAC,OAAO,QACR,OAAO,OAAO,SACV,mBACA,wDACJ;EACJ,MAAM,QAAQ,OAAO,OAAO,IAAI;GAC5B,WAAW;IACP,MAAM,QAAQ,uBAAuB,IAAI,MAAM;IAC/C,IAAI,YAAY,IAAI,MAAM,IAAI,CAAC,CAAC,SAAS,UAAU,MAAM,IAAI,MAAM;IACnE,OAAO;GACX;GACA,aACI,SAAS,mBAAmB,uDAAuD;EAC3F,CAAC;EACD,MAAM,SAAS,OAAO,OAAO,WAAW;GACpC,MAAM,WACF,qBAAqB,QACjB,cAAc,MAAM,GACpB,OAAO,aACP,OAAO,OAAQ,YACf,OAAO,OAAO,OAAQ,UAAU,GAChC,OAAO,OAAQ,QACnB;GACJ,QAAQ,UAAU,aAAa,mBAAmB,KAAK;EAC3D,CAAC;EACD,OAAO,OAAO,OAAO,IAAI;GAGrB,YAAY;IAAE,OAAO,MAAM,OAAO,OAAO,SAAS;IAAG,YAAY,OAAO;GAAW;GACnF,aAAa,SAAS,mBAAmB,gCAAgC,iBAAiB;EAC9F,CAAC;CACL,CAAC,EACL;AACJ"}

package/lib/adapter/foundryActionError.d.ts

@@ -0,0 +1,7 @@
+import { BackendError } from "@party-stack/ontology-backend";
+import { OntologyIR } from "@party-stack/ontology-spec";
+//#region src/adapter/foundryActionError.d.ts
+/** Map only provider evidence about submitted references; a general 404 cannot identify a field. */
+export declare function foundryActionError(operation: string, cause: unknown, ir: OntologyIR, actionName: string, values: Record<string, unknown>): BackendError;
+//#endregion
+//# sourceMappingURL=foundryActionError.d.ts.map

package/lib/adapter/foundryActionError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"foundryActionError.d.ts","names":[],"sources":["../../src/adapter/foundryActionError.ts"],"mappings":";;;;wBAagB,mBACZ,mBACA,gBACA,IAAI,YACJ,oBACA,QAAQ,0BACT"}

package/lib/adapter/foundryActionError.js

@@ -0,0 +1,61 @@
+import { Schema } from "effect";
+import { BackendError, classifyBackendFailure } from "@party-stack/ontology-backend";
+import { resolveType } from "@party-stack/ontology-spec/utils";
+//#region src/adapter/foundryActionError.ts
+const Failure = Schema.Struct({
+	errorName: Schema.optional(Schema.String),
+	parameters: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+	cause: Schema.optional(Schema.Unknown),
+	reason: Schema.optional(Schema.Unknown)
+});
+/** Map only provider evidence about submitted references; a general 404 cannot identify a field. */
+function foundryActionError(operation, cause, ir, actionName, values) {
+	if (cause instanceof BackendError) return cause;
+	const normalized = classifyBackendFailure(operation, cause);
+	const action = ir.actionTypes.find((action) => action.name === actionName);
+	if (!action) return normalized;
+	let candidate = cause;
+	for (let depth = 0; depth < 5; depth++) {
+		const decoded = Schema.decodeUnknownOption(Failure)(candidate);
+		if (decoded._tag === "None") break;
+		const error = decoded.value;
+		const name = error.errorName?.split(":").at(-1);
+		const paths = [];
+		if (name === "ActionParameterObjectNotFound") {
+			const parameter = action.parameters.find((parameter) => parameter.name === error.parameters?.parameterId);
+			if (parameter) paths.push([parameter.name]);
+		} else if (name === "ParameterObjectNotFound" || name === "ObjectNotFound") {
+			const visit = (definition, value, path) => {
+				if (value === void 0 || value === null) return;
+				const type = resolveType(ir, definition);
+				if (type.kind === "optional") visit(type.value.type, value, path);
+				else if (type.kind === "list" && Array.isArray(value)) value.forEach((item, index) => visit(type.value.elementType, item, [...path, index]));
+				else if (type.kind === "objectReference" && type.value.objectType === error.parameters?.objectType && Object.is(value, error.parameters?.primaryKey)) paths.push(path);
+			};
+			for (const parameter of action.parameters) visit(parameter.type, values[parameter.name], [parameter.name]);
+		}
+		if (paths.length) return new BackendError({
+			operation,
+			kind: "ValidationFailed",
+			message: "Submission failed validation.",
+			retryable: false,
+			actionOutcome: "not-committed",
+			cause: normalized.cause,
+			issues: paths.map((path) => ({
+				path,
+				code: "InvalidObjectReference",
+				category: "reference",
+				source: "parameter",
+				messageSource: "standard",
+				message: "Choose a valid value."
+			}))
+		});
+		if (name) break;
+		candidate = error.reason ?? error.cause;
+	}
+	return normalized;
+}
+//#endregion
+export { foundryActionError };
+
+//# sourceMappingURL=foundryActionError.js.map

package/lib/adapter/foundryActionError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"foundryActionError.js","names":[],"sources":["../../src/adapter/foundryActionError.ts"],"sourcesContent":["import { BackendError, classifyBackendFailure } from \"@party-stack/ontology-backend\";\nimport { resolveType } from \"@party-stack/ontology-spec/utils\";\nimport { Schema } from \"effect\";\nimport type { OntologyIR, TypeDef } from \"@party-stack/ontology-spec\";\n\nconst Failure = Schema.Struct({\n    errorName: Schema.optional(Schema.String),\n    parameters: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),\n    cause: Schema.optional(Schema.Unknown),\n    reason: Schema.optional(Schema.Unknown),\n});\n\n/** Map only provider evidence about submitted references; a general 404 cannot identify a field. */\nexport function foundryActionError(\n    operation: string,\n    cause: unknown,\n    ir: OntologyIR,\n    actionName: string,\n    values: Record<string, unknown>\n): BackendError {\n    if (cause instanceof BackendError) return cause;\n    const normalized = classifyBackendFailure(operation, cause);\n    const action = ir.actionTypes.find((action) => action.name === actionName);\n    if (!action) return normalized;\n    let candidate = cause;\n    for (let depth = 0; depth < 5; depth++) {\n        const decoded = Schema.decodeUnknownOption(Failure)(candidate);\n        if (decoded._tag === \"None\") break;\n        const error = decoded.value;\n        const name = error.errorName?.split(\":\").at(-1);\n        const paths: Array<readonly (string | number)[]> = [];\n        if (name === \"ActionParameterObjectNotFound\") {\n            const parameter = action.parameters.find(\n                (parameter) => parameter.name === error.parameters?.parameterId\n            );\n            if (parameter) paths.push([parameter.name]);\n        } else if (name === \"ParameterObjectNotFound\" || name === \"ObjectNotFound\") {\n            const visit = (definition: TypeDef, value: unknown, path: readonly (string | number)[]) => {\n                if (value === undefined || value === null) return;\n                const type = resolveType(ir, definition);\n                if (type.kind === \"optional\") visit(type.value.type, value, path);\n                else if (type.kind === \"list\" && Array.isArray(value))\n                    value.forEach((item, index) => visit(type.value.elementType, item, [...path, index]));\n                else if (\n                    type.kind === \"objectReference\" &&\n                    type.value.objectType === error.parameters?.objectType &&\n                    Object.is(value, error.parameters?.primaryKey)\n                )\n                    paths.push(path);\n            };\n            for (const parameter of action.parameters)\n                visit(parameter.type, values[parameter.name], [parameter.name]);\n        }\n        if (paths.length)\n            return new BackendError({\n                operation,\n                kind: \"ValidationFailed\",\n                message: \"Submission failed validation.\",\n                retryable: false,\n                actionOutcome: \"not-committed\",\n                cause: normalized.cause,\n                issues: paths.map((path) => ({\n                    path,\n                    code: \"InvalidObjectReference\",\n                    category: \"reference\",\n                    source: \"parameter\",\n                    messageSource: \"standard\",\n                    message: \"Choose a valid value.\",\n                })),\n            });\n        if (name) break;\n        candidate = error.reason ?? error.cause;\n    }\n    return normalized;\n}\n"],"mappings":";;;;AAKA,MAAM,UAAU,OAAO,OAAO;CAC1B,WAAW,OAAO,SAAS,OAAO,MAAM;CACxC,YAAY,OAAO,SAAS,OAAO,OAAO,OAAO,QAAQ,OAAO,OAAO,CAAC;CACxE,OAAO,OAAO,SAAS,OAAO,OAAO;CACrC,QAAQ,OAAO,SAAS,OAAO,OAAO;AAC1C,CAAC;;AAGD,SAAgB,mBACZ,WACA,OACA,IACA,YACA,QACY;CACZ,IAAI,iBAAiB,cAAc,OAAO;CAC1C,MAAM,aAAa,uBAAuB,WAAW,KAAK;CAC1D,MAAM,SAAS,GAAG,YAAY,MAAM,WAAW,OAAO,SAAS,UAAU;CACzE,IAAI,CAAC,QAAQ,OAAO;CACpB,IAAI,YAAY;CAChB,KAAK,IAAI,QAAQ,GAAG,QAAQ,GAAG,SAAS;EACpC,MAAM,UAAU,OAAO,oBAAoB,OAAO,CAAC,CAAC,SAAS;EAC7D,IAAI,QAAQ,SAAS,QAAQ;EAC7B,MAAM,QAAQ,QAAQ;EACtB,MAAM,OAAO,MAAM,WAAW,MAAM,GAAG,CAAC,CAAC,GAAG,EAAE;EAC9C,MAAM,QAA6C,CAAC;EACpD,IAAI,SAAS,iCAAiC;GAC1C,MAAM,YAAY,OAAO,WAAW,MAC/B,cAAc,UAAU,SAAS,MAAM,YAAY,WACxD;GACA,IAAI,WAAW,MAAM,KAAK,CAAC,UAAU,IAAI,CAAC;EAC9C,OAAO,IAAI,SAAS,6BAA6B,SAAS,kBAAkB;GACxE,MAAM,SAAS,YAAqB,OAAgB,SAAuC;IACvF,IAAI,UAAU,KAAA,KAAa,UAAU,MAAM;IAC3C,MAAM,OAAO,YAAY,IAAI,UAAU;IACvC,IAAI,KAAK,SAAS,YAAY,MAAM,KAAK,MAAM,MAAM,OAAO,IAAI;SAC3D,IAAI,KAAK,SAAS,UAAU,MAAM,QAAQ,KAAK,GAChD,MAAM,SAAS,MAAM,UAAU,MAAM,KAAK,MAAM,aAAa,MAAM,CAAC,GAAG,MAAM,KAAK,CAAC,CAAC;SACnF,IACD,KAAK,SAAS,qBACd,KAAK,MAAM,eAAe,MAAM,YAAY,cAC5C,OAAO,GAAG,OAAO,MAAM,YAAY,UAAU,GAE7C,MAAM,KAAK,IAAI;GACvB;GACA,KAAK,MAAM,aAAa,OAAO,YAC3B,MAAM,UAAU,MAAM,OAAO,UAAU,OAAO,CAAC,UAAU,IAAI,CAAC;EACtE;EACA,IAAI,MAAM,QACN,OAAO,IAAI,aAAa;GACpB;GACA,MAAM;GACN,SAAS;GACT,WAAW;GACX,eAAe;GACf,OAAO,WAAW;GAClB,QAAQ,MAAM,KAAK,UAAU;IACzB;IACA,MAAM;IACN,UAAU;IACV,QAAQ;IACR,eAAe;IACf,SAAS;GACb,EAAE;EACN,CAAC;EACL,IAAI,MAAM;EACV,YAAY,MAAM,UAAU,MAAM;CACtC;CACA,OAAO;AACX"}

package/lib/adapter/foundryActionValidation.d.ts

@@ -1,8 +1,9 @@
 import { OntologyClient } from "@party-stack/foundry-client";
 import { SyncApplyActionResponseV2 } from "@osdk/foundry.ontologies";
-import { Uncertain, ValidationIssue } from "@party-stack/ontology";
+import { ValidationIssue } from "@party-stack/ontology-backend";
+import { Uncertain } from "@party-stack/ontology-spec";
 import { Condition } from "@osdk/client.unstable";
-import { Result } from "@party-stack/ontology/values";
+import { Result } from "@party-stack/ontology-spec/values";
 //#region src/adapter/foundryActionValidation.d.ts
 export interface FoundrySubmissionCriterion {
   condition: Condition;
@@ -20,6 +21,6 @@ export declare function validateFoundryActionDraftCriteria(options: {
   parameters: Record<string, unknown>;
   knownParameters?: ReadonlySet<string>;
 }): Promise<Uncertain<Result<void, readonly ValidationIssue[]>>>;
-export declare function getFoundryValidationIssues(result: SyncApplyActionResponseV2): ValidationIssue[];
+export declare function getFoundryValidationIssues(result: SyncApplyActionResponseV2, parameters?: Record<string, unknown>): ValidationIssue[];
 //#endregion
 //# sourceMappingURL=foundryActionValidation.d.ts.map