@fungi.computer/agar 0.0.0-stage → 0.0.1

package/dist/media.js

@@ -0,0 +1,654 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import * as z from "zod";
+import { defineCapability } from "./capabilities.js";
+import { rpcDataSchema, rpcHandleSchema, rpcMethod, rpcVoid, } from "./internal/rpc-contract.js";
+import * as Schema from "effect/Schema";
+export { mediaLibraryRequestSchema, mediaLibraryPathSchema, mediaLibraryResponseSchema, } from "./media-library.js";
+import { AppError } from "./errors.js";
+import { ownedRpcValue } from "./internal/capabilities.js";
+/** A decoded Media failure; null stage means the host could not identify it. */
+export class MediaGenerationError extends AppError {
+    stage;
+    constructor(failure) {
+        super(failure.message, {
+            code: failure.code,
+            retryable: failure.retryable,
+        });
+        this.stage = failure.stage ?? null;
+    }
+}
+/** One narrow Media capability: discover the retained catalog and generate. */
+const text = (maximum) => Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isMaxLength(maximum)));
+/** A replay identity, never an authorization capability. */
+export const mediaGenerationReferenceSchema = Schema.Struct({
+    requestId: text(256),
+    computerId: text(256),
+});
+const safeInteger = Schema.Number.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.makeFilter(Number.isSafeInteger, {
+    message: "Expected a safe integer",
+})));
+const positiveInteger = safeInteger.pipe(Schema.check(Schema.isGreaterThan(0)));
+const nonNegativeInteger = safeInteger.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)));
+/** Video frame/reference role, interpreted by the host's model catalog. */
+export const mediaVideoReferenceRoleSchema = Schema.Literals([
+    "first-frame",
+    "last-frame",
+    "reference",
+]);
+/** A supported wire resolution. The host refines it against the chosen model. */
+export const mediaVideoResolutionSchema = Schema.Literals([
+    "480p",
+    "720p",
+    "768p",
+    "1080p",
+    "4k",
+]);
+/** A supported wire aspect. The host refines it against the chosen model. */
+export const mediaVideoAspectRatioSchema = Schema.Literals([
+    "16:9",
+    "4:3",
+    "1:1",
+    "3:4",
+    "9:16",
+    "21:9",
+    "9:21",
+]);
+const referenceSchema = Schema.Struct({
+    path: text(4_096),
+    role: Schema.optional(mediaVideoReferenceRoleSchema),
+});
+/** Path-only video reference. The host supplies Computer authority. */
+export const mediaVideoReferenceSchema = Schema.Struct({
+    /** Computer-relative image path. */
+    path: text(4_096),
+    /** First frame, last frame or reference-image mode. */
+    role: mediaVideoReferenceRoleSchema,
+});
+const resultReferenceSchema = Schema.Struct({
+    computerId: text(256),
+    path: text(4_096),
+});
+const modelInputSchema = Schema.Struct({
+    defaultHeight: positiveInteger,
+    defaultSteps: Schema.NullOr(nonNegativeInteger),
+    defaultWidth: positiveInteger,
+    dimensions: Schema.Literals(["none", "own"]),
+    maxDimension: Schema.NullOr(positiveInteger),
+    maxReferences: nonNegativeInteger,
+    maxSteps: Schema.NullOr(positiveInteger),
+    referenceField: Schema.NullOr(text(256)),
+    steps: Schema.Literals(["steps", "num_steps", "fixed"]),
+    transport: Schema.Literals(["json", "multipart"]),
+});
+/** Host-described video capabilities and costs. This is wire grammar, not a catalog. */
+export const mediaVideoModelSchema = Schema.Struct({
+    /** Smallest duration; the durations list owns exact membership. */
+    minSeconds: positiveInteger,
+    /** Largest duration. */
+    maxSeconds: positiveInteger,
+    /** Default whole seconds. */
+    defaultSeconds: positiveInteger,
+    /** Exact admitted duration values. */
+    durations: Schema.Array(positiveInteger),
+    /** Provider translation family. */
+    provider: Schema.Literals(["seedance", "veo", "minimax"]),
+    /** Resolution/aspect selectors and nominal dimensions. */
+    formats: Schema.Array(Schema.Struct({
+        /** Provider resolution selector. */
+        resolution: mediaVideoResolutionSchema,
+        /** Requested aspect selector. */
+        aspectRatio: mediaVideoAspectRatioSchema,
+        /** Nominal width, not measured MP4 dimensions. */
+        width: positiveInteger,
+        /** Nominal height, not measured MP4 dimensions. */
+        height: positiveInteger,
+    })),
+    /** Default resolution. */
+    defaultResolution: mediaVideoResolutionSchema,
+    /** Default requested aspect. */
+    defaultAspectRatio: mediaVideoAspectRatioSchema,
+    /** Audio default, or null when the provider default is undocumented. */
+    defaultGenerateAudio: Schema.NullOr(Schema.Boolean),
+    /** Host/provider prompt bound. */
+    maxPromptLength: positiveInteger,
+    /** Roles admitted by this model. */
+    referenceRoles: Schema.Array(mediaVideoReferenceRoleSchema),
+    /** Maximum images in reference-image mode. */
+    maxReferenceImages: nonNegativeInteger,
+    /** Resolutions admitting reference-image mode. */
+    referenceResolutions: Schema.Array(mediaVideoResolutionSchema),
+    /** Host-described costs, where 1 USD is 100,000 milliunits. */
+    prices: Schema.Array(Schema.Struct({
+        /** Billed provider resolution. */
+        resolution: mediaVideoResolutionSchema,
+        /** Provider milliunits per silent output second. */
+        silentMilliunitsPerSecond: positiveInteger,
+        /** Provider milliunits per output second with audio. */
+        audioMilliunitsPerSecond: positiveInteger,
+    })),
+});
+/** Validates one model row of the host's Media catalog. */
+export const mediaModelSchema = Schema.Struct({
+    id: text(256),
+    input: modelInputSchema,
+    kind: Schema.Literals(["image", "video"]),
+    label: text(512),
+    tier: Schema.Literals(["draft", "balanced", "premium", "max"]),
+    outputFormats: Schema.Array(Schema.Literals(["png", "jpeg", "webp"])).pipe(Schema.check(Schema.isMaxLength(3))),
+    sizes: Schema.NullOr(Schema.Array(Schema.String.pipe(Schema.check(Schema.isPattern(/^\d+x\d+$/u))))),
+    video: Schema.NullOr(mediaVideoModelSchema),
+});
+const modelsSchema = Schema.Array(mediaModelSchema);
+const descriptionSchema = Schema.Struct({
+    [Symbol.dispose]: Schema.optional(Schema.Unknown),
+    computerId: text(256),
+    models: modelsSchema,
+    canGenerate: Schema.Boolean,
+});
+/** The most reference images one generation request may name. */
+export const MAX_MEDIA_REFERENCES = 4;
+/**
+ * Validates the shape of an App's generation settings. Model-specific limits
+ * (sizes, steps, durations, reference counts) and defaults are the host's:
+ * it checks the selection against its catalog when it accepts a generation.
+ */
+export const mediaGenerationSelectionSchema = Schema.Struct({
+    model: text(256),
+    prompt: text(2_048),
+    width: positiveInteger.pipe(Schema.check(Schema.isLessThanOrEqualTo(5_040))),
+    height: positiveInteger.pipe(Schema.check(Schema.isLessThanOrEqualTo(5_040))),
+    steps: Schema.optional(positiveInteger),
+    durationSeconds: Schema.optional(positiveInteger),
+    resolution: Schema.optional(mediaVideoResolutionSchema),
+    aspectRatio: Schema.optional(mediaVideoAspectRatioSchema),
+    generateAudio: Schema.optional(Schema.Boolean),
+    references: Schema.optional(Schema.Array(referenceSchema).pipe(Schema.check(Schema.isMaxLength(MAX_MEDIA_REFERENCES)))),
+});
+/** Path-only video selection. Model defaults and combination refinements remain host-owned. */
+export const mediaVideoSelectionSchema = Schema.Struct({
+    /** Host catalog model identifier. */
+    model: text(256),
+    /** Host-bounded prompt. */
+    prompt: text(2_048),
+    /** Optional provider resolution selector. */
+    resolution: Schema.optional(mediaVideoResolutionSchema),
+    /** Optional requested aspect selector. */
+    aspectRatio: Schema.optional(mediaVideoAspectRatioSchema),
+    /** Whole seconds, 4 through 15; the host checks exact model membership. */
+    durationSeconds: Schema.optional(positiveInteger.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(4)), Schema.check(Schema.isLessThanOrEqualTo(15)))),
+    /** Explicit audio choice. The host owns omitted defaults. */
+    generateAudio: Schema.optional(Schema.Boolean),
+    /** At most four paths with explicit frame/reference roles. */
+    references: Schema.optional(Schema.Array(mediaVideoReferenceSchema).pipe(Schema.check(Schema.isMaxLength(MAX_MEDIA_REFERENCES)))),
+});
+/** Public diagnostic stages a host may name when a generation fails. */
+export const mediaFailureStages = [
+    "admission",
+    "generation-authorization",
+    "settings",
+    "estimate",
+    "billing",
+    "operation",
+    "provider",
+    "normalization",
+    "artifact",
+    "destination-authorization",
+    "destination-write",
+];
+/** Validates a generation input envelope; settings are parsed separately. */
+export const mediaGenerationInputWireSchema = Schema.Struct({
+    destination: Schema.Struct({ path: text(4_096) }),
+    settings: Schema.Unknown,
+});
+/** Completed image or video metadata saved to a host-admitted destination. */
+export const mediaGenerationResultSchema = Schema.Struct({
+    // Cap'n Web decorates returned object envelopes with a disposal owner.
+    [Symbol.dispose]: Schema.optional(Schema.Unknown),
+    bytes: positiveInteger,
+    costMilliunits: nonNegativeInteger,
+    destination: resultReferenceSchema,
+    format: Schema.Literals(["png", "jpeg", "gif", "webp", "mp4"]),
+    height: positiveInteger,
+    model: text(256),
+    width: positiveInteger,
+});
+/** Completed native MEDIA video result, with a host-admitted destination. */
+export const mediaVideoResultSchema = Schema.Struct({
+    ...mediaGenerationResultSchema.fields,
+    /** Bounded fetched video encoding. */
+    format: Schema.Literal("mp4"),
+});
+/** Validates the typed failure a host reports for a generation attempt. */
+export const mediaGenerationFailureSchema = Schema.Struct({
+    message: text(512),
+    stage: Schema.optional(Schema.Literals(mediaFailureStages)),
+    code: Schema.Literals([
+        "CANCELLED",
+        "CAPABILITY_DENIED",
+        "CAPABILITY_REVOKED",
+        "DISCONNECTED",
+        "HOST_FAILURE",
+        "IDENTITY",
+        "INSUFFICIENT_CREDIT",
+        "INVALID_ARGUMENT",
+        "PROTOCOL",
+        "SAFETY_FILTER_REFUSED",
+        "TIMEOUT",
+    ]),
+    retryable: Schema.Boolean,
+});
+const outcomeSchema = Schema.Union([
+    Schema.Struct({
+        [Symbol.dispose]: Schema.optional(Schema.Unknown),
+        kind: Schema.Literal("succeeded"),
+        result: mediaGenerationResultSchema,
+    }),
+    Schema.Struct({
+        [Symbol.dispose]: Schema.optional(Schema.Unknown),
+        kind: Schema.Literal("failed"),
+        failure: mediaGenerationFailureSchema,
+    }),
+]);
+const mediaAttemptHandleSchema = rpcHandleSchema({
+    reference: rpcMethod(rpcDataSchema(z
+        .unknown()
+        .transform((value) => Schema.decodeUnknownSync(mediaGenerationReferenceSchema)(value)))),
+    generate: rpcMethod(rpcDataSchema(z.unknown().transform((value) => {
+        const outcome = Schema.decodeUnknownSync(outcomeSchema, {
+            onExcessProperty: "error",
+        })(value);
+        return outcome.kind === "succeeded"
+            ? {
+                kind: outcome.kind,
+                result: {
+                    bytes: outcome.result.bytes,
+                    costMilliunits: outcome.result.costMilliunits,
+                    destination: outcome.result.destination,
+                    format: outcome.result.format,
+                    height: outcome.result.height,
+                    model: outcome.result.model,
+                    width: outcome.result.width,
+                },
+            }
+            : { kind: outcome.kind, failure: outcome.failure };
+    }))),
+});
+/** Capability contract for generating Media (images or video). Apps
+ * declare it to request access; openMediaGeneration uses it to obtain
+ * the host's handle. */
+export const mediaGeneration = defineCapability("media.generation", 5, rpcHandleSchema({
+    describe: rpcMethod(rpcDataSchema(z.unknown().transform((value) => {
+        const { computerId, canGenerate, models } = Schema.decodeUnknownSync(descriptionSchema, {
+            onExcessProperty: "error",
+        })(value);
+        return { computerId, canGenerate, models };
+    }))),
+    createAttempt: rpcMethod(mediaAttemptHandleSchema),
+    restoreAttempt: rpcMethod(mediaAttemptHandleSchema),
+    cancelAttempt: rpcVoid,
+}));
+/** Parse a value received from the host and turn schema failures into the
+ * transport-safe Agar error used by the other capability helpers. */
+function decode(schema, value) {
+    try {
+        return Schema.decodeUnknownSync(schema, {
+            onExcessProperty: "error",
+        })(value);
+    }
+    catch (cause) {
+        throw new AppError("The Media capability returned malformed data", {
+            cause,
+            code: "PROTOCOL",
+            retryable: false,
+        });
+    }
+}
+function capabilityFailure(cause) {
+    if (cause instanceof AppError)
+        return cause;
+    return new AppError("The Media capability failed", {
+        cause,
+        code: "HOST_FAILURE",
+        retryable: true,
+    });
+}
+function throwIfCancelled(signal) {
+    if (!signal?.aborted)
+        return;
+    throw new AppError("Media generation was cancelled", {
+        code: "CANCELLED",
+        retryable: false,
+    });
+}
+/** Decode and normalize a typed input envelope; storage parses the envelope first. */
+export function parseMediaGenerationInput(input) {
+    let parsed;
+    try {
+        parsed = Schema.decodeUnknownSync(mediaGenerationInputWireSchema, {
+            onExcessProperty: "error",
+        })(input);
+    }
+    catch (cause) {
+        throw new AppError("Media generation input is invalid", {
+            cause,
+            code: "INVALID_ARGUMENT",
+            retryable: false,
+        });
+    }
+    let settings;
+    try {
+        settings = normalizeSelection(Schema.decodeUnknownSync(mediaGenerationSelectionSchema, {
+            onExcessProperty: "error",
+        })(parsed.settings));
+    }
+    catch (cause) {
+        throw new AppError("Media generation settings are invalid", {
+            cause,
+            code: "INVALID_ARGUMENT",
+            retryable: false,
+        });
+    }
+    const destination = { path: parsed.destination.path.trim() };
+    if (destination.path.length === 0)
+        throw new AppError("Media generation destination is invalid", {
+            code: "INVALID_ARGUMENT",
+            retryable: false,
+        });
+    return Object.freeze({
+        destination: Object.freeze(destination),
+        settings,
+    });
+}
+/** Trim the text fields the host compares; blank text is invalid. */
+function normalizeSelection(selection) {
+    const trimmed = (value, name) => {
+        const result = value.trim();
+        if (result.length === 0)
+            throw new Error(`${name} must not be blank`);
+        return result;
+    };
+    const normalized = {
+        model: trimmed(selection.model, "model"),
+        prompt: trimmed(selection.prompt, "prompt"),
+        width: selection.width,
+        height: selection.height,
+    };
+    if (selection.steps !== undefined)
+        normalized.steps = selection.steps;
+    if (selection.durationSeconds !== undefined)
+        normalized.durationSeconds = selection.durationSeconds;
+    if (selection.resolution !== undefined)
+        normalized.resolution = selection.resolution;
+    if (selection.aspectRatio !== undefined)
+        normalized.aspectRatio = selection.aspectRatio;
+    if (selection.generateAudio !== undefined)
+        normalized.generateAudio = selection.generateAudio;
+    if (selection.references !== undefined)
+        normalized.references = Object.freeze(selection.references.map((reference) => Object.freeze({
+            ...reference,
+            path: trimmed(reference.path, "reference"),
+        })));
+    return Object.freeze(normalized);
+}
+/** The host owns the catalog; Agar checks only its shape and identity. */
+function parseModels(value) {
+    const models = decode(modelsSchema, value);
+    const seen = new Set();
+    for (const model of models) {
+        if (seen.has(model.id))
+            throw new AppError("The Media capability repeated a model", {
+                code: "PROTOCOL",
+                retryable: false,
+            });
+        seen.add(model.id);
+    }
+    return Object.freeze(models.map((model) => Object.freeze(model)));
+}
+function parseResult(value, request, computerId) {
+    const result = decode(mediaGenerationResultSchema, value);
+    if (result.model !== request.settings.model ||
+        result.destination.computerId !== computerId ||
+        result.destination.path !== request.destination.path ||
+        result.width !== request.settings.width ||
+        result.height !== request.settings.height)
+        throw new AppError("The Media capability returned an unrelated result", {
+            code: "PROTOCOL",
+            retryable: false,
+        });
+    return Object.freeze({
+        bytes: result.bytes,
+        costMilliunits: result.costMilliunits,
+        destination: Object.freeze({ ...result.destination }),
+        format: result.format,
+        height: result.height,
+        model: result.model,
+        width: result.width,
+    });
+}
+/** Discover the exact retained model catalog surfaced by the owner. */
+export async function openMediaGeneration(capabilities) {
+    try {
+        const handle = capabilities.require(mediaGeneration);
+        {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const response = __addDisposableResource(env_1, ownedRpcValue(await handle.describe()), false);
+                const description = decode(descriptionSchema, response.value);
+                const computerId = description.computerId.trim();
+                if (computerId.length === 0)
+                    throw new AppError("The Media capability returned no Computer", {
+                        code: "PROTOCOL",
+                        retryable: false,
+                    });
+                const models = parseModels(description.models);
+                const wrapAttempt = async (remote) => {
+                    const owner = ownedRpcValue(remote);
+                    let reference;
+                    try {
+                        {
+                            const env_2 = { stack: [], error: void 0, hasError: false };
+                            try {
+                                const response = __addDisposableResource(env_2, ownedRpcValue(await remote.reference()), false);
+                                const parsed = decode(Schema.Struct({
+                                    ...mediaGenerationReferenceSchema.fields,
+                                    [Symbol.dispose]: Schema.optional(Schema.Unknown),
+                                }), response.value);
+                                reference = {
+                                    requestId: parsed.requestId,
+                                    computerId: parsed.computerId,
+                                };
+                                if (reference.computerId !== computerId)
+                                    throw new AppError("Media attempt belongs to another Computer", {
+                                        code: "IDENTITY",
+                                        retryable: false,
+                                    });
+                            }
+                            catch (e_2) {
+                                env_2.error = e_2;
+                                env_2.hasError = true;
+                            }
+                            finally {
+                                __disposeResources(env_2);
+                            }
+                        }
+                    }
+                    catch (cause) {
+                        owner[Symbol.dispose]();
+                        throw capabilityFailure(cause);
+                    }
+                    let disposed = false;
+                    return {
+                        reference: Object.freeze(reference),
+                        async generate(input, options = {}) {
+                            if (disposed)
+                                throw new AppError("Media generation attempt is closed", {
+                                    code: "CAPABILITY_DENIED",
+                                    retryable: false,
+                                });
+                            throwIfCancelled(options.signal);
+                            const request = parseMediaGenerationInput(input);
+                            const signal = options.signal;
+                            let onAbort;
+                            let cancellation;
+                            const requestCancellation = () => {
+                                cancellation ??= handle.cancelAttempt(reference);
+                                return cancellation;
+                            };
+                            try {
+                                const generation = remote.generate(request);
+                                const response = signal === undefined
+                                    ? await generation
+                                    : await Promise.race([
+                                        generation,
+                                        new Promise((_resolve, reject) => {
+                                            onAbort = () => {
+                                                void requestCancellation().then(() => {
+                                                    reject(new AppError("Media generation was cancelled", {
+                                                        code: "CANCELLED",
+                                                        retryable: false,
+                                                    }));
+                                                }, reject);
+                                            };
+                                            signal.addEventListener("abort", onAbort, {
+                                                once: true,
+                                            });
+                                            if (signal.aborted)
+                                                onAbort();
+                                        }),
+                                    ]);
+                                if (signal?.aborted) {
+                                    await requestCancellation();
+                                    throwIfCancelled(signal);
+                                }
+                                throwIfCancelled(signal);
+                                {
+                                    const env_3 = { stack: [], error: void 0, hasError: false };
+                                    try {
+                                        const owned = __addDisposableResource(env_3, ownedRpcValue(response), false);
+                                        const outcome = decode(outcomeSchema, owned.value);
+                                        if (outcome.kind === "failed")
+                                            throw new MediaGenerationError(outcome.failure);
+                                        return parseResult(outcome.result, request, computerId);
+                                    }
+                                    catch (e_3) {
+                                        env_3.error = e_3;
+                                        env_3.hasError = true;
+                                    }
+                                    finally {
+                                        __disposeResources(env_3);
+                                    }
+                                }
+                            }
+                            catch (cause) {
+                                if (signal?.aborted) {
+                                    await requestCancellation();
+                                    throwIfCancelled(signal);
+                                }
+                                throw capabilityFailure(cause);
+                            }
+                            finally {
+                                if (onAbort !== undefined)
+                                    signal?.removeEventListener("abort", onAbort);
+                            }
+                        },
+                        [Symbol.dispose]() {
+                            if (disposed)
+                                return;
+                            disposed = true;
+                            owner[Symbol.dispose]();
+                        },
+                    };
+                };
+                return Object.freeze({
+                    computerId,
+                    canGenerate: description.canGenerate,
+                    models,
+                    /** Start a fresh attempt scoped to this session's Computer. */
+                    async createAttempt() {
+                        return wrapAttempt(await handle.createAttempt());
+                    },
+                    /** Resume an attempt using a reference returned earlier in this
+                     * session; the reference must match this session's Computer. */
+                    async restoreAttempt(reference) {
+                        const parsed = decode(mediaGenerationReferenceSchema, reference);
+                        if (parsed.computerId !== computerId)
+                            throw new AppError("Select the original Computer to retry this generation", {
+                                code: "IDENTITY",
+                                retryable: false,
+                            });
+                        const attempt = await wrapAttempt(await handle.restoreAttempt(parsed));
+                        if (attempt.reference.requestId !== parsed.requestId) {
+                            attempt[Symbol.dispose]();
+                            throw new AppError("Media restore changed the request identity", {
+                                code: "PROTOCOL",
+                                retryable: false,
+                            });
+                        }
+                        return attempt;
+                    },
+                });
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                __disposeResources(env_1);
+            }
+        }
+    }
+    catch (cause) {
+        throw capabilityFailure(cause);
+    }
+}