@byteplus-iga-pages/agent 0.0.0-stage → 1.0.3

package/dist/cjs/647.js

@@ -0,0 +1,1367 @@
+"use strict";
+exports.ids = [
+    "647"
+];
+exports.modules = {
+    "../sandbox/src/api-client.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            K: ()=>SandboxApi,
+            SW: ()=>createSandboxApi,
+            ip: ()=>isConfirmedMissingInstanceResponse
+        });
+        var node_https__rspack_import_0 = __webpack_require__("node:https");
+        var node_https__rspack_import_0_default = /*#__PURE__*/ __webpack_require__.n(node_https__rspack_import_0);
+        var _iga_pages_data_plane__rspack_import_1 = __webpack_require__("../data-plane/dist/esm/index.js");
+        var axios__rspack_import_4 = __webpack_require__("../../node_modules/.pnpm/axios@1.20.0/node_modules/axios/lib/axios.js");
+        var _error_js__rspack_import_3 = __webpack_require__("../sandbox/src/error.ts");
+        var _agent_infra_sandbox__rspack_import_2 = __webpack_require__("../../node_modules/.pnpm/@agent-infra+sandbox@1.0.17/node_modules/@agent-infra/sandbox/dist/esm/index.mjs");
+        function createSandboxApi(opts) {
+            return new SandboxApi(opts.apiBaseUrl, opts.apiToken);
+        }
+        class SandboxApi {
+            resolveBaseUrl() {
+                if (this.baseUrl) return this.baseUrl.replace(/\/+$/, "");
+                throw new _error_js__rspack_import_3.ES("Sandbox API base URL is not configured. Pass apiBaseUrl in createSandbox options.");
+            }
+            async getToken(opts = {}) {
+                const url = `${this.resolveBaseUrl()}/pages/v1/api/sandbox-token`;
+                const raw = await this.postJson(url, opts, {});
+                if (!raw.ApiKey) throw new _error_js__rspack_import_3.ES("Sandbox credentials could not be initialized.");
+                return {
+                    apiKey: raw.ApiKey,
+                    sandboxAppId: raw.SandboxAppID,
+                    url: raw.Url,
+                    tokenType: raw.TokenType,
+                    tokenHeader: raw.TokenHeader
+                };
+            }
+            async create(opts) {
+                const url = `${this.resolveBaseUrl()}/pages/v1/api/sandbox/create`;
+                const raw = await this.postJson(url, opts, {
+                    ProjectID: opts.projectId
+                });
+                if (!raw.SandboxId) throw new _error_js__rspack_import_3.ES("The sandbox could not be created because the service returned an invalid response.");
+                return {
+                    sandboxId: raw.SandboxId
+                };
+            }
+            async destroy(opts) {
+                const url = `${this.resolveBaseUrl()}/pages/v1/api/sandbox/destroy`;
+                await this.postJson(url, opts, {
+                    ProjectID: opts.projectId,
+                    SandboxID: opts.sandboxId
+                });
+                return {
+                    ok: true
+                };
+            }
+            async getInstance(opts) {
+                const url = `${this.resolveBaseUrl()}/pages/v1/api/sandbox/instance`;
+                let raw;
+                try {
+                    raw = await this.postJson(url, opts, {
+                        ProjectID: opts.projectId,
+                        SandboxID: opts.sandboxId
+                    });
+                } catch (error) {
+                    if (error instanceof _error_js__rspack_import_3.ES && 200 === error.status && await this.confirmMissingViaDataPlane(opts)) throw new _error_js__rspack_import_3.YA("The sandbox was not found.", {
+                        status: 404
+                    });
+                    if (opts.signal?.aborted) throw new _error_js__rspack_import_3.sX("The sandbox request was cancelled.");
+                    throw error;
+                }
+                if (!raw || "object" != typeof raw || "string" != typeof raw.SandboxID) throw new _error_js__rspack_import_3.ES("Sandbox instance query returned an invalid response.");
+                return {
+                    sandboxId: raw.SandboxID ?? "",
+                    expireAt: raw.ExpireAt,
+                    createdAt: raw.CreatedAt,
+                    status: normalizeInstanceStatus(raw.Status)
+                };
+            }
+            async confirmInstanceExists(opts) {
+                const info = await this.getInstance(opts);
+                if (!info.sandboxId) throw sandboxNotFoundError();
+                if (info.sandboxId !== opts.sandboxId) throw new _error_js__rspack_import_3.ES("Sandbox instance query returned a different instance.");
+                if ("Failed" === info.status || "Terminating" === info.status) throw sandboxNotFoundError();
+            }
+            async confirmMissingViaDataPlane(opts) {
+                try {
+                    const token = await this.getToken({
+                        signal: opts.signal
+                    });
+                    if (!token.url) return false;
+                    const client = new _agent_infra_sandbox__rspack_import_2.VF({
+                        environment: token.url,
+                        timeoutInSeconds: 10,
+                        headers: {
+                            [token.tokenHeader ?? "Authorization"]: `${token.tokenType ?? "Bearer"} ${token.apiKey}`,
+                            "x-faas-instance-name": opts.sandboxId
+                        }
+                    });
+                    const result = await client.file.listPath({
+                        path: "/"
+                    }, {
+                        abortSignal: opts.signal
+                    });
+                    return isConfirmedMissingInstanceResponse(result);
+                } catch  {
+                    return false;
+                }
+            }
+            async updateInstanceTimeout(opts) {
+                const url = `${this.resolveBaseUrl()}/pages/v1/api/sandbox/instance/update`;
+                let raw;
+                try {
+                    raw = await this.postJson(url, opts, {
+                        ProjectID: opts.projectId,
+                        SandboxID: opts.sandboxId,
+                        Time: opts.timeoutInMinutes
+                    });
+                } catch (error) {
+                    if (error instanceof _error_js__rspack_import_3.ES && 200 === error.status) try {
+                        await this.confirmInstanceExists(opts);
+                    } catch (confirmation) {
+                        if (confirmation instanceof _error_js__rspack_import_3.YA) throw confirmation;
+                    }
+                    if (opts.signal?.aborted) throw new _error_js__rspack_import_3.sX("The sandbox request was cancelled.");
+                    throw error;
+                }
+                return {
+                    sandboxId: raw.SandboxID ?? "",
+                    expireAt: raw.ExpireAt,
+                    createdAt: raw.CreatedAt,
+                    status: normalizeInstanceStatus(raw.Status)
+                };
+            }
+            async postJson(url, opts, body) {
+                if (!this.token) throw new _error_js__rspack_import_3.ES("Sandbox API token is not configured.");
+                const timestamp = String(this.now());
+                const endpoint = new URL(url);
+                endpoint.searchParams.set("timestamp", timestamp);
+                endpoint.searchParams.set("token", this.token);
+                const requestUrl = endpoint.toString();
+                let resp;
+                try {
+                    resp = await this.http.post(requestUrl, body, {
+                        signal: opts.signal,
+                        headers: (0, _iga_pages_data_plane__rspack_import_1.uQ)()
+                    });
+                } catch (err) {
+                    if (axios__rspack_import_4.A.isCancel(err) || err?.name === "CanceledError") throw new _error_js__rspack_import_3.sX("The sandbox request was cancelled.");
+                    const response = err && "object" == typeof err ? err.response : void 0;
+                    throw new _error_js__rspack_import_3.ES("The sandbox service is temporarily unavailable.", {
+                        status: response?.status
+                    });
+                }
+                if (resp.status < 200 || resp.status >= 300) throw controlPlaneHttpError({
+                    status: resp.status,
+                    responseBody: resp.data,
+                    token: this.token,
+                    instanceEndpoint: isInstanceQueryEndpoint(url)
+                });
+                return unwrapEnvelope(resp.data, {
+                    status: resp.status,
+                    token: this.token
+                });
+            }
+            constructor(baseUrl, token, now = Date.now){
+                this.baseUrl = baseUrl;
+                this.token = token;
+                this.now = now;
+                this.http = axios__rspack_import_4.A.create({
+                    headers: {
+                        "Content-Type": "application/json"
+                    },
+                    timeout: 30000,
+                    validateStatus: ()=>true,
+                    httpsAgent: new (node_https__rspack_import_0_default()).Agent({
+                        keepAlive: true,
+                        timeout: 30000
+                    })
+                });
+            }
+        }
+        function isInstanceQueryEndpoint(url) {
+            return /\/pages\/v1\/api\/sandbox\/(instance|destroy)/.test(url);
+        }
+        function normalizeInstanceStatus(value) {
+            if ("Starting" === value || "Ready" === value || "Failed" === value || "Terminating" === value) return value;
+            if (void 0 !== value) throw new _error_js__rspack_import_3.ES("Sandbox returned an unknown instance status.");
+        }
+        function unwrapEnvelope(data, context) {
+            if (data && "object" == typeof data && "code" in data) {
+                const envelope = data;
+                if ("number" == typeof envelope.code || "string" == typeof envelope.code) {
+                    if (0 !== envelope.code && "0" !== envelope.code) throw new _error_js__rspack_import_3.ES(controlPlaneMessage(data, context.token), {
+                        status: context.status
+                    });
+                    if (void 0 !== envelope.data) return envelope.data;
+                }
+            }
+            return data;
+        }
+        function controlPlaneHttpError(input) {
+            const options = {
+                status: input.status
+            };
+            const message = controlPlaneMessage(input.responseBody, input.token);
+            if ((404 === input.status || 410 === input.status) && input.instanceEndpoint) return new _error_js__rspack_import_3.YA(message, options);
+            return new _error_js__rspack_import_3.ES(message, options);
+        }
+        function controlPlaneMessage(body, token) {
+            const record = body && "object" == typeof body ? body : void 0;
+            const value = "string" == typeof record?.message && record.message.trim() ? record.message : "string" == typeof record?.error && record.error.trim() ? record.error : "The sandbox request could not be completed.";
+            let message = token ? value.split(token).join("[redacted]") : value;
+            message = message.replace(/\bBearer\s+[A-Za-z0-9._~+\/-]+=*/gi, "Bearer [redacted]").replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g, "[redacted]").replace(/([?&](?:access[_-]?token|api[_-]?key|key|token|signature|credential|auth|password|secret)\s*=)[^&#\s]*/gi, "$1[redacted]").replace(/([a-z][a-z0-9+.-]*:\/\/)[^@\s/]+@/gi, "$1[redacted]@").replace(/\b(token|authorization|password|secret|api[_-]?key|credential|signature)\b\s*[:=]\s*(?:"[^"]*"|'[^']*'|[^\s,;]+)/gi, "$1=[redacted]");
+            return message;
+        }
+        function sandboxNotFoundError() {
+            return new _error_js__rspack_import_3.YA("The sandbox was not found.");
+        }
+        function isConfirmedMissingInstanceResponse(value) {
+            if (!value || "object" != typeof value) return false;
+            const result = value;
+            const content = result.error?.content;
+            return false === result.ok && content?.reason === "status-code" && 404 === content.statusCode && content.body?.error_code === "instance_not_found";
+        }
+    },
+    "../sandbox/src/binding-repository.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            P: ()=>createRuntimeSandboxBindingRepository,
+            t: ()=>SupabaseSandboxBindingRepository
+        });
+        var node_crypto__rspack_import_0 = __webpack_require__("node:crypto");
+        var _iga_pages_data_plane__rspack_import_1 = __webpack_require__("../data-plane/dist/esm/index.js");
+        var _error_js__rspack_import_2 = __webpack_require__("../sandbox/src/error.ts");
+        function unavailable(_operation, _requestId, status) {
+            return new _error_js__rspack_import_2.ES("Sandbox session persistence is temporarily unavailable.", {
+                status
+            });
+        }
+        function asRecord(value, operation) {
+            const normalized = Array.isArray(value) && 1 === value.length ? value[0] : value;
+            if (!normalized || "object" != typeof normalized || Array.isArray(normalized)) throw new _error_js__rspack_import_2.ES("Sandbox persistence returned an invalid response.");
+            return normalized;
+        }
+        function requiredString(record, key, operation) {
+            const value = record[key];
+            if ("string" != typeof value || !value) throw new _error_js__rspack_import_2.ES("Sandbox persistence returned an invalid response.");
+            return value;
+        }
+        function requiredGeneration(record, operation) {
+            const value = Number(record.generation);
+            if (!Number.isSafeInteger(value) || value < 1) throw new _error_js__rspack_import_2.ES("Sandbox persistence returned an invalid response.");
+            return value;
+        }
+        class SupabaseSandboxBindingRepository {
+            async acquire(conversationId, leaseToken, signal) {
+                const operation = "sandbox.binding.acquire";
+                const record = asRecord(await this.rpc("sandbox_binding_acquire", {
+                    p_conversation_id: conversationId,
+                    p_lease_token: leaseToken,
+                    p_lease_seconds: this.leaseSeconds
+                }, operation, signal), operation);
+                const action = requiredString(record, "action", operation);
+                const generation = requiredGeneration(record, operation);
+                if ("attach" === action) return {
+                    action,
+                    generation,
+                    sandboxId: requiredString(record, "sandbox_id", operation)
+                };
+                if ("create" === action || "wait" === action) return {
+                    action,
+                    generation,
+                    leaseExpiresAt: requiredString(record, "lease_expires_at", operation)
+                };
+                throw new _error_js__rspack_import_2.ES("Sandbox persistence returned an invalid response.");
+            }
+            async publish(conversationId, generation, leaseToken, sandboxId, signal) {
+                return this.booleanRpc("sandbox_binding_publish", {
+                    p_conversation_id: conversationId,
+                    p_generation: generation,
+                    p_lease_token: leaseToken,
+                    p_sandbox_id: sandboxId
+                }, "sandbox.binding.publish", signal);
+            }
+            async release(conversationId, generation, leaseToken, signal) {
+                await this.booleanRpc("sandbox_binding_release", {
+                    p_conversation_id: conversationId,
+                    p_generation: generation,
+                    p_lease_token: leaseToken
+                }, "sandbox.binding.release", signal);
+            }
+            invalidate(conversationId, generation, sandboxId, signal) {
+                return this.booleanRpc("sandbox_binding_invalidate", {
+                    p_conversation_id: conversationId,
+                    p_generation: generation,
+                    p_sandbox_id: sandboxId
+                }, "sandbox.binding.invalidate", signal);
+            }
+            async beginDestroy(conversationId, leaseToken, signal) {
+                const operation = "sandbox.binding.beginDestroy";
+                const record = asRecord(await this.rpc("sandbox_binding_begin_destroy", {
+                    p_conversation_id: conversationId,
+                    p_lease_token: leaseToken,
+                    p_lease_seconds: this.leaseSeconds
+                }, operation, signal), operation);
+                const action = requiredString(record, "action", operation);
+                if ("none" === action) return {
+                    action
+                };
+                if ("wait" === action) return {
+                    action,
+                    leaseExpiresAt: requiredString(record, "lease_expires_at", operation)
+                };
+                if ("destroy" === action) return {
+                    action,
+                    generation: requiredGeneration(record, operation),
+                    sandboxId: requiredString(record, "sandbox_id", operation)
+                };
+                throw new _error_js__rspack_import_2.ES("Sandbox persistence returned an invalid response.");
+            }
+            async finishDestroy(conversationId, generation, leaseToken, signal) {
+                await this.booleanRpc("sandbox_binding_finish_destroy", {
+                    p_conversation_id: conversationId,
+                    p_generation: generation,
+                    p_lease_token: leaseToken
+                }, "sandbox.binding.finishDestroy", signal);
+            }
+            async restore(conversationId, generation, leaseToken, signal) {
+                await this.booleanRpc("sandbox_binding_restore", {
+                    p_conversation_id: conversationId,
+                    p_generation: generation,
+                    p_lease_token: leaseToken
+                }, "sandbox.binding.restore", signal);
+            }
+            async booleanRpc(name, params, operation, signal) {
+                const data = await this.rpc(name, params, operation, signal);
+                if ("boolean" != typeof data) throw new _error_js__rspack_import_2.ES("Sandbox persistence returned an invalid response.");
+                return data;
+            }
+            async rpc(name, params, operation, signal) {
+                const requestId = this.generateUuid();
+                for(let attempt = 0; attempt < 2; attempt += 1){
+                    if (signal?.aborted) throw new _error_js__rspack_import_2.sX("The sandbox operation was cancelled.");
+                    let credentials;
+                    try {
+                        credentials = await this.credentialProvider.getValidCredentials(signal);
+                    } catch (error) {
+                        if (error instanceof _iga_pages_data_plane__rspack_import_1.d && "aborted" === error.code) throw new _error_js__rspack_import_2.sX("The sandbox operation was cancelled.");
+                        if (error instanceof _iga_pages_data_plane__rspack_import_1.d) throw new _error_js__rspack_import_2.ES(error.message, {
+                            status: error.status
+                        });
+                        break;
+                    }
+                    const client = (0, _iga_pages_data_plane__rspack_import_1.Ju)({
+                        credentials,
+                        requestId,
+                        signal,
+                        fetch: this.fetch,
+                        createClient: this.createClient,
+                        realtimeError: ()=>new _error_js__rspack_import_2.ES("Sandbox persistence does not support Realtime.")
+                    });
+                    let result;
+                    try {
+                        result = await client.rpc(name, params);
+                    } catch  {
+                        if (signal?.aborted) throw new _error_js__rspack_import_2.sX("The sandbox operation was cancelled.");
+                        if (0 === attempt) continue;
+                        break;
+                    }
+                    if (401 === result.status && 0 === attempt) {
+                        this.credentialProvider.invalidate(credentials.jwt);
+                        continue;
+                    }
+                    if (result.error || result.status < 200 || result.status >= 300) throw unavailable(operation, requestId, result.status);
+                    return result.data;
+                }
+                throw unavailable(operation, requestId);
+            }
+            constructor(options){
+                this.credentialProvider = options.credentialProvider;
+                this.fetch = options.fetch;
+                this.createClient = options.createClient;
+                this.generateUuid = options.generateUuid ?? node_crypto__rspack_import_0.randomUUID;
+                this.leaseSeconds = options.leaseSeconds ?? 60;
+            }
+        }
+        function createRuntimeSandboxBindingRepository(options) {
+            const credentialProvider = new _iga_pages_data_plane__rspack_import_1.ZQ({
+                fetchCredentials: ()=>(0, _iga_pages_data_plane__rspack_import_1.FM)({
+                        token: options.token,
+                        fetch: options.fetch
+                    })
+            });
+            return new SupabaseSandboxBindingRepository({
+                credentialProvider,
+                fetch: options.fetch,
+                createClient: options.createClient
+            });
+        }
+    },
+    "../sandbox/src/iga-sandbox.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            rG: ()=>__clearSandboxCacheForTests,
+            _i: ()=>createSandbox,
+            CT: ()=>createDetachedSandbox,
+            gk: ()=>isInstanceGoneResponse,
+            RN: ()=>IgaSandbox,
+            R9: ()=>attachSandbox,
+            pf: ()=>__getEntryForTests
+        });
+        var external_node_crypto_ = __webpack_require__("node:crypto");
+        var esm = __webpack_require__("../../node_modules/.pnpm/@agent-infra+sandbox@1.0.17/node_modules/@agent-infra/sandbox/dist/esm/index.mjs");
+        var src_error = __webpack_require__("../sandbox/src/error.ts");
+        var api_client = __webpack_require__("../sandbox/src/api-client.ts");
+        function parseExpireAtMs(value) {
+            if (!value) return;
+            const normalized = value.replace(/([+-]\d{2}):?(\d{2})/, "$1:$2").replace(/\s+[A-Za-z]{2,5}$/, "");
+            const ms = Date.parse(normalized);
+            return Number.isFinite(ms) ? ms : void 0;
+        }
+        const cache = new Map();
+        function __clearSandboxCacheForTests() {
+            for (const entry of cache.values())entry.inflight?.controller.abort();
+            cache.clear();
+        }
+        function __getEntryForTests(projectId, conversationId) {
+            return cache.get(JSON.stringify([
+                projectId,
+                conversationId
+            ]));
+        }
+        const AUTO_EXTEND_THRESHOLD_MS = 300000;
+        const AUTO_EXTEND_MINUTES = 30;
+        function isInstanceGoneResponse(result) {
+            if (!result || "object" != typeof result) return false;
+            const failed = result;
+            if (false !== failed.ok) return false;
+            if (failed.error?.statusCode === 422) return false;
+            const content = failed.error?.content;
+            if (!content || "status-code" !== content.reason) return false;
+            return 404 === content.statusCode || 410 === content.statusCode;
+        }
+        async function extendIfExpiring(entry, opts) {
+            if (void 0 === entry.instanceExpireAt) return;
+            if (entry.instanceExpireAt - AUTO_EXTEND_THRESHOLD_MS > Date.now()) return;
+            if (void 0 === entry.sandboxId) return;
+            if (entry.extendingInflight) return entry.extendingInflight;
+            const generation = entry.generation;
+            const sandboxId = entry.sandboxId;
+            const flight = Promise.resolve().then(async ()=>{
+                try {
+                    const updated = await entry.api.updateInstanceTimeout({
+                        ...opts,
+                        sandboxId,
+                        timeoutInMinutes: AUTO_EXTEND_MINUTES
+                    });
+                    const expireAt = parseExpireAtMs(updated.expireAt);
+                    if (void 0 !== expireAt && entry.generation === generation && entry.sandboxId === sandboxId && updated.sandboxId === sandboxId) entry.instanceExpireAt = expireAt;
+                } catch (error) {
+                    if (entry.generation === generation && entry.sandboxId === sandboxId && (error instanceof src_error.YA || void 0 !== entry.instanceExpireAt && entry.instanceExpireAt <= Date.now())) throw normalizeLifecycleError(error, "extendTimeout");
+                } finally{
+                    if (entry.extendingInflight === flight) entry.extendingInflight = void 0;
+                }
+            });
+            entry.extendingInflight = flight;
+            return flight;
+        }
+        const CLIENT_SUBMODULE_KEYS = (()=>{
+            const descs = Object.getOwnPropertyDescriptors(esm.VF.prototype);
+            return Object.keys(descs).filter((k)=>"constructor" !== k && "function" == typeof descs[k].get);
+        })();
+        function isDetachedOptions(options) {
+            return "detached" === options.mode;
+        }
+        function isAttachOptions(options) {
+            return "attach" === options.mode;
+        }
+        class IgaSandbox {
+            installLazyGetters() {
+                for (const key of CLIENT_SUBMODULE_KEYS)if (!Object.prototype.hasOwnProperty.call(this, key)) Object.defineProperty(this, key, {
+                    enumerable: true,
+                    configurable: true,
+                    get: ()=>this.getLazySubmodule(key)
+                });
+            }
+            getLazySubmodule(key) {
+                const cached = this.submoduleCache.get(key);
+                if (void 0 !== cached) return cached;
+                const self = this;
+                const proxy = new Proxy({}, {
+                    get (_t, method) {
+                        if ("string" != typeof method) return;
+                        return async function(...args) {
+                            const abortSignal = requestAbortSignal(args);
+                            const invocation = {
+                                generation: self.entry.generation
+                            };
+                            const invoke = async ()=>{
+                                let raw = await self.ensureInstance({
+                                    abortSignal
+                                });
+                                while(self.entry.destroyingInflight || self.entry.recoveryInflight || self.rawGeneration !== self.entry.generation)raw = await self.ensureInstance({
+                                    abortSignal
+                                });
+                                const sub = raw[key];
+                                const fn = sub[method];
+                                if ("function" != typeof fn) throw new TypeError(`sandbox.${key}.${String(method)} is not a function`);
+                                invocation.generation = self.entry.generation;
+                                const operation = Promise.resolve().then(()=>fn.apply(sub, args));
+                                const active = self.entry.activeOperations ??= new Set();
+                                active.add(operation);
+                                const renewal = setInterval(()=>{
+                                    if (self.entry.generation === invocation.generation) extendIfExpiring(self.entry, self.managementCallOpts()).catch(()=>{});
+                                }, 60000);
+                                renewal.unref();
+                                try {
+                                    return await operation;
+                                } finally{
+                                    clearInterval(renewal);
+                                    active.delete(operation);
+                                }
+                            };
+                            return self.callWithRecreate(invoke, invocation, abortSignal);
+                        };
+                    }
+                });
+                this.submoduleCache.set(key, proxy);
+                return proxy;
+            }
+            async callWithRecreate(invoke, invocation, abortSignal) {
+                const result = await invoke();
+                if ("conversation" !== this.mode) return result;
+                if (!isInstanceGoneResponse(result)) return result;
+                const generation = invocation.generation;
+                if (this.entry.generation !== generation || this.entry.destroyingInflight) return result;
+                const confirmed = await this.confirmDestroyed(abortSignal);
+                if (!confirmed || this.entry.generation !== generation || this.entry.destroyingInflight) return result;
+                await this.recreateInstance(generation, abortSignal);
+                if (this.entry.destroyingInflight || this.entry.generation !== generation + 1) return result;
+                await this.ensureInstance({
+                    abortSignal
+                });
+                if (!(0, api_client.ip)(result)) return result;
+                return invoke();
+            }
+            async confirmDestroyed(abortSignal) {
+                const entry = this.entry;
+                const sandboxId = entry.sandboxId;
+                if (!sandboxId) return false;
+                if (!entry.recreateInflight) {
+                    const flight = Promise.resolve().then(async ()=>{
+                        try {
+                            await entry.api.confirmInstanceExists({
+                                ...this.managementCallOpts(),
+                                sandboxId
+                            });
+                            return false;
+                        } catch (err) {
+                            if (err instanceof src_error.YA) return true;
+                            return false;
+                        } finally{
+                            if (entry.recreateInflight === flight) entry.recreateInflight = void 0;
+                        }
+                    });
+                    entry.recreateInflight = flight;
+                }
+                const inflight = entry.recreateInflight;
+                return waitForOperation(inflight, abortSignal);
+            }
+            async recreateInstance(expectedGeneration, abortSignal) {
+                throwIfOperationAborted(abortSignal);
+                const entry = this.entry;
+                if (entry.destroyingInflight) return void await waitForOperation(entry.destroyingInflight, abortSignal);
+                if (entry.recoveryInflight) return waitForOperation(entry.recoveryInflight, abortSignal);
+                if (entry.generation !== expectedGeneration) return;
+                const flight = Promise.resolve().then(()=>this.performRecreation(expectedGeneration)).finally(()=>{
+                    if (entry.recoveryInflight === flight) entry.recoveryInflight = void 0;
+                });
+                entry.recoveryInflight = flight;
+                return waitForOperation(flight, abortSignal);
+            }
+            async performRecreation(expectedGeneration) {
+                const entry = this.entry;
+                const abortSignal = void 0;
+                if (entry.generation !== expectedGeneration) return;
+                const sandboxId = entry.sandboxId;
+                if (entry.bindingRepository && this.conversationId && void 0 !== entry.bindingGeneration && sandboxId) await entry.bindingRepository.invalidate(this.conversationId, entry.bindingGeneration, sandboxId, abortSignal);
+                if (entry.generation !== expectedGeneration) return;
+                entry.inflight?.controller.abort();
+                entry.generation += 1;
+                this.raw = void 0;
+                this.rawGeneration = -1;
+                entry.inflight = void 0;
+                entry.sandboxId = void 0;
+                entry.apiKey = void 0;
+                entry.environment = void 0;
+                entry.headers = void 0;
+                entry.instanceExpireAt = void 0;
+                entry.bindingGeneration = void 0;
+                entry.extendingInflight = void 0;
+                entry.recreateInflight = void 0;
+                this.submoduleCache.clear();
+                if (!sandboxId) return;
+                try {
+                    await entry.api.destroy({
+                        ...this.managementCallOpts(),
+                        sandboxId
+                    });
+                } catch  {}
+            }
+            async getClient(options) {
+                return this.ensureInstance({
+                    abortSignal: options?.abortSignal
+                });
+            }
+            async ensureReady(options) {
+                await this.ensureInstance({
+                    abortSignal: options?.abortSignal
+                });
+            }
+            async ensureInstance(opts = {}) {
+                const entry = this.entry;
+                for(;;){
+                    throwIfOperationAborted(opts.abortSignal);
+                    const lifecycle = entry.destroyingInflight ?? entry.recoveryInflight;
+                    if (lifecycle) {
+                        await waitForOperation(lifecycle, opts.abortSignal);
+                        continue;
+                    }
+                    const generation = entry.generation;
+                    if (isEntryReady(entry)) {
+                        if (!opts.skipAutoExtend) try {
+                            await waitForOperation(extendIfExpiring(entry, this.managementCallOpts()), opts.abortSignal);
+                        } catch (error) {
+                            if ("conversation" !== this.mode || !(error instanceof src_error.YA)) throw error;
+                            await this.recreateInstance(generation, opts.abortSignal);
+                            continue;
+                        }
+                        if (entry.generation !== generation || entry.destroyingInflight || entry.recoveryInflight || !isEntryReady(entry)) continue;
+                        if (this.raw && this.rawGeneration === generation) return this.raw;
+                        return this.createClient(entry);
+                    }
+                    this.raw = void 0;
+                    const flight = entry.inflight ?? this.startInitialization(entry);
+                    try {
+                        await this.waitForInitialization(flight, opts.abortSignal);
+                    } catch (error) {
+                        throwIfOperationAborted(opts.abortSignal);
+                        throw error;
+                    }
+                    if (entry.generation === generation && !entry.destroyingInflight && !entry.recoveryInflight) {
+                        if (!isEntryReady(entry)) throw sandboxUnavailableError("sandbox.initialize");
+                        return this.createClient(entry);
+                    }
+                }
+            }
+            startInitialization(entry) {
+                const controller = new AbortController();
+                const generation = entry.generation;
+                const flight = {};
+                flight.controller = controller;
+                flight.result = this.initializeEntry(entry, controller.signal, generation).then(()=>({
+                        ok: true,
+                        value: void 0
+                    }), (error)=>({
+                        ok: false,
+                        error
+                    }));
+                entry.inflight = flight;
+                flight.result.then(()=>{
+                    if (entry.inflight === flight) entry.inflight = void 0;
+                });
+                return flight;
+            }
+            async waitForInitialization(flight, abortSignal) {
+                const result = await waitForOperation(flight.result, abortSignal);
+                if (!result.ok) throw result.error;
+            }
+            async initializeEntry(entry, signal, generation) {
+                if ("attach" === this.mode) return void await this.initializeAttach(entry, signal, generation);
+                if ("conversation" === this.mode && entry.bindingRepository) return void await this.initializePersistentConversation(entry, signal, generation);
+                const conversationCallOpts = {
+                    projectId: this.projectId,
+                    conversationId: this.conversationId,
+                    signal
+                };
+                const callOpts = "detached" === this.mode ? {
+                    projectId: this.projectId,
+                    conversationId: "",
+                    signal
+                } : conversationCallOpts;
+                let token;
+                try {
+                    token = await entry.api.getToken({
+                        signal: callOpts.signal
+                    });
+                } catch (err) {
+                    throw normalizeLifecycleError(err, "authenticate");
+                }
+                assertInitializationCurrent(entry, generation, signal);
+                let created;
+                try {
+                    created = await entry.api.create(callOpts);
+                } catch (err) {
+                    throw normalizeLifecycleError(err, "create");
+                }
+                if (signal.aborted || entry.generation !== generation) {
+                    await bestEffortDestroy(entry, {
+                        projectId: this.projectId,
+                        conversationId: callOpts.conversationId,
+                        sandboxId: created.sandboxId
+                    });
+                    assertInitializationCurrent(entry, generation, signal);
+                }
+                const environment = token.url;
+                if (!environment) {
+                    await bestEffortDestroy(entry, {
+                        projectId: this.projectId,
+                        conversationId: callOpts.conversationId,
+                        sandboxId: created.sandboxId
+                    });
+                    throw new src_error.ES("Sandbox credentials could not be initialized.");
+                }
+                const headerName = token.tokenHeader ?? "Authorization";
+                const headerValue = `${token.tokenType ?? "Bearer"} ${token.apiKey}`;
+                const headers = {
+                    [headerName]: headerValue
+                };
+                headers["x-faas-instance-name"] = created.sandboxId;
+                entry.apiKey = token.apiKey;
+                entry.sandboxId = created.sandboxId;
+                entry.environment = environment;
+                entry.headers = headers;
+                entry.instanceExpireAt = void 0;
+                if ("detached" === this.mode) this.sandboxId = created.sandboxId;
+                try {
+                    const info = await entry.api.getInstance({
+                        ...callOpts,
+                        sandboxId: created.sandboxId
+                    });
+                    if (entry.generation === generation && entry.sandboxId === created.sandboxId && info.sandboxId === created.sandboxId) entry.instanceExpireAt = parseExpireAtMs(info.expireAt);
+                } catch  {}
+            }
+            async queryUsableInstance(entry, opts) {
+                const deadline = Date.now() + 30000;
+                for(;;){
+                    const info = await entry.api.getInstance(opts);
+                    if (!info.sandboxId) throw new src_error.YA("The sandbox was not found.");
+                    if (info.sandboxId !== opts.sandboxId) throw new src_error.ES("Sandbox instance query returned a different instance.");
+                    if ("Failed" === info.status || "Terminating" === info.status) throw new src_error.YA("The sandbox is not available.");
+                    if ("Starting" !== info.status) return info;
+                    if (Date.now() >= deadline) throw new src_error.ES("Sandbox startup timed out.", {
+                        status: 504
+                    });
+                    await waitForDelay(500, opts.signal);
+                }
+            }
+            async initializePersistentConversation(entry, signal, generation) {
+                const repository = entry.bindingRepository;
+                const conversationId = this.conversationId;
+                const leaseToken = (0, external_node_crypto_.randomUUID)();
+                const waitDeadline = Date.now() + 90000;
+                const callOpts = {
+                    projectId: this.projectId,
+                    conversationId,
+                    signal
+                };
+                for(;;){
+                    assertInitializationCurrent(entry, generation, signal);
+                    if (Date.now() >= waitDeadline) throw new src_error.ES("Sandbox session initialization timed out.", {
+                        status: 504
+                    });
+                    const binding = await repository.acquire(conversationId, leaseToken, signal);
+                    if ("wait" === binding.action) {
+                        if (Date.now() >= waitDeadline) throw new src_error.ES("Sandbox session initialization is still in progress.");
+                        const leaseDeadline = Date.parse(binding.leaseExpiresAt);
+                        const remaining = Number.isFinite(leaseDeadline) ? Math.max(100, leaseDeadline - Date.now()) : 500;
+                        await waitForDelay(Math.min(500, remaining), signal);
+                        continue;
+                    }
+                    if ("attach" === binding.action) {
+                        let info;
+                        try {
+                            info = await this.queryUsableInstance(entry, {
+                                ...callOpts,
+                                sandboxId: binding.sandboxId
+                            });
+                        } catch (error) {
+                            if (error instanceof src_error.YA) {
+                                assertInitializationCurrent(entry, generation, signal);
+                                await repository.invalidate(conversationId, binding.generation, binding.sandboxId, signal);
+                                continue;
+                            }
+                            throw normalizeLifecycleError(error, "getInfo");
+                        }
+                        assertInitializationCurrent(entry, generation, signal);
+                        if (isUnavailableInstance(info)) {
+                            await repository.invalidate(conversationId, binding.generation, binding.sandboxId, signal);
+                            continue;
+                        }
+                        const expiry = parseExpireAtMs(info.expireAt);
+                        if (void 0 !== expiry && expiry <= Date.now() + AUTO_EXTEND_THRESHOLD_MS) {
+                            try {
+                                info = await entry.api.updateInstanceTimeout({
+                                    ...callOpts,
+                                    sandboxId: binding.sandboxId,
+                                    timeoutInMinutes: AUTO_EXTEND_MINUTES
+                                });
+                            } catch (error) {
+                                if (!(error instanceof src_error.YA)) throw error;
+                                await repository.invalidate(conversationId, binding.generation, binding.sandboxId, signal);
+                                continue;
+                            }
+                            assertInitializationCurrent(entry, generation, signal);
+                            if (info.sandboxId !== binding.sandboxId) throw new src_error.ES("Sandbox renewal returned a different instance.");
+                        }
+                        let token;
+                        try {
+                            token = await entry.api.getToken({
+                                signal: callOpts.signal
+                            });
+                        } catch (error) {
+                            throw normalizeLifecycleError(error, "authenticate");
+                        }
+                        assertInitializationCurrent(entry, generation, signal);
+                        this.commitInitializedEntry(entry, generation, binding.generation, binding.sandboxId, token, info.expireAt, signal);
+                        return;
+                    }
+                    let token;
+                    try {
+                        token = await entry.api.getToken({
+                            signal: callOpts.signal
+                        });
+                    } catch (error) {
+                        await repository.release(conversationId, binding.generation, leaseToken, signal);
+                        throw normalizeLifecycleError(error, "authenticate");
+                    }
+                    assertInitializationCurrent(entry, generation, signal);
+                    if (!token.url) {
+                        await repository.release(conversationId, binding.generation, leaseToken, signal);
+                        throw new src_error.ES("Sandbox credentials could not be initialized.");
+                    }
+                    let created;
+                    try {
+                        created = await entry.api.create(callOpts);
+                    } catch (error) {
+                        throw normalizeLifecycleError(error, "create");
+                    }
+                    if (signal.aborted || entry.generation !== generation) {
+                        await bestEffortDestroy(entry, {
+                            projectId: this.projectId,
+                            conversationId,
+                            sandboxId: created.sandboxId
+                        });
+                        assertInitializationCurrent(entry, generation, signal);
+                    }
+                    let info;
+                    try {
+                        info = await this.queryUsableInstance(entry, {
+                            ...callOpts,
+                            sandboxId: created.sandboxId
+                        });
+                    } catch (error) {
+                        await bestEffortDestroy(entry, {
+                            ...callOpts,
+                            sandboxId: created.sandboxId
+                        });
+                        await repository.release(conversationId, binding.generation, leaseToken, signal);
+                        throw error;
+                    }
+                    let published;
+                    try {
+                        published = await repository.publish(conversationId, binding.generation, leaseToken, created.sandboxId, signal);
+                    } catch (error) {
+                        await bestEffortDestroy(entry, {
+                            projectId: this.projectId,
+                            conversationId,
+                            sandboxId: created.sandboxId
+                        });
+                        throw error;
+                    }
+                    if (!published) {
+                        await bestEffortDestroy(entry, {
+                            projectId: this.projectId,
+                            conversationId,
+                            sandboxId: created.sandboxId
+                        });
+                        continue;
+                    }
+                    try {
+                        this.commitInitializedEntry(entry, generation, binding.generation, created.sandboxId, token, info?.expireAt, signal);
+                    } catch (error) {
+                        await bestEffortDestroy(entry, {
+                            projectId: this.projectId,
+                            conversationId,
+                            sandboxId: created.sandboxId
+                        });
+                        await repository.invalidate(conversationId, binding.generation, created.sandboxId, signal);
+                        throw error;
+                    }
+                    return;
+                }
+            }
+            commitInitializedEntry(entry, generation, bindingGeneration, sandboxId, token, expireAt, signal) {
+                if (!token.url) throw new src_error.ES("Sandbox credentials could not be initialized.");
+                assertInitializationCurrent(entry, generation, signal ?? new AbortController().signal);
+                const headerName = token.tokenHeader ?? "Authorization";
+                entry.apiKey = token.apiKey;
+                entry.sandboxId = sandboxId;
+                entry.environment = token.url;
+                entry.headers = {
+                    [headerName]: `${token.tokenType ?? "Bearer"} ${token.apiKey}`,
+                    "x-faas-instance-name": sandboxId
+                };
+                entry.instanceExpireAt = parseExpireAtMs(expireAt);
+                entry.bindingGeneration = bindingGeneration;
+            }
+            async initializeAttach(entry, signal, generation) {
+                const sandboxId = this.sandboxId;
+                const callOpts = {
+                    projectId: this.projectId,
+                    conversationId: "",
+                    signal
+                };
+                let token;
+                try {
+                    token = await entry.api.getToken({
+                        signal: callOpts.signal
+                    });
+                } catch (err) {
+                    throw normalizeLifecycleError(err, "authenticate");
+                }
+                assertInitializationCurrent(entry, generation, signal);
+                let info;
+                try {
+                    info = await this.queryUsableInstance(entry, {
+                        ...callOpts,
+                        sandboxId
+                    });
+                } catch (err) {
+                    throw normalizeLifecycleError(err, "getInfo");
+                }
+                assertInitializationCurrent(entry, generation, signal);
+                if (!info.sandboxId || "Failed" === info.status || "Terminating" === info.status) throw new src_error.YA("The sandbox was not found.");
+                const expireAt = parseExpireAtMs(info.expireAt);
+                if (void 0 !== expireAt && expireAt <= Date.now()) {
+                    let renewed;
+                    try {
+                        renewed = await entry.api.updateInstanceTimeout({
+                            ...callOpts,
+                            sandboxId,
+                            timeoutInMinutes: AUTO_EXTEND_MINUTES
+                        });
+                    } catch (err) {
+                        throw normalizeLifecycleError(err, "extendTimeout");
+                    }
+                    assertInitializationCurrent(entry, generation, signal);
+                    if (renewed.sandboxId !== sandboxId) throw new src_error.ES("Sandbox renewal returned a different instance.");
+                    entry.instanceExpireAt = parseExpireAtMs(renewed.expireAt);
+                } else entry.instanceExpireAt = expireAt;
+                const environment = token.url;
+                if (!environment) throw new src_error.ES("Sandbox credentials could not be initialized.");
+                const headerName = token.tokenHeader ?? "Authorization";
+                const headerValue = `${token.tokenType ?? "Bearer"} ${token.apiKey}`;
+                const headers = {
+                    [headerName]: headerValue
+                };
+                headers["x-faas-instance-name"] = sandboxId;
+                entry.apiKey = token.apiKey;
+                entry.sandboxId = sandboxId;
+                entry.environment = environment;
+                entry.headers = headers;
+            }
+            managementCallOpts() {
+                return {
+                    projectId: this.projectId,
+                    conversationId: this.conversationId ?? ""
+                };
+            }
+            createClient(entry) {
+                if (!isEntryReady(entry)) throw sandboxUnavailableError("sandbox.initialize");
+                this.raw = new esm.VF({
+                    environment: entry.environment,
+                    timeoutInSeconds: this.timeoutInSeconds ?? 60,
+                    maxRetries: 0,
+                    headers: entry.headers
+                });
+                this.rawGeneration = entry.generation;
+                return this.raw;
+            }
+            async getInfo(options) {
+                const abortSignal = options?.abortSignal;
+                const invoke = async ()=>{
+                    await this.ensureInstance({
+                        abortSignal
+                    });
+                    const sandboxId = this.entry.sandboxId;
+                    if (!sandboxId) throw sandboxUnavailableError("sandbox.getInfo");
+                    const generation = this.entry.generation;
+                    try {
+                        const info = await this.api.getInstance({
+                            projectId: this.projectId,
+                            conversationId: this.conversationId ?? "",
+                            sandboxId,
+                            signal: abortSignal
+                        });
+                        if (!info.sandboxId) throw new src_error.YA("The sandbox was not found.");
+                        if (info.sandboxId !== sandboxId) throw new src_error.ES("Sandbox instance query returned a different instance.");
+                        if ("Failed" === info.status || "Terminating" === info.status) throw new src_error.YA("The sandbox is not available.");
+                        if (this.entry.generation === generation && this.entry.sandboxId === sandboxId && info.sandboxId === sandboxId) this.entry.instanceExpireAt = parseExpireAtMs(info.expireAt);
+                        return info;
+                    } catch (err) {
+                        throw normalizeLifecycleError(err, "getInfo");
+                    }
+                };
+                return this.managementCallWithRecreate(invoke, abortSignal);
+            }
+            async extendTimeout(timeoutInMinutes, options) {
+                const abortSignal = options?.abortSignal;
+                const invoke = async ()=>{
+                    await this.ensureInstance({
+                        skipAutoExtend: true,
+                        abortSignal
+                    });
+                    const sandboxId = this.entry.sandboxId;
+                    if (!sandboxId) throw sandboxUnavailableError("sandbox.extendTimeout");
+                    const generation = this.entry.generation;
+                    try {
+                        const updated = await this.api.updateInstanceTimeout({
+                            projectId: this.projectId,
+                            conversationId: this.conversationId ?? "",
+                            sandboxId,
+                            timeoutInMinutes,
+                            signal: abortSignal
+                        });
+                        if (this.entry.generation === generation && this.entry.sandboxId === sandboxId && updated.sandboxId === sandboxId) this.entry.instanceExpireAt = parseExpireAtMs(updated.expireAt);
+                        return updated;
+                    } catch (err) {
+                        throw normalizeLifecycleError(err, "extendTimeout");
+                    }
+                };
+                return this.managementCallWithRecreate(invoke, abortSignal);
+            }
+            async managementCallWithRecreate(invoke, abortSignal) {
+                const generation = this.entry.generation;
+                try {
+                    return await invoke();
+                } catch (err) {
+                    if ("conversation" !== this.mode) throw err;
+                    if (!(err instanceof src_error.YA)) throw err;
+                    await this.recreateInstance(generation, abortSignal);
+                    return invoke();
+                }
+            }
+            async destroy(options) {
+                const abortSignal = options?.abortSignal;
+                throwIfOperationAborted(abortSignal);
+                const entry = this.entry;
+                if (entry.destroyingInflight) return waitForOperation(entry.destroyingInflight, abortSignal);
+                const flight = Promise.resolve().then(async ()=>{
+                    await entry.recoveryInflight;
+                    await Promise.allSettled([
+                        ...entry.activeOperations ?? []
+                    ]);
+                    await this.performDestroy();
+                }).finally(()=>{
+                    if (entry.destroyingInflight === flight) entry.destroyingInflight = void 0;
+                });
+                entry.destroyingInflight = flight;
+                return waitForOperation(flight, abortSignal);
+            }
+            async performDestroy() {
+                const entry = this.entry;
+                const abortSignal = void 0;
+                if ("conversation" === this.mode && this.conversationId && entry.bindingRepository) {
+                    const initialization = entry.inflight;
+                    initialization?.controller.abort();
+                    if (initialization) await waitForOperation(initialization.result, abortSignal);
+                    await this.destroyPersistentBinding(entry.bindingRepository, this.conversationId, abortSignal);
+                    entry.generation += 1;
+                    this.raw = void 0;
+                    this.rawGeneration = -1;
+                    entry.inflight = void 0;
+                    entry.sandboxId = void 0;
+                    entry.apiKey = void 0;
+                    entry.environment = void 0;
+                    entry.headers = void 0;
+                    entry.instanceExpireAt = void 0;
+                    entry.bindingGeneration = void 0;
+                    entry.extendingInflight = void 0;
+                    entry.recreateInflight = void 0;
+                    this.submoduleCache.clear();
+                    return;
+                }
+                await this.destroyStandalone(entry);
+            }
+            async destroyStandalone(entry, abortSignal) {
+                const sandboxId = entry.sandboxId;
+                const initialization = entry.inflight;
+                initialization?.controller.abort();
+                if (initialization) await waitForOperation(initialization.result, abortSignal);
+                if (sandboxId) try {
+                    await entry.api.destroy({
+                        projectId: this.projectId,
+                        conversationId: this.conversationId ?? "",
+                        sandboxId,
+                        signal: abortSignal
+                    });
+                } catch (err) {
+                    let confirmedGone = false;
+                    try {
+                        await entry.api.confirmInstanceExists({
+                            projectId: this.projectId,
+                            conversationId: this.conversationId ?? "",
+                            sandboxId,
+                            signal: abortSignal
+                        });
+                    } catch (confirmError) {
+                        confirmedGone = confirmError instanceof src_error.YA;
+                    }
+                    if (!confirmedGone) throw normalizeLifecycleError(err, "destroy");
+                }
+                entry.generation += 1;
+                this.raw = void 0;
+                this.rawGeneration = -1;
+                entry.inflight = void 0;
+                entry.sandboxId = void 0;
+                entry.apiKey = void 0;
+                entry.environment = void 0;
+                entry.headers = void 0;
+                entry.instanceExpireAt = void 0;
+                this.submoduleCache.clear();
+            }
+            async destroyPersistentBinding(repository, conversationId, abortSignal) {
+                const leaseToken = (0, external_node_crypto_.randomUUID)();
+                const deadline = Date.now() + 90000;
+                for(;;){
+                    throwIfOperationAborted(abortSignal);
+                    const binding = await repository.beginDestroy(conversationId, leaseToken, abortSignal);
+                    if ("none" === binding.action) return;
+                    if ("wait" === binding.action) {
+                        if (Date.now() >= deadline) throw new src_error.ES("Sandbox session destruction is still in progress.");
+                        const leaseDeadline = Date.parse(binding.leaseExpiresAt);
+                        const remaining = Number.isFinite(leaseDeadline) ? Math.max(100, leaseDeadline - Date.now()) : 500;
+                        await waitForAbortableDelay(Math.min(500, remaining), abortSignal);
+                        continue;
+                    }
+                    try {
+                        await this.api.destroy({
+                            projectId: this.projectId,
+                            conversationId,
+                            sandboxId: binding.sandboxId,
+                            signal: abortSignal
+                        });
+                    } catch (destroyError) {
+                        try {
+                            await this.api.confirmInstanceExists({
+                                projectId: this.projectId,
+                                conversationId,
+                                sandboxId: binding.sandboxId,
+                                signal: abortSignal
+                            });
+                            await repository.restore(conversationId, binding.generation, leaseToken, abortSignal);
+                        } catch (confirmError) {
+                            if (confirmError instanceof src_error.YA) return void await repository.finishDestroy(conversationId, binding.generation, leaseToken, abortSignal);
+                        }
+                        throw normalizeLifecycleError(destroyError, "destroy");
+                    }
+                    await repository.finishDestroy(conversationId, binding.generation, leaseToken, abortSignal);
+                    return;
+                }
+            }
+            constructor(options){
+                this.rawGeneration = -1;
+                this.submoduleCache = new Map();
+                this.projectId = options.projectId;
+                this.timeoutInSeconds = options.timeoutInSeconds;
+                if (isDetachedOptions(options)) {
+                    this.mode = "detached";
+                    this.conversationId = void 0;
+                    this.sandboxId = void 0;
+                    this.entry = createStandaloneEntry(options);
+                    this.api = this.entry.api;
+                } else if (isAttachOptions(options)) {
+                    this.mode = "attach";
+                    this.conversationId = void 0;
+                    this.sandboxId = options.sandboxId;
+                    const entry = createStandaloneEntry(options);
+                    entry.sandboxId = options.sandboxId;
+                    this.entry = entry;
+                    this.api = entry.api;
+                } else {
+                    this.mode = "conversation";
+                    this.conversationId = options.conversationId;
+                    this.sandboxId = void 0;
+                    const cacheKey = JSON.stringify([
+                        options.projectId,
+                        options.conversationId
+                    ]);
+                    let entry = cache.get(cacheKey);
+                    if (!entry) {
+                        const api = options.api ?? (0, api_client.SW)({
+                            apiBaseUrl: options.apiBaseUrl,
+                            apiToken: options.apiToken
+                        });
+                        entry = {
+                            api,
+                            bindingRepository: options.bindingRepository,
+                            generation: 0
+                        };
+                        cache.set(cacheKey, entry);
+                    }
+                    this.entry = entry;
+                    this.api = entry.api;
+                }
+                this.installLazyGetters();
+            }
+        }
+        const PUBLIC_SANDBOX_KEYS = [
+            "conversationId",
+            "sandboxId",
+            "getClient",
+            "ensureReady",
+            "getInfo",
+            "extendTimeout",
+            "destroy"
+        ];
+        function createSandboxProxy(target) {
+            const publicKeys = new Set([
+                ...CLIENT_SUBMODULE_KEYS,
+                ...PUBLIC_SANDBOX_KEYS
+            ]);
+            return new Proxy(target, {
+                get (current, property) {
+                    if ("symbol" != typeof property && !publicKeys.has(property)) return;
+                    const value = Reflect.get(current, property, current);
+                    return "function" == typeof value ? value.bind(current) : value;
+                },
+                has (_current, property) {
+                    return publicKeys.has(property);
+                },
+                ownKeys (current) {
+                    return Reflect.ownKeys(current).filter((property)=>publicKeys.has(property));
+                },
+                getOwnPropertyDescriptor (current, property) {
+                    if (!publicKeys.has(property)) return;
+                    return Reflect.getOwnPropertyDescriptor(current, property);
+                },
+                set () {
+                    return false;
+                },
+                defineProperty () {
+                    return false;
+                },
+                deleteProperty () {
+                    return false;
+                },
+                preventExtensions () {
+                    return false;
+                }
+            });
+        }
+        function createSandbox(options) {
+            return createSandboxProxy(new IgaSandbox(options));
+        }
+        function createDetachedSandbox(options) {
+            return createSandboxProxy(new IgaSandbox({
+                ...options,
+                mode: "detached"
+            }));
+        }
+        function attachSandbox(options) {
+            return createSandboxProxy(new IgaSandbox({
+                ...options,
+                mode: "attach"
+            }));
+        }
+        function createStandaloneEntry(options) {
+            const api = options.api ?? (0, api_client.SW)({
+                apiBaseUrl: options.apiBaseUrl,
+                apiToken: options.apiToken
+            });
+            return {
+                api,
+                generation: 0
+            };
+        }
+        function requestAbortSignal(args) {
+            const last = args.at(-1);
+            if (!last || "object" != typeof last) return;
+            const signal = last.abortSignal;
+            return isAbortSignal(signal) ? signal : void 0;
+        }
+        function isAbortSignal(value) {
+            return Boolean(value && "object" == typeof value && "boolean" == typeof value.aborted && "function" == typeof value.addEventListener && "function" == typeof value.removeEventListener);
+        }
+        function throwIfOperationAborted(signal) {
+            if (!signal?.aborted) return;
+            throw new src_error.sX("The sandbox operation was cancelled.");
+        }
+        function waitForOperation(promise, signal) {
+            if (!signal) return promise;
+            throwIfOperationAborted(signal);
+            return new Promise((resolve, reject)=>{
+                const cleanup = ()=>signal.removeEventListener("abort", onAbort);
+                const onAbort = ()=>{
+                    cleanup();
+                    reject(new src_error.sX("The sandbox operation was cancelled."));
+                };
+                signal.addEventListener("abort", onAbort, {
+                    once: true
+                });
+                promise.then((value)=>{
+                    cleanup();
+                    resolve(value);
+                }, (error)=>{
+                    cleanup();
+                    reject(error);
+                });
+            });
+        }
+        function waitForDelay(delayMs, signal) {
+            if (signal.aborted) return Promise.reject(new src_error.sX("Sandbox initialization was cancelled."));
+            return new Promise((resolve, reject)=>{
+                const timer = setTimeout(()=>{
+                    signal.removeEventListener("abort", onAbort);
+                    resolve();
+                }, delayMs);
+                const onAbort = ()=>{
+                    clearTimeout(timer);
+                    reject(new src_error.sX("Sandbox initialization was cancelled."));
+                };
+                signal.addEventListener("abort", onAbort, {
+                    once: true
+                });
+            });
+        }
+        function waitForAbortableDelay(delayMs, signal) {
+            if (!signal) return new Promise((resolve)=>setTimeout(resolve, delayMs));
+            return waitForDelay(delayMs, signal);
+        }
+        function isUnavailableInstance(info) {
+            return !info.sandboxId || "Failed" === info.status || "Terminating" === info.status;
+        }
+        function assertInitializationCurrent(entry, generation, signal) {
+            if (!signal.aborted && entry.generation === generation) return;
+            throw new src_error.sX("Sandbox initialization was cancelled.");
+        }
+        async function bestEffortDestroy(entry, opts) {
+            try {
+                await entry.api.destroy(opts);
+            } catch  {}
+        }
+        function isEntryReady(entry) {
+            return Boolean(entry.sandboxId && entry.apiKey && entry.environment && entry.headers);
+        }
+        function normalizeLifecycleError(err, _phase) {
+            if (err instanceof src_error.ES) return err;
+            if ((0, src_error.zf)(err)) return new src_error.sX("The sandbox operation was cancelled.");
+            return new src_error.ES("The sandbox service is temporarily unavailable.");
+        }
+        function sandboxUnavailableError(_operation) {
+            return new src_error.ES("The sandbox is temporarily unavailable.");
+        }
+    }
+};