abtars 0.3.4-alpha.7 → 0.3.4

package/bundle/{chunk-ONBF5DDU.js → chunk-L72RIPEC.js}

@@ -1,21 +1,23 @@
 #!/usr/bin/env node
  import { createRequire as __bundleCreateRequire } from 'node:module'; import { fileURLToPath as __bundleFileURLToPath } from 'node:url'; import { dirname as __bundleDirname } from 'node:path'; const require = __bundleCreateRequire(import.meta.url); const __chunk_filename = __bundleFileURLToPath(import.meta.url); const __chunk_dirname = __bundleDirname(__chunk_filename);
 import {
-  getMasterUserId,
-  init_master_user
-} from "./chunk-AFREM7FX.js";
-import {
-  init_user_registry,
-  loadUsers
-} from "./chunk-ZV4IWKDJ.js";
-import {
+  init_spin_profiles,
   init_spin_types,
   parseSessionType,
+  profileFor,
   sessionCreatedAt,
   sessionType,
   typeAgent,
   typeLabel
-} from "./chunk-Y76VUJSF.js";
+} from "./chunk-BNXV7SZI.js";
+import {
+  getMasterUserId,
+  init_master_user
+} from "./chunk-CK7YTA2F.js";
+import {
+  init_user_registry,
+  loadUsers
+} from "./chunk-E7XD5UGB.js";
 import {
   init_kanban_board,
   isUnblocked,
@@ -26,17 +28,17 @@ import {
   kanbanList,
   kanbanRetryOrFail,
   kanbanRunning
-} from "./chunk-EQSG2CRM.js";
+} from "./chunk-FGYDIX54.js";
 import {
   init_log_and_swallow,
   logAndSwallow
-} from "./chunk-YSKCQH6E.js";
+} from "./chunk-2IYJ4I66.js";
 import {
   init_logger,
   logDebug,
   logInfo,
   logWarn
-} from "./chunk-GWILHZPT.js";
+} from "./chunk-XRTXYN66.js";
 import {
   init_paths,
   paths_exports
@@ -378,7 +380,7 @@ __export(spin_exports, {
 });
 async function fireCallback(peerName, taskId, status, result, error, artifacts, tokensUsed) {
   try {
-    const { getPeerTransport } = await import("./peer-transport-I6JPLFZ2.js");
+    const { getPeerTransport } = await import("./peer-transport-SI7I72DB.js");
     const transport = getPeerTransport();
     const payload = { action: "callback", task_id: taskId, status, result_summary: result, error, tokens_used: tokensUsed ?? 0 };
     if (artifacts?.length) payload.artifacts = artifacts;
@@ -397,6 +399,7 @@ var init_spin = __esm({
     init_user_registry();
     init_master_user();
     init_spin_types();
+    init_spin_profiles();
     init_spin_sessions();
     init_spin_sessions();
     init_spin_types();
@@ -461,6 +464,17 @@ var init_spin = __esm({
         this.nextIndex = r.nextIndex;
         return r.session;
       }
+      /** Allocate a named Dreamy (D) session upfront for the duration of a sleep cycle (#1280).
+       *  Non-active, platform="background" — visible in master /session (showAll) for the full cycle.
+       *  Call at sleep start before the first runtime.complete(); the caller holds the returned id
+       *  and passes it as sessionId to subsequent spin({ type:"D", sessionId }) calls. */
+      allocateDreamySession(name) {
+        const userId = getMasterUserId();
+        const r = allocateSession(this.sessions, this.nextIndex, "D", userId, "background", 0, { active: false });
+        this.nextIndex = r.nextIndex;
+        r.session.name = name;
+        return r.session;
+      }
       switchSession(userId, platform, index) {
         return switchSession(this.sessions, userId, platform, index);
       }
@@ -688,19 +702,177 @@ var init_spin = __esm({
       getOrcSession() {
         return this.orcSession?.isReady ? this.orcSession : null;
       }
+      /** @deprecated Use `spin({ type:"O", sessionId, prompt:"[USER] "+msg, await:true })`. */
       async sendUserToOrc(message) {
-        const orc = this.getOrcSession();
-        if (!orc) return null;
-        const response = await orc.sendPrompt("orc:user", `[USER] ${message}`);
-        return response;
+        const orcSession = [...this.sessions.values()].find((s) => s.id.includes("_O_") && s.status !== "ended");
+        if (!orcSession) return null;
+        const { result } = await this.spin({ type: "O", sessionId: orcSession.id, prompt: `[USER] ${message}`, await: true });
+        return result ?? null;
+      }
+      // ── #1271: unified session API ────────────────────────────────────────
+      //
+      // spin(spec) is the single chokepoint for issuing a model prompt. Per-type
+      // behavior lives in SESSION_PROFILES (spin-profiles.ts) — no `type === "…"`
+      // branches here. Continuation (pipeline main turn, sleep step N) is just
+      // spin() with a sessionId.
+      async spin(spec) {
+        if (!this.runtime) throw new Error("Spin: runtime not set");
+        const profile = profileFor(spec.type);
+        const userId = spec.userId ?? getMasterUserId();
+        const platform = spec.platform ?? "background";
+        const chatId = spec.chatId ?? 0;
+        const agent = spec.agent ?? profile.agent;
+        const timeoutMs = spec.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const terminate = spec.terminateAfter ?? profile.terminateAfter;
+        const persistent = spec.persistent ?? profile.transportMode === "persistent";
+        let session;
+        if (spec.sessionId) {
+          const found = this.sessions.get(spec.sessionId);
+          if (!found) throw new Error(`Spin: sessionId ${spec.sessionId} not found`);
+          if (found.status === "ended") throw new Error(`Spin: sessionId ${spec.sessionId} is ended`);
+          session = found;
+        } else if (spec.active || profile.resolution === "active") {
+          session = this.getActiveSession(userId, platform);
+        } else if (profile.resolution === "singleton") {
+          session = this.getOrCreateVisibleSession(userId, spec.type);
+        } else {
+          const r = allocateSession(this.sessions, this.nextIndex, spec.type, userId, platform, chatId);
+          this.nextIndex = r.nextIndex;
+          session = r.session;
+          if (spec.metadata) session.metadata = { ...spec.metadata };
+        }
+        const stepIndex = (session.messageCount >> 1) + 1;
+        let cardId = spec.cardId;
+        if (cardId === void 0 && spec.goal !== void 0) {
+          cardId = kanbanEnqueue(spec.title ?? spec.goal.slice(0, 80), spec.source ?? "user", void 0, {
+            priority: spec.priority ?? "MEDIUM",
+            type: spec.type,
+            parent_id: spec.parentCardId,
+            deliveryMode: spec.deliveryMode,
+            chatId: chatId ? String(chatId) : void 0,
+            notes: spec.callbackPeer ? JSON.stringify({ callback_peer: spec.callbackPeer }) : void 0,
+            sourcePeer: spec.sourcePeer
+          });
+        }
+        if (cardId !== void 0 && this.canDispatch(spec.type, cardId)) {
+          this.markRunning(spec.type, cardId);
+          kanbanRunning(cardId);
+        }
+        const started = Date.now();
+        try {
+          await profile.beforePrompt?.(session, cardId);
+          let sessionTransport = session.transport;
+          if (persistent && !sessionTransport) {
+            const agentSession = await this.runtime.session(agent, profile.resolution === "active" ? userId : void 0);
+            sessionTransport = agentSession.transport;
+            session.transport = sessionTransport;
+            session.status = "ready";
+          }
+          let prompt = spec.prompt ?? spec.goal ?? "";
+          for (const decorate of profile.decorators) {
+            prompt = await decorate(prompt, { session, cardId, parentCardId: spec.parentCardId });
+          }
+          pushLog(session, `spin type=${spec.type} agent=${agent} step=${stepIndex}`);
+          const exec = sessionTransport ? sessionTransport.sendPrompt(session.id, prompt, spec.imageContent, spec.userId ?? userId) : this.runtime.complete(agent, prompt, { timeoutMs, session: "fresh", maxToolRounds: spec.maxToolRounds });
+          if (!spec.await) {
+            exec.then((r) => this.finishSpin(spec, profile, session, cardId, stepIndex, started, r || "(no output)", terminate)).catch((e) => this.failSpin(spec, profile, session, cardId, stepIndex, started, e, terminate));
+            return { sessionId: session.id, cardId };
+          }
+          const result = await exec || "(no output)";
+          await this.finishSpin(spec, profile, session, cardId, stepIndex, started, result, terminate);
+          return { sessionId: session.id, cardId, result };
+        } catch (err) {
+          await this.failSpin(spec, profile, session, cardId, stepIndex, started, err, terminate);
+          if (spec.await) throw err;
+          return { sessionId: session.id, cardId };
+        }
+      }
+      async finishSpin(spec, profile, session, cardId, stepIndex, started, result, terminate) {
+        const usage = session.transport?.lastUsage?.() ?? this.runtime?.lastUsage ?? null;
+        session.messageCount += 2;
+        session.lastActiveAt = Date.now();
+        session.tokenCount = usage ? usage.input + usage.output : session.tokenCount;
+        pushLog(session, "complete");
+        if (this.memory) {
+          const sid = cardId !== void 0 ? `${spec.type}_card${cardId}` : `${spec.type}_${session.id}`;
+          this.memory.recordMessage({ role: "user", content: spec.goal ?? spec.prompt ?? "", timestamp: Date.now(), userId: "system", sessionId: sid });
+          this.memory.recordMessage({ role: "assistant", content: result, timestamp: Date.now(), userId: "system", sessionId: sid });
+        }
+        if (cardId !== void 0) {
+          let artifacts = [];
+          try {
+            const { drainArtifacts: drainArtifacts2 } = (init_artifact_tools(), __toCommonJS(artifact_tools_exports));
+            artifacts = drainArtifacts2(cardId) ?? [];
+          } catch {
+          }
+          kanbanComplete(cardId, null, result.slice(0, 500));
+          if (spec.callbackPeer) {
+            const card = kanbanGetCard(cardId);
+            fireCallback(spec.callbackPeer, cardId, "done", result.slice(0, 500), void 0, artifacts, card?.tokens_used ?? 0);
+          }
+        }
+        await profile.afterPrompt?.(session, cardId);
+        const stepEvent = {
+          sessionId: session.id,
+          cardId,
+          stepIndex,
+          result,
+          durationMs: Date.now() - started,
+          inputTokens: usage?.input,
+          outputTokens: usage?.output
+        };
+        await spec.onStepComplete?.(stepEvent);
+        this.applyTerminate(session, terminate);
+        if (cardId !== void 0) {
+          this.markDone(spec.type, cardId);
+          this.drainQueued();
+        }
+      }
+      async failSpin(spec, profile, session, cardId, stepIndex, started, err, terminate) {
+        const msg = (err instanceof Error ? err.message : String(err)).slice(0, 1e3);
+        logWarn(TAG, `${spec.type} spin failed: ${msg}`);
+        pushLog(session, `failed: ${msg.slice(0, 80)}`);
+        if (cardId !== void 0) {
+          kanbanRetryOrFail(cardId, msg);
+          if (spec.callbackPeer) fireCallback(spec.callbackPeer, cardId, "failed", void 0, msg);
+        }
+        await profile.afterPrompt?.(session, cardId);
+        const stepEvent = {
+          sessionId: session.id,
+          cardId,
+          stepIndex,
+          error: err instanceof Error ? err : new Error(msg),
+          durationMs: Date.now() - started
+        };
+        await spec.onStepComplete?.(stepEvent);
+        this.applyTerminate(session, terminate);
+        if (cardId !== void 0) {
+          this.markDone(spec.type, cardId);
+          this.drainQueued();
+        }
+      }
+      applyTerminate(session, terminate) {
+        if (terminate === "call") this.sessions.delete(session.id);
+        else if (terminate === "response") {
+          session.status = "ended";
+          session.active = false;
+        }
       }
-      async getOrCreateOrc() {
-        if (this.orcSession?.isReady) return this.orcSession;
-        logInfo(TAG, "Spawning persistent Orc session");
-        this.orcSession = await this.runtime.session("browsie");
-        return this.orcSession;
+      /** #1271: Background one-shot (e.g. compaction summary). Returns the result string. */
+      async dispatchBackground(opts) {
+        const { result } = await this.spin({
+          type: opts.type ?? "S",
+          prompt: opts.prompt,
+          timeoutMs: opts.timeoutMs,
+          agent: opts.agent,
+          await: true
+        });
+        return result ?? "";
       }
-      // ── Dispatch ───────────────────────────────────────────────────────────
+      // ── Dispatch (legacy wrappers, #1271) ───────────────────────────────────
+      // dispatch / dispatchAwait / getOrCreateOrc / sendUserToOrc are thin wrappers
+      // around the unified spin(spec) chokepoint. dispatchBackground is the new
+      // background-only entry point.
       /** #1010: O-type reuses existing session (one Orc). All others create new. */
       getOrCreateVisibleSession(userId, type) {
         if (type === "O") {
@@ -711,6 +883,11 @@ var init_spin = __esm({
         const sub = this.createSubSession(userId, "telegram", type);
         return typeof sub === "string" ? void 0 : sub;
       }
+      /**
+       * @deprecated Use `spin({ type, goal, …, await: false })` instead.
+       * Backward-compat wrapper: creates a kanban card, then dispatches via spin().
+       * Returns the cardId synchronously; the model call runs in the background.
+       */
       dispatch(request) {
         const cardTitle = request.title ?? request.goal.slice(0, 80);
         const cardId = request.cardId ?? kanbanEnqueue(cardTitle, request.source, void 0, {
@@ -722,76 +899,57 @@ var init_spin = __esm({
           chatId: request.chatId,
           sourcePeer: request.sourcePeer
         });
-        if (!this.canDispatch(request.type, cardId)) {
-          logInfo(TAG, `${request.type} card:${cardId} queued (concurrency gate)`);
+        const aliveSessions = [...this.sessions.values()].filter((s) => s.status !== "ended").length;
+        if (aliveSessions >= MAX_TOTAL_SESSIONS || !this.canDispatch(request.type, cardId)) {
+          const reason = aliveSessions >= MAX_TOTAL_SESSIONS ? "session cap" : "concurrency gate";
+          logInfo(TAG, `${request.type} card:${cardId} queued (${reason})`);
           return { cardId };
         }
-        this.markRunning(request.type, cardId);
-        kanbanRunning(cardId);
-        const masterUserId = getMasterUserId();
-        const session = this.getOrCreateVisibleSession(masterUserId, request.type);
-        if (session) {
-          session.name = request.title?.slice(0, 20);
-          pushLog(session, `dispatch card:${cardId}`);
-        }
-        const timeout = request.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-        this.execute(request, cardId, timeout).then((result) => {
-          const { drainArtifacts: drainArtifacts2 } = (init_artifact_tools(), __toCommonJS(artifact_tools_exports));
-          const artifacts = drainArtifacts2(cardId);
-          kanbanComplete(cardId, null, result.slice(0, 500));
-          if (request.callbackPeer) {
-            const card = kanbanGetCard(cardId);
-            fireCallback(request.callbackPeer, cardId, "done", result.slice(0, 500), void 0, artifacts, card?.tokens_used ?? 0);
-          }
-        }).catch((err) => {
-          const msg = (err instanceof Error ? err.message : String(err)).slice(0, 1e3);
-          logWarn(TAG, `${request.type} card:${cardId} failed: ${msg}`);
-          kanbanRetryOrFail(cardId, msg);
-          if (request.callbackPeer) fireCallback(request.callbackPeer, cardId, "failed", void 0, msg);
-        }).finally(() => {
-          this.markDone(request.type, cardId);
-          if (session) {
-            session.status = "ended";
-            session.active = false;
-            pushLog(session, "completed");
-          }
-          this.drainQueued();
+        void this.spin({
+          type: request.type,
+          goal: request.goal,
+          cardId,
+          parentCardId: request.parentCardId,
+          title: request.title,
+          priority: request.priority,
+          source: request.source,
+          deliveryMode: request.deliveryMode,
+          agent: request.agent,
+          timeoutMs: request.timeoutMs,
+          callbackPeer: request.callbackPeer,
+          sourcePeer: request.sourcePeer,
+          chatId: request.chatId ? Number(request.chatId) : void 0,
+          await: false
         });
-        return { cardId, sessionId: session?.id };
+        return { cardId };
       }
+      /**
+       * @deprecated Use `spin({ type, goal, …, await: true })` instead.
+       * Backward-compat wrapper: synchronously dispatches and returns the result.
+       */
       async dispatchAwait(request) {
+        const aliveSessions = [...this.sessions.values()].filter((s) => s.status !== "ended").length;
+        if (aliveSessions >= MAX_TOTAL_SESSIONS) {
+          throw new Error("System busy \u2014 max sessions reached.");
+        }
         if (!this.canDispatch(request.type, 0)) {
           throw new Error(`${request.type} session busy or in cooldown \u2014 skipping`);
         }
-        const cardTitle = request.title ?? request.goal.slice(0, 80);
-        const cardId = request.cardId ?? kanbanEnqueue(cardTitle, request.source, void 0, {
-          priority: request.priority ?? "MEDIUM",
+        const { cardId, result } = await this.spin({
           type: request.type,
-          parent_id: request.parentCardId,
+          goal: request.goal,
+          title: request.title,
+          priority: request.priority,
+          source: request.source,
           deliveryMode: request.deliveryMode,
-          chatId: request.chatId
+          agent: request.agent,
+          timeoutMs: request.timeoutMs,
+          maxToolRounds: request.maxToolRounds,
+          parentCardId: request.parentCardId,
+          chatId: request.chatId ? Number(request.chatId) : void 0,
+          await: true
         });
-        this.markRunning(request.type, cardId);
-        kanbanRunning(cardId);
-        const masterUserId = getMasterUserId();
-        const session = this.getOrCreateVisibleSession(masterUserId, request.type);
-        if (session) {
-          session.name = request.title?.slice(0, 20);
-          pushLog(session, `dispatchAwait card:${cardId}`);
-        }
-        const timeout = request.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-        try {
-          const result = await this.execute(request, cardId, timeout);
-          return { cardId, result };
-        } finally {
-          this.markDone(request.type, cardId);
-          if (session && request.type !== "O") {
-            session.status = "ended";
-            session.active = false;
-            pushLog(session, "completed");
-          }
-          this.drainQueued();
-        }
+        return { cardId, result };
       }
       spawnChild(parentCardId, request) {
         if (request.type === "O") throw new Error("Cannot nest orchestrators");
@@ -825,17 +983,21 @@ var init_spin = __esm({
       checkStaleWorkers() {
         const STALE_MS = parseInt(process.env["WORKER_STALE_MS"] || "300000", 10);
         const now = Date.now();
-        for (const [, cardIds] of this.running) {
-          for (const cardId of cardIds) {
+        let freed = false;
+        for (const [type, cardIds] of this.running) {
+          for (const cardId of [...cardIds]) {
             const card = kanbanGetCard(cardId);
             if (!card || card.status !== "running") continue;
             const lastActivity = (/* @__PURE__ */ new Date(card.updated_at + "Z")).getTime();
             if (now - lastActivity > STALE_MS) {
               logWarn(TAG, `Stale card ${cardId} (${Math.round((now - lastActivity) / 1e3)}s no activity) \u2014 failing`);
               kanbanFail(cardId, "stale \u2014 no activity");
+              this.markDone(type, cardId);
+              freed = true;
             }
           }
         }
+        if (freed) this.drainQueued();
       }
       /** #613: Prune .trash/ entries older than 7 days (~hourly). */
       pruneSkillTrash() {
@@ -907,7 +1069,7 @@ var init_spin = __esm({
       async pollRemoteCards() {
         const remoteCards = kanbanList("running", "status").filter((c) => c.type === "remote");
         if (remoteCards.length === 0) return;
-        const { getPeerTransport } = await import("./peer-transport-I6JPLFZ2.js");
+        const { getPeerTransport } = await import("./peer-transport-SI7I72DB.js");
         const transport = getPeerTransport();
         const REMOTE_MAX_AGE_MS = 15 * 60 * 1e3;
         for (const card of remoteCards) {
@@ -941,102 +1103,6 @@ var init_spin = __esm({
         this.running.get(type)?.delete(cardId);
         if (type === "H") this._lastHealerDoneAt = Date.now();
       }
-      async execute(request, cardId, timeoutMs) {
-        if (!this.runtime) throw new Error("Spin: runtime not set");
-        if (request.type === "O") return this.executeOrc(request, cardId, timeoutMs);
-        const agentName = request.agent ?? typeAgent(request.type);
-        logInfo(TAG, `\u25B6 ${request.type} card:${cardId} agent=${agentName}`);
-        try {
-          const { buildSoulBundle } = await import("./soul-bundle-VWAVHCZ6.js");
-          const bundle = buildSoulBundle(request.type);
-          let fullPrompt = bundle ? `${bundle}
-
----
-
-${request.goal}` : request.goal;
-          if (request.type === "W" || request.type === "T") {
-            const { channelUnread } = await import("./kanban-channel-IJ52OMNA.js");
-            const workerName = `Worker-${String(cardId).padStart(2, "0")}`;
-            const parentCard = request.parentCardId ?? cardId;
-            const msgs = channelUnread(parentCard, workerName);
-            if (msgs.length > 0) {
-              const lines = msgs.map((m) => `[${m.from_agent}\u2192${m.to_agent}]${m.directive ? " \u26A1" : ""} ${m.message}`);
-              fullPrompt = `[CHANNEL \u2014 ${msgs.length} message(s) for ${workerName}]
-${lines.join("\n")}
-[/CHANNEL]
-
-${fullPrompt}`;
-            }
-          }
-          const result = await this.runtime.complete(agentName, fullPrompt, { timeoutMs, session: "fresh" }) || "(no output)";
-          if (this.memory) {
-            const sid = `${request.type}_card${cardId}`;
-            this.memory.recordMessage({ role: "user", content: request.goal, timestamp: Date.now(), userId: "system", sessionId: sid });
-            this.memory.recordMessage({ role: "assistant", content: result, timestamp: Date.now(), userId: "system", sessionId: sid });
-          }
-          return result;
-        } finally {
-        }
-      }
-      async executeOrc(request, cardId, timeoutMs) {
-        const { updateBridgeLockField } = await import("./bridge-lock-transport-4ZH7QTJP.js");
-        const { setActiveOrcCard } = await import("./orc-tools-4CHEFWSN.js");
-        updateBridgeLockField("orc_active", cardId);
-        setActiveOrcCard(cardId);
-        const orc = await this.getOrCreateOrc();
-        logInfo(TAG, `\u25B6 O card:${cardId} (persistent Orc)`);
-        let orcSessionKey = "orc:project";
-        for (const [, s] of this.sessions) {
-          if (s.id.includes("_O_") && s.status !== "ended") {
-            s.transport = orc.transport;
-            s.status = "ready";
-            orcSessionKey = s.id;
-            break;
-          }
-        }
-        const timer = setTimeout(() => {
-          logWarn(TAG, `\u23F1\uFE0F O card:${cardId} timed out`);
-        }, timeoutMs);
-        try {
-          const { buildSoulBundle } = await import("./soul-bundle-VWAVHCZ6.js");
-          const bundle = buildSoulBundle("O");
-          const { localDateTime } = await import("./local-time-HT7A7OGW.js");
-          const context = `[CONTEXT \u2014 do not respond to this section]
-[PROJECT] card #${cardId}
-[CURRENT TIME] ${localDateTime()}
-[/CONTEXT]
-
-`;
-          let fullPrompt = context + (bundle ? `${bundle}
-
----
-
-${request.goal}` : request.goal);
-          const { drainOrcNotifications } = await import("./spin-notifications-SE2HVZI7.js");
-          const notifications = drainOrcNotifications(cardId);
-          if (notifications.length) fullPrompt = notifications.join("\n") + "\n\n" + fullPrompt;
-          const { channelUnread } = await import("./kanban-channel-IJ52OMNA.js");
-          const orcMsgs = channelUnread(cardId, "Orc");
-          if (orcMsgs.length > 0) {
-            const lines = orcMsgs.map((m) => `[${m.from_agent}\u2192${m.to_agent}]${m.directive ? " \u26A1" : ""} ${m.message}`);
-            fullPrompt = `[CHANNEL \u2014 ${orcMsgs.length} message(s)]
-${lines.join("\n")}
-[/CHANNEL]
-
-${fullPrompt}`;
-          }
-          const result = await orc.sendPrompt(orcSessionKey, fullPrompt) || "(no output)";
-          if (this.memory) {
-            this.memory.recordMessage({ role: "user", content: request.goal, timestamp: Date.now(), userId: "system", sessionId: orcSessionKey });
-            this.memory.recordMessage({ role: "assistant", content: result, timestamp: Date.now(), userId: "system", sessionId: orcSessionKey });
-          }
-          return result;
-        } finally {
-          clearTimeout(timer);
-          updateBridgeLockField("orc_active", null);
-          setActiveOrcCard(null);
-        }
-      }
     };
     spin = new Spin();
   }
@@ -1053,4 +1119,4 @@ export {
   spin_exports,
   init_spin
 };
-//# sourceMappingURL=chunk-ONBF5DDU.js.map
+//# sourceMappingURL=chunk-L72RIPEC.js.map