@party-stack/foundry-ontology 0.17.0 → 0.18.1

package/lib/adapter/createFoundryOntologyBackendAdapter.js

@@ -1,423 +1,311 @@
+import { objectCollectionOptions } from "./objectCollectionOptions.js";
+import { toFoundryActionTypeName } from "../utils/actionTypeName.js";
+import { getFoundryAttachmentKind } from "../meta/foundryAttachmentMetadata.js";
+import { getFoundryActionOverrideParameterMapping } from "../meta/convertMetaActionType.js";
+import { getFoundryValidationIssues, loadFoundrySubmissionCriteria, validateFoundryActionDraftCriteria } from "./foundryActionValidation.js";
+import { decodeFoundryMediaId, mediaReferenceToFoundryMediaId } from "./foundryMediaId.js";
+import { createFoundryCodec } from "./foundryCodec.js";
+import { Actions, Attachments, MediaReferenceProperties, Queries } from "@osdk/foundry.ontologies";
+import { Temporal } from "temporal-polyfill";
 import { invariant } from "@bobbyfidz/panic";
 import { MediaSets } from "@osdk/foundry.mediasets";
-import { Actions, Attachments, MediaReferenceProperties, Queries, } from "@osdk/foundry.ontologies";
-import { certain, NonRetryableError, uncertain, } from "@party-stack/ontology";
+import { NonRetryableError, certain, uncertain } from "@party-stack/ontology";
 import { resolveType, unwrapType } from "@party-stack/ontology/utils";
-import { Temporal } from "temporal-polyfill";
-import { getFoundryActionOverrideParameterMapping } from "../meta/convertMetaActionType.js";
-import { getFoundryAttachmentKind } from "../meta/foundryAttachmentMetadata.js";
-import { toFoundryActionTypeName } from "../utils/actionTypeName.js";
-import { getFoundryValidationIssues, loadFoundrySubmissionCriteria, validateFoundryActionDraftCriteria, } from "./foundryActionValidation.js";
-import { createFoundryCodec } from "./foundryCodec.js";
-import { decodeFoundryMediaId, mediaReferenceToFoundryMediaId } from "./foundryMediaId.js";
-import { objectCollectionOptions } from "./objectCollectionOptions.js";
+//#region src/adapter/createFoundryOntologyBackendAdapter.ts
 function isFoundryAttachmentRid(value) {
-    return /^ri\.attachments\.[^.]+\.attachment\..+$/.test(value);
+	return /^ri\.attachments\.[^.]+\.attachment\..+$/.test(value);
 }
-export function isFoundryNotFoundError(error) {
-    if (typeof error !== "object" || error === null) {
-        return false;
-    }
-    const foundryError = error;
-    return foundryError.statusCode === 404 || foundryError.errorCode === "NOT_FOUND";
+function isFoundryNotFoundError(error) {
+	if (typeof error !== "object" || error === null) return false;
+	const foundryError = error;
+	return foundryError.statusCode === 404 || foundryError.errorCode === "NOT_FOUND";
 }
 function serializeOverrideValue(value) {
-    if (typeof value === "string") {
-        return value;
-    }
-    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
-        return String(value);
-    }
-    if (value instanceof Date) {
-        return value.toISOString();
-    }
-    if (value instanceof Temporal.Instant) {
-        return value.toString();
-    }
-    if (value instanceof Temporal.PlainDate || value instanceof Temporal.PlainDateTime) {
-        return value.toString();
-    }
-    return JSON.stringify(value) ?? "";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value);
+	if (value instanceof Date) return value.toISOString();
+	if (value instanceof Temporal.Instant) return value.toString();
+	if (value instanceof Temporal.PlainDate || value instanceof Temporal.PlainDateTime) return value.toString();
+	return JSON.stringify(value) ?? "";
 }
 function serializeActionExecutionTime(value) {
-    try {
-        const candidate = value instanceof Date ? value.toISOString() : String(value);
-        return Temporal.Instant.from(candidate).toString();
-    }
-    catch (cause) {
-        throw new TypeError("Invalid action execution time: expected a Date or Temporal-like ISO instant.", { cause });
-    }
+	try {
+		const candidate = value instanceof Date ? value.toISOString() : String(value);
+		return Temporal.Instant.from(candidate).toString();
+	} catch (cause) {
+		throw new TypeError("Invalid action execution time: expected a Date or Temporal-like ISO instant.", { cause });
+	}
 }
 function getApplyActionOperationId(result) {
-    const operationId = result.operationId;
-    if (typeof operationId !== "string" || operationId.length === 0) {
-        throw new Error("Foundry apply action response did not include an operationId.");
-    }
-    return operationId;
+	const operationId = result.operationId;
+	if (typeof operationId !== "string" || operationId.length === 0) throw new Error("Foundry apply action response did not include an operationId.");
+	return operationId;
 }
 function getAttachmentName(attachment) {
-    if (typeof attachment !== "object" || attachment === null || Array.isArray(attachment)) {
-        return undefined;
-    }
-    const name = attachment.name;
-    return typeof name === "string" ? name : undefined;
+	if (typeof attachment !== "object" || attachment === null || Array.isArray(attachment)) return;
+	const name = attachment.name;
+	return typeof name === "string" ? name : void 0;
 }
 function getAttachmentProviderType(target) {
-    return getFoundryAttachmentKind(target?.meta);
+	return getFoundryAttachmentKind(target?.meta);
 }
 function getEditedObjectTypes(edits) {
-    const objectTypes = new Set();
-    if (!edits || edits.type !== "edits") {
-        return objectTypes;
-    }
-    for (const edit of edits.edits) {
-        if (edit.type === "addObject" || edit.type === "modifyObject" || edit.type === "deleteObject") {
-            objectTypes.add(edit.objectType);
-        }
-    }
-    return objectTypes;
+	const objectTypes = /* @__PURE__ */ new Set();
+	if (!edits || edits.type !== "edits") return objectTypes;
+	for (const edit of edits.edits) if (edit.type === "addObject" || edit.type === "modifyObject" || edit.type === "deleteObject") objectTypes.add(edit.objectType);
+	return objectTypes;
 }
 function prepareFoundryActionInvocation(options) {
-    const actionType = options.ir.actionTypes.find((candidate) => candidate.name === options.name);
-    if (!actionType) {
-        throw new NonRetryableError(`Unknown Foundry action type "${options.name}".`);
-    }
-    const overrideMapping = getFoundryActionOverrideParameterMapping(actionType);
-    const parameterTypes = new Map(actionType.parameters.map((parameter) => [parameter.name, parameter.type]));
-    const parameters = {};
-    const uniqueIdentifierLinkIdValues = {};
-    let actionExecutionTime;
-    for (const [parameterName, value] of Object.entries(options.parameters)) {
-        if (overrideMapping.uuidByParameterName.has(parameterName)) {
-            if (value !== undefined) {
-                uniqueIdentifierLinkIdValues[overrideMapping.uuidByParameterName.get(parameterName)] =
-                    serializeOverrideValue(value);
-            }
-            continue;
-        }
-        if (overrideMapping.nowParameterName === parameterName) {
-            if (value !== undefined) {
-                actionExecutionTime = serializeActionExecutionTime(value);
-            }
-            continue;
-        }
-        if (value !== undefined) {
-            const parameterType = parameterTypes.get(parameterName);
-            parameters[parameterName] = parameterType
-                ? options.codec.encodeValue(parameterType, value)
-                : value;
-        }
-    }
-    return {
-        parameters,
-        overrides: {
-            uniqueIdentifierLinkIdValues,
-            actionExecutionTime,
-        },
-    };
+	const actionType = options.ir.actionTypes.find((candidate) => candidate.name === options.name);
+	if (!actionType) throw new NonRetryableError(`Unknown Foundry action type "${options.name}".`);
+	const overrideMapping = getFoundryActionOverrideParameterMapping(actionType);
+	const parameterTypes = new Map(actionType.parameters.map((parameter) => [parameter.name, parameter.type]));
+	const parameters = {};
+	const uniqueIdentifierLinkIdValues = {};
+	let actionExecutionTime;
+	for (const [parameterName, value] of Object.entries(options.parameters)) {
+		if (overrideMapping.uuidByParameterName.has(parameterName)) {
+			if (value !== void 0) uniqueIdentifierLinkIdValues[overrideMapping.uuidByParameterName.get(parameterName)] = serializeOverrideValue(value);
+			continue;
+		}
+		if (overrideMapping.nowParameterName === parameterName) {
+			if (value !== void 0) actionExecutionTime = serializeActionExecutionTime(value);
+			continue;
+		}
+		if (value !== void 0) {
+			const parameterType = parameterTypes.get(parameterName);
+			parameters[parameterName] = parameterType ? options.codec.encodeValue(parameterType, value) : value;
+		}
+	}
+	return {
+		parameters,
+		overrides: {
+			uniqueIdentifierLinkIdValues,
+			actionExecutionTime
+		}
+	};
 }
-export function createFoundryOntologyBackendAdapter(opts) {
-    const codec = createFoundryCodec(opts.ir);
-    const attachments = {
-        generateAttachmentId: (_, { target }) => {
-            invariant(target, "A property target must be passed to generateAttachmentId in the Foundry adapter so that we know whether to target attachments or media.");
-            if (getFoundryAttachmentKind(target.meta) ===
-                "attachment") {
-                return `ri.attachments.main.attachment.${crypto.randomUUID()}`;
-            }
-            return crypto.randomUUID();
-        },
-        canMaterializeAttachment: (_, { target }) => getAttachmentProviderType(target) !== "media",
-        materializeAttachment: async (attachment, blob, { target }) => {
-            invariant(target, "A property target must be passed to materializeAttachment in the Foundry adapter so that we know whether to target attachments or media.");
-            invariant(getAttachmentProviderType(target) === "attachment", "Foundry media references must be uploaded during action execution.");
-            const filename = getAttachmentName(blob) ?? "";
-            if (!isFoundryAttachmentRid(attachment.id)) {
-                const uploaded = await Attachments.upload(opts.client, blob, { filename });
-                return {
-                    ...attachment,
-                    id: uploaded.rid,
-                };
-            }
-            try {
-                await Attachments.get(opts.client, attachment.id);
-                return;
-            }
-            catch (error) {
-                if (!isFoundryNotFoundError(error)) {
-                    throw error;
-                }
-            }
-            await Attachments.uploadWithRid(opts.client, attachment.id, blob, {
-                filename,
-                preview: true,
-            });
-        },
-        getAttachmentContent: async (attachment) => {
-            const userContent = await opts.users?.getAttachmentContent?.(opts.client, attachment);
-            if (userContent)
-                return userContent;
-            const media = decodeFoundryMediaId(attachment.id);
-            if (media) {
-                const source = attachment.source;
-                invariant(source, `Foundry media attachment "${attachment.id}" is missing its object property source.`);
-                const response = await MediaReferenceProperties.getMediaContent(opts.client, opts.client.ontologyRid, source.objectType, String(source.primaryKey), source.property, { preview: true });
-                return response.blob();
-            }
-            const contents = await Attachments.read(opts.client, attachment.id);
-            return contents.blob();
-        },
-        getAttachmentMetadata: async (attachment, selection) => {
-            const userMetadata = await opts.users?.getAttachmentMetadata?.(opts.client, attachment, selection);
-            if (userMetadata)
-                return userMetadata;
-            const media = decodeFoundryMediaId(attachment.id);
-            if (media) {
-                const result = {};
-                if (attachment.type !== undefined) {
-                    result.type = attachment.type;
-                }
-                if (selection.includes("dimensions")) {
-                    const detailed = await MediaSets.metadata(opts.client, media.mediaSetRid, media.mediaItemRid);
-                    result.size = detailed.sizeBytes;
-                    if (detailed.type === "imagery" && detailed.dimensions) {
-                        result.dimensions = {
-                            width: detailed.dimensions.width,
-                            height: detailed.dimensions.height,
-                        };
-                    }
-                }
-                const missingMetadata = selection.filter((field) => result[field] === undefined);
-                const needsBasicMetadata = missingMetadata.some((field) => field !== "dimensions");
-                if (!needsBasicMetadata)
-                    return result;
-                const source = attachment.source;
-                invariant(source, `Foundry media attachment "${attachment.id}" is missing its object property source.`);
-                const info = await MediaReferenceProperties.getMediaMetadata(opts.client, opts.client.ontologyRid, source.objectType, String(source.primaryKey), source.property, { preview: true });
-                return {
-                    ...result,
-                    size: Number(info.sizeBytes),
-                    type: info.mediaType,
-                    name: info.path,
-                };
-            }
-            const metadata = await Attachments.get(opts.client, attachment.id);
-            return {
-                id: attachment.id,
-                size: Number(metadata.sizeBytes),
-                type: metadata.mediaType,
-                name: metadata.filename,
-            };
-        },
-    };
-    const adapter = {
-        name: "foundry",
-        live: opts.live !== false,
-        getCollectionOptions: (objectType) => {
-            if (opts.users?.objectType === objectType) {
-                return opts.users.getCollectionOptions(opts.client);
-            }
-            const objectTypeDef = opts.ir.objectTypes.find((ot) => ot.name === objectType);
-            return objectCollectionOptions({
-                client: opts.client,
-                objectType,
-                primaryKeyProperty: objectTypeDef.primaryKey,
-                selectedProperties: objectTypeDef.properties.map((property) => property.name),
-                live: opts.live,
-                decodeObject: (object) => codec.decodeObject(objectType, object),
-                decodeEditObject: (object) => codec.decodeEditObject(objectType, object),
-            });
-        },
-        validateAction: async (name, parameters) => {
-            const invocation = prepareFoundryActionInvocation({
-                ir: opts.ir,
-                name,
-                parameters,
-                codec,
-            });
-            let result;
-            try {
-                result = await Actions.applyWithOverrides(opts.client, opts.client.ontologyRid, toFoundryActionTypeName(name), {
-                    request: {
-                        options: {
-                            mode: "VALIDATE_ONLY",
-                        },
-                        parameters: invocation.parameters,
-                    },
-                    overrides: invocation.overrides,
-                }, 
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                {
-                    preview: true,
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                });
-            }
-            catch (error) {
-                if (isFoundryNotFoundError(error)) {
-                    throw new NonRetryableError(error instanceof Error ? error.message : "Foundry action target was not found.", { cause: error });
-                }
-                throw error;
-            }
-            if (!result.validation) {
-                throw new Error("Foundry validate action response did not include a validation result.");
-            }
-            return {
-                certain: true,
-                value: result.validation.result === "VALID"
-                    ? {
-                        kind: "ok",
-                        value: undefined,
-                    }
-                    : {
-                        kind: "err",
-                        value: getFoundryValidationIssues(result),
-                    },
-            };
-        },
-        validateActionDraft: async (name, parameters, live) => {
-            const actionType = opts.ir.actionTypes.find((candidate) => candidate.name === name);
-            if (!actionType) {
-                throw new NonRetryableError(`Unknown Foundry action type "${name}".`);
-            }
-            const knownParameters = new Set([
-                ...Object.entries(parameters).flatMap(([parameterName, value]) => value === undefined
-                    ? []
-                    : [parameterName]),
-                ...live.knownParameters,
-            ]);
-            const missingKnownRequiredParameters = actionType.parameters.filter((parameter) => parameters[parameter.name] === undefined &&
-                knownParameters.has(parameter.name) &&
-                !unwrapType(resolveType(opts.ir, parameter.type)).isOptional);
-            if (missingKnownRequiredParameters.length > 0) {
-                return certain({
-                    kind: "err",
-                    value: missingKnownRequiredParameters.map((parameter) => ({
-                        message: `Required action parameter "${parameter.name}" is missing.`,
-                        path: [parameter.name],
-                    })),
-                });
-            }
-            const hasUnknownParameters = actionType.parameters.some((parameter) => parameters[parameter.name] === undefined &&
-                !knownParameters.has(parameter.name));
-            if (!hasUnknownParameters) {
-                return adapter.validateAction(name, parameters, live);
-            }
-            const userId = typeof live.context?.user === "string"
-                ? live.context.user
-                : undefined;
-            if (!userId) {
-                return uncertain();
-            }
-            const criteria = await loadFoundrySubmissionCriteria({
-                client: opts.client,
-                actionTypeName: name,
-                userId,
-            });
-            return validateFoundryActionDraftCriteria({
-                client: opts.client,
-                criteria,
-                userId,
-                parameters,
-                knownParameters,
-            });
-        },
-        applyAction: async (name, parameters, context) => {
-            const mediaReferences = new Map();
-            const attachmentIdMappings = [];
-            await Promise.all([
-                ...new Map((context.attachmentUploads ?? []).map((upload) => [upload.attachment.id, upload])).values(),
-            ].map(async (upload) => {
-                invariant(getAttachmentProviderType(upload.target) === "media", `Foundry attachment "${upload.attachment.id}" was not materialized before action execution.`);
-                const reference = await MediaSets.uploadMedia(opts.client, upload.blob, {
-                    filename: getAttachmentName(upload.blob) ?? upload.attachment.id,
-                });
-                mediaReferences.set(upload.attachment.id, reference);
-                attachmentIdMappings.push({
-                    localId: upload.attachment.id,
-                    remoteId: mediaReferenceToFoundryMediaId(reference),
-                });
-            }));
-            const actionCodec = createFoundryCodec(opts.ir, {
-                resolveMediaReference: (id) => mediaReferences.get(id),
-            });
-            const invocation = prepareFoundryActionInvocation({
-                ir: opts.ir,
-                name,
-                parameters,
-                codec: actionCodec,
-            });
-            let result;
-            try {
-                result = await Actions.applyWithOverrides(opts.client, opts.client.ontologyRid, toFoundryActionTypeName(name), {
-                    request: {
-                        options: {
-                            mode: "VALIDATE_AND_EXECUTE",
-                            returnEdits: "ALL_V2_WITH_DELETIONS",
-                        },
-                        parameters: invocation.parameters,
-                    },
-                    overrides: invocation.overrides,
-                }, 
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                {
-                    preview: true,
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                });
-            }
-            catch (error) {
-                if (isFoundryNotFoundError(error)) {
-                    throw new NonRetryableError(error instanceof Error ? error.message : "Foundry action target was not found.", { cause: error });
-                }
-                throw error;
-            }
-            if (result.validation?.result === "INVALID") {
-                throw new NonRetryableError("Invalid Action arguments.");
-            }
-            if (opts.live !== false && context) {
-                const operationId = getApplyActionOperationId(result);
-                const editedObjectTypes = Array.from(getEditedObjectTypes(result.edits));
-                const targetCollections = editedObjectTypes
-                    .map((objectType) => context.objects[objectType])
-                    .filter((collection) => Boolean(collection?.utils?.awaitOperationId));
-                await Promise.all(targetCollections.map((collection) => collection.utils.awaitOperationId(operationId)));
-            }
-            if (attachmentIdMappings.length === 0) {
-                return undefined;
-            }
-            return {
-                attachmentIdMappings,
-            };
-        },
-        runQueryFunction: async (name, parameters) => {
-            const queryFunctionType = opts.ir.queryFunctionTypes.find((candidate) => candidate.name === name);
-            if (!queryFunctionType) {
-                throw new Error(`Unknown Foundry query function type "${name}".`);
-            }
-            const parameterTypes = new Map(queryFunctionType.parameters.map((parameter) => [parameter.name, parameter.type]));
-            const requestParameters = {};
-            for (const [parameterName, value] of Object.entries(parameters)) {
-                if (value === undefined)
-                    continue;
-                const parameterType = parameterTypes.get(parameterName);
-                requestParameters[parameterName] = parameterType
-                    ? codec.encodeValue(parameterType, value)
-                    : value;
-            }
-            const result = await Queries.execute(opts.client, opts.client.ontologyRid, name, {
-                parameters: requestParameters,
-            });
-            return codec.decodeValue(queryFunctionType.returnType, result.value);
-        },
-        attachments,
-    };
-    return adapter;
+function createFoundryOntologyBackendAdapter(opts) {
+	const codec = createFoundryCodec(opts.ir);
+	const adapter = {
+		name: "foundry",
+		live: opts.live !== false,
+		getCollectionOptions: (objectType) => {
+			if (opts.users?.objectType === objectType) return opts.users.getCollectionOptions(opts.client);
+			const objectTypeDef = opts.ir.objectTypes.find((ot) => ot.name === objectType);
+			return objectCollectionOptions({
+				client: opts.client,
+				objectType,
+				primaryKeyProperty: objectTypeDef.primaryKey,
+				selectedProperties: objectTypeDef.properties.map((property) => property.name),
+				live: opts.live,
+				decodeObject: (object) => codec.decodeObject(objectType, object),
+				decodeEditObject: (object) => codec.decodeEditObject(objectType, object)
+			});
+		},
+		validateAction: async (name, parameters) => {
+			const invocation = prepareFoundryActionInvocation({
+				ir: opts.ir,
+				name,
+				parameters,
+				codec
+			});
+			let result;
+			try {
+				result = await Actions.applyWithOverrides(opts.client, opts.client.ontologyRid, toFoundryActionTypeName(name), {
+					request: {
+						options: { mode: "VALIDATE_ONLY" },
+						parameters: invocation.parameters
+					},
+					overrides: invocation.overrides
+				}, { preview: true });
+			} catch (error) {
+				if (isFoundryNotFoundError(error)) throw new NonRetryableError(error instanceof Error ? error.message : "Foundry action target was not found.", { cause: error });
+				throw error;
+			}
+			if (!result.validation) throw new Error("Foundry validate action response did not include a validation result.");
+			return {
+				certain: true,
+				value: result.validation.result === "VALID" ? {
+					kind: "ok",
+					value: void 0
+				} : {
+					kind: "err",
+					value: getFoundryValidationIssues(result)
+				}
+			};
+		},
+		validateActionDraft: async (name, parameters, live) => {
+			const actionType = opts.ir.actionTypes.find((candidate) => candidate.name === name);
+			if (!actionType) throw new NonRetryableError(`Unknown Foundry action type "${name}".`);
+			const knownParameters = /* @__PURE__ */ new Set([...Object.entries(parameters).flatMap(([parameterName, value]) => value === void 0 ? [] : [parameterName]), ...live.knownParameters]);
+			const missingKnownRequiredParameters = actionType.parameters.filter((parameter) => parameters[parameter.name] === void 0 && knownParameters.has(parameter.name) && !unwrapType(resolveType(opts.ir, parameter.type)).isOptional);
+			if (missingKnownRequiredParameters.length > 0) return certain({
+				kind: "err",
+				value: missingKnownRequiredParameters.map((parameter) => ({
+					message: `Required action parameter "${parameter.name}" is missing.`,
+					path: [parameter.name]
+				}))
+			});
+			if (!actionType.parameters.some((parameter) => parameters[parameter.name] === void 0 && !knownParameters.has(parameter.name))) return adapter.validateAction(name, parameters, live);
+			const userId = typeof live.context?.user === "string" ? live.context.user : void 0;
+			if (!userId) return uncertain();
+			const criteria = await loadFoundrySubmissionCriteria({
+				client: opts.client,
+				actionTypeName: name,
+				userId
+			});
+			return validateFoundryActionDraftCriteria({
+				client: opts.client,
+				criteria,
+				userId,
+				parameters,
+				knownParameters
+			});
+		},
+		applyAction: async (name, parameters, context) => {
+			const mediaReferences = /* @__PURE__ */ new Map();
+			const attachmentIdMappings = [];
+			await Promise.all([...new Map((context.attachmentUploads ?? []).map((upload) => [upload.attachment.id, upload])).values()].map(async (upload) => {
+				invariant(getAttachmentProviderType(upload.target) === "media", `Foundry attachment "${upload.attachment.id}" was not materialized before action execution.`);
+				const reference = await MediaSets.uploadMedia(opts.client, upload.blob, { filename: getAttachmentName(upload.blob) ?? upload.attachment.id });
+				mediaReferences.set(upload.attachment.id, reference);
+				attachmentIdMappings.push({
+					localId: upload.attachment.id,
+					remoteId: mediaReferenceToFoundryMediaId(reference)
+				});
+			}));
+			const actionCodec = createFoundryCodec(opts.ir, { resolveMediaReference: (id) => mediaReferences.get(id) });
+			const invocation = prepareFoundryActionInvocation({
+				ir: opts.ir,
+				name,
+				parameters,
+				codec: actionCodec
+			});
+			let result;
+			try {
+				result = await Actions.applyWithOverrides(opts.client, opts.client.ontologyRid, toFoundryActionTypeName(name), {
+					request: {
+						options: {
+							mode: "VALIDATE_AND_EXECUTE",
+							returnEdits: "ALL_V2_WITH_DELETIONS"
+						},
+						parameters: invocation.parameters
+					},
+					overrides: invocation.overrides
+				}, { preview: true });
+			} catch (error) {
+				if (isFoundryNotFoundError(error)) throw new NonRetryableError(error instanceof Error ? error.message : "Foundry action target was not found.", { cause: error });
+				throw error;
+			}
+			if (result.validation?.result === "INVALID") throw new NonRetryableError("Invalid Action arguments.");
+			if (opts.live !== false && context) {
+				const operationId = getApplyActionOperationId(result);
+				const targetCollections = Array.from(getEditedObjectTypes(result.edits)).map((objectType) => context.objects[objectType]).filter((collection) => Boolean(collection?.utils?.awaitOperationId));
+				await Promise.all(targetCollections.map((collection) => collection.utils.awaitOperationId(operationId)));
+			}
+			if (attachmentIdMappings.length === 0) return;
+			return { attachmentIdMappings };
+		},
+		runQueryFunction: async (name, parameters) => {
+			const queryFunctionType = opts.ir.queryFunctionTypes.find((candidate) => candidate.name === name);
+			if (!queryFunctionType) throw new Error(`Unknown Foundry query function type "${name}".`);
+			const parameterTypes = new Map(queryFunctionType.parameters.map((parameter) => [parameter.name, parameter.type]));
+			const requestParameters = {};
+			for (const [parameterName, value] of Object.entries(parameters)) {
+				if (value === void 0) continue;
+				const parameterType = parameterTypes.get(parameterName);
+				requestParameters[parameterName] = parameterType ? codec.encodeValue(parameterType, value) : value;
+			}
+			const result = await Queries.execute(opts.client, opts.client.ontologyRid, name, { parameters: requestParameters });
+			return codec.decodeValue(queryFunctionType.returnType, result.value);
+		},
+		attachments: {
+			generateAttachmentId: (_, { target }) => {
+				invariant(target, "A property target must be passed to generateAttachmentId in the Foundry adapter so that we know whether to target attachments or media.");
+				if (getFoundryAttachmentKind(target.meta) === "attachment") return `ri.attachments.main.attachment.${crypto.randomUUID()}`;
+				return crypto.randomUUID();
+			},
+			canMaterializeAttachment: (_, { target }) => getAttachmentProviderType(target) !== "media",
+			materializeAttachment: async (attachment, blob, { target }) => {
+				invariant(target, "A property target must be passed to materializeAttachment in the Foundry adapter so that we know whether to target attachments or media.");
+				invariant(getAttachmentProviderType(target) === "attachment", "Foundry media references must be uploaded during action execution.");
+				const filename = getAttachmentName(blob) ?? "";
+				if (!isFoundryAttachmentRid(attachment.id)) {
+					const uploaded = await Attachments.upload(opts.client, blob, { filename });
+					return {
+						...attachment,
+						id: uploaded.rid
+					};
+				}
+				try {
+					await Attachments.get(opts.client, attachment.id);
+					return;
+				} catch (error) {
+					if (!isFoundryNotFoundError(error)) throw error;
+				}
+				await Attachments.uploadWithRid(opts.client, attachment.id, blob, {
+					filename,
+					preview: true
+				});
+			},
+			getAttachmentContent: async (attachment) => {
+				const userContent = await opts.users?.getAttachmentContent?.(opts.client, attachment);
+				if (userContent) return userContent;
+				if (decodeFoundryMediaId(attachment.id)) {
+					const source = attachment.source;
+					invariant(source, `Foundry media attachment "${attachment.id}" is missing its object property source.`);
+					return (await MediaReferenceProperties.getMediaContent(opts.client, opts.client.ontologyRid, source.objectType, String(source.primaryKey), source.property, { preview: true })).blob();
+				}
+				return (await Attachments.read(opts.client, attachment.id)).blob();
+			},
+			getAttachmentMetadata: async (attachment, selection) => {
+				const userMetadata = await opts.users?.getAttachmentMetadata?.(opts.client, attachment, selection);
+				if (userMetadata) return userMetadata;
+				const media = decodeFoundryMediaId(attachment.id);
+				if (media) {
+					const result = {};
+					if (attachment.type !== void 0) result.type = attachment.type;
+					if (selection.includes("dimensions")) {
+						const detailed = await MediaSets.metadata(opts.client, media.mediaSetRid, media.mediaItemRid);
+						result.size = detailed.sizeBytes;
+						if (detailed.type === "imagery" && detailed.dimensions) result.dimensions = {
+							width: detailed.dimensions.width,
+							height: detailed.dimensions.height
+						};
+					}
+					if (!selection.filter((field) => result[field] === void 0).some((field) => field !== "dimensions")) return result;
+					const source = attachment.source;
+					invariant(source, `Foundry media attachment "${attachment.id}" is missing its object property source.`);
+					const info = await MediaReferenceProperties.getMediaMetadata(opts.client, opts.client.ontologyRid, source.objectType, String(source.primaryKey), source.property, { preview: true });
+					return {
+						...result,
+						size: Number(info.sizeBytes),
+						type: info.mediaType,
+						name: info.path
+					};
+				}
+				const metadata = await Attachments.get(opts.client, attachment.id);
+				return {
+					id: attachment.id,
+					size: Number(metadata.sizeBytes),
+					type: metadata.mediaType,
+					name: metadata.filename
+				};
+			}
+		}
+	};
+	return adapter;
 }
-export function createFoundryOntologyBackend(opts) {
-    return async (ir, context) => createFoundryOntologyBackendAdapter({
-        ir,
-        client: "client" in opts ? opts.client : await opts.createClient(ir, context),
-        users: opts.users,
-        live: opts.live,
-    });
+function createFoundryOntologyBackend(opts) {
+	return async (ir, context) => createFoundryOntologyBackendAdapter({
+		ir,
+		client: "client" in opts ? opts.client : await opts.createClient(ir, context),
+		users: opts.users,
+		live: opts.live
+	});
 }
+//#endregion
+export { createFoundryOntologyBackend, createFoundryOntologyBackendAdapter, isFoundryNotFoundError };
+
 //# sourceMappingURL=createFoundryOntologyBackendAdapter.js.map