@popcraft/kit 0.53.3 → 0.53.5

package/dist/chunks/runner-5YTIWTPP.js

@@ -0,0 +1,2900 @@
+import { createRequire as __popcraftRequire } from 'node:module';
+import { fileURLToPath as __popcraftPath } from 'node:url';
+import { dirname as __popcraftDirname } from 'node:path';
+const require = __popcraftRequire(import.meta.url);
+const __filename = __popcraftPath(import.meta.url);
+const __dirname = __popcraftDirname(__filename);
+import {
+  ALL_TOOLS,
+  SUBAGENT_FRAMING,
+  activeMessages,
+  agentModel,
+  allProfiles,
+  allSkills,
+  appendMessage,
+  findProfile,
+  findSkill,
+  mentionContext,
+  newId,
+  persistThreads,
+  profileIndexLine,
+  rememberCheckpoint,
+  setParts,
+  setTodos,
+  skillIndexLine,
+  updateActiveThread,
+  updateMessage,
+  useAgentStore
+} from "./chunk-QMHR62B6.js";
+import "./chunk-LRF3JAZW.js";
+import {
+  registerBuiltinTools
+} from "./chunk-5CG26ML2.js";
+import {
+  registerDangerousCommands
+} from "./chunk-ESUEH4WJ.js";
+import "./chunk-UTDF3XDV.js";
+import "./chunk-7CSTSDHU.js";
+import "./chunk-ZLWN6LBH.js";
+import "./chunk-Q7EITIAT.js";
+import "./chunk-X36CCQ76.js";
+import {
+  editBlockReason,
+  editorToolContext
+} from "./chunk-5F5AEM7E.js";
+import "./chunk-KOAEKWIA.js";
+import "./chunk-U7FLEMSS.js";
+import "./chunk-YMGUPGGX.js";
+import {
+  buildDesignContext,
+  joinWithin
+} from "./chunk-3QD6CCCN.js";
+import "./chunk-FH4HHWJT.js";
+import "./chunk-A6XXXQQO.js";
+import "./chunk-ATSLWELA.js";
+import "./chunk-6B6ULEDJ.js";
+import "./chunk-G27HUNKQ.js";
+import {
+  HYPERY_PAYMENT_SOURCE_HEADER,
+  paymentSourceHeaders
+} from "./chunk-G53FIV7D.js";
+import {
+  aiAvailability,
+  effectiveChatModel,
+  useAiStore
+} from "./chunk-A4CGHVJP.js";
+import {
+  allTools,
+  getTool,
+  runTool,
+  toolSpecs
+} from "./chunk-ENO5QFID.js";
+import {
+  external_exports
+} from "./chunk-VOOUF5TT.js";
+import {
+  provideAgentCapability
+} from "./chunk-57ZPSFB4.js";
+import {
+  defineCommand
+} from "./chunk-ZYK65XJJ.js";
+import "./chunk-HS4CR6HU.js";
+import "./chunk-4LOAHKDJ.js";
+import "./chunk-4JTHODXO.js";
+import "./chunk-DE2GVUWC.js";
+import "./chunk-OWWBFGCR.js";
+import "./chunk-LB26H7IY.js";
+import "./chunk-ZLTGINSH.js";
+import "./chunk-UCNBKWJQ.js";
+import "./chunk-BKRXB4FD.js";
+import "./chunk-33WF4AEY.js";
+import "./chunk-NBFZY6QK.js";
+import "./chunk-YZKSEJHZ.js";
+import "./chunk-3OXHJA4W.js";
+import "./chunk-OE2LGHLL.js";
+import "./chunk-T4R6MNN5.js";
+import "./chunk-IYAH6IB3.js";
+import "./chunk-633NXQV2.js";
+import "./chunk-YD7Z3PGN.js";
+import "./chunk-3DMEPFEZ.js";
+import "./chunk-EYGE2XSW.js";
+import "./chunk-K65QFCH4.js";
+import "./chunk-PTWMYRV4.js";
+import "./chunk-EUF3VFBW.js";
+import {
+  activeHyperyTeamId
+} from "./chunk-C743GDSN.js";
+import "./chunk-SY3KZGGN.js";
+import "./chunk-3PRZ5XSZ.js";
+import "./chunk-SSIJMUZP.js";
+import "./chunk-LGPRILVA.js";
+import {
+  useEditorStore
+} from "./chunk-NGYWHBRO.js";
+import "./chunk-OZJ7KASI.js";
+import "./chunk-PMLSPVLR.js";
+import "./chunk-76I6DIEM.js";
+import "./chunk-ZWKNYWUL.js";
+import "./chunk-ISEGXWC3.js";
+import "./chunk-VXB34VXD.js";
+import "./chunk-OLQTCVWP.js";
+import "./chunk-EOPTDAPJ.js";
+import "./chunk-UM2WBM37.js";
+import "./chunk-BNQZIEZX.js";
+import "./chunk-GUGOVTVN.js";
+import "./chunk-R5O3E5HI.js";
+import "./chunk-SW4F3FK5.js";
+import "./chunk-CBXDTH5N.js";
+import "./chunk-DV7XWPVL.js";
+import "./chunk-QLJLPV5R.js";
+import "./chunk-LDUTRSTJ.js";
+import "./chunk-7Y45PGYJ.js";
+import "./chunk-NM4EL7ES.js";
+import "./chunk-CEVTHE4E.js";
+import "./chunk-M7WRXM6Y.js";
+import {
+  HYPERY_GATEWAY_URL,
+  accessToken
+} from "./chunk-L47OWSXA.js";
+import "./chunk-C3PEAMN4.js";
+import "./chunk-7EVFVLIZ.js";
+import "./chunk-OQZFD4BD.js";
+import "./chunk-HUBA4GXU.js";
+import {
+  ToolError,
+  registerCommand
+} from "./chunk-ZNG4F4F3.js";
+import "./chunk-RSS4ZNKX.js";
+import "./chunk-SBZ7X4XF.js";
+import "./chunk-ZGRH6TWS.js";
+import "./chunk-5NXWMSML.js";
+import "./chunk-M5GKWOJL.js";
+import "./chunk-4DODDLBE.js";
+import "./chunk-ZWGSFZFE.js";
+import "./chunk-PLHJR3CN.js";
+import "./chunk-RK3HJC3E.js";
+import "./chunk-A54HJQ6T.js";
+import "./chunk-7DATU5VX.js";
+import "./chunk-EKHLRZ2V.js";
+import "./chunk-6YZC5UXW.js";
+import "./chunk-WNTU3TLN.js";
+import "./chunk-ANIZ3AGS.js";
+import "./chunk-E66ZNPHF.js";
+import "./chunk-3MVD3KZ3.js";
+import "./chunk-INZZZ5M6.js";
+import "./chunk-ESA4AFPU.js";
+import "./chunk-6R3NJFQL.js";
+import "./chunk-QWXV3M43.js";
+import "./chunk-TFCXBKDU.js";
+import "./chunk-VUGLVNQF.js";
+import "./chunk-KATP7TSA.js";
+import "./chunk-TAWWNEV3.js";
+import "./chunk-PU2DNOWP.js";
+import "./chunk-QNR4D25F.js";
+import "./chunk-HL4BM2AW.js";
+import "./chunk-CHJBZFDR.js";
+import "./chunk-5RHX7374.js";
+import "./chunk-QV42WAC3.js";
+import "./chunk-EMRMDF3C.js";
+import "./chunk-W2MSYW6G.js";
+import "./chunk-YR2RU7SP.js";
+import "./chunk-MN4EEFZJ.js";
+import "./chunk-J7N5AJ7Q.js";
+import "./chunk-BT3Q43SU.js";
+import "./chunk-42I5OWW5.js";
+import "./chunk-L4HYVWDW.js";
+import "./chunk-FR4I6EP4.js";
+import "./chunk-KRGFO6BM.js";
+import "./chunk-AVWA3JAF.js";
+import "./chunk-2SPBA2GP.js";
+import "./chunk-GDOV5QOD.js";
+import "./chunk-V36EJ24Y.js";
+import "./chunk-KBXTF45P.js";
+import "./chunk-KIVW57QH.js";
+import "./chunk-GKKSGKVP.js";
+import "./chunk-SAQ2W6VJ.js";
+import "./chunk-R77FKJO6.js";
+import "./chunk-WG5UENME.js";
+import "./chunk-KASBBLQC.js";
+import "./chunk-MRON56GU.js";
+import "./chunk-HZ3C272Q.js";
+import "./chunk-PLZLKHOI.js";
+import "./chunk-UT3VNYCC.js";
+import "./chunk-OM5VD3WH.js";
+import "./chunk-ACHG2HMK.js";
+import "./chunk-P675L74X.js";
+import "./chunk-HEQLOQAN.js";
+import "./chunk-GFBUI5Q4.js";
+import "./chunk-HUYCKP2F.js";
+import "./chunk-WLPGSUI2.js";
+import "./chunk-637CSND3.js";
+import "./chunk-EGSRWLGD.js";
+import "./chunk-IM6WH7GK.js";
+import "./chunk-3TPXU2PF.js";
+import "./chunk-PQID5H2U.js";
+import "./chunk-UECFXKFB.js";
+import "./chunk-ASE4MVE3.js";
+import "./chunk-2ZG5YVYA.js";
+import "./chunk-E4OKHTNS.js";
+import "./chunk-KQKO2ZZ2.js";
+import "./chunk-CWLO43FG.js";
+import {
+  AI_LIMITS,
+  init_limits,
+  str
+} from "./chunk-NIEUIAKQ.js";
+import "./chunk-XZXB3HB5.js";
+import "./chunk-UGG5XQHU.js";
+import "./chunk-SHK6YV6A.js";
+import "./chunk-M5WJSLHT.js";
+import "./chunk-MVIYMAMH.js";
+import "./chunk-NWNYARD6.js";
+import "./chunk-WBBHPF5E.js";
+import "./chunk-T2SCC6PU.js";
+import "./chunk-25VZ3OBK.js";
+import "./chunk-M2H3GLK2.js";
+import "./chunk-ALV6EOJF.js";
+import "./chunk-Y7TG6HTD.js";
+import "./chunk-SJ63JCL4.js";
+import {
+  init_define_POPCRAFT_COMPONENT_IDS
+} from "./chunk-WKDVCZ45.js";
+import "./chunk-LJSVREWM.js";
+
+// lib/agent/runner.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+
+// lib/agent/gateway.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+
+// node_modules/.pnpm/@hyperyai+sdk@2.1.0_@types+react-dom@19.3.0_@types+react@19.3.0__@types+react@19.3.0_re_62022f8c0abbfd4c405f5fb20b5aa9ec/node_modules/@hyperyai/sdk/dist/agents/index.js
+init_define_POPCRAFT_COMPONENT_IDS();
+
+// node_modules/.pnpm/@hyperyai+sdk@2.1.0_@types+react-dom@19.3.0_@types+react@19.3.0__@types+react@19.3.0_re_62022f8c0abbfd4c405f5fb20b5aa9ec/node_modules/@hyperyai/sdk/dist/agents/core/hypery-model.js
+init_define_POPCRAFT_COMPONENT_IDS();
+var delay = ((ms) => new Promise((settle) => setTimeout(() => settle(null), Math.max(0, Number(ms) || 0))));
+var utf8Complete = ((b) => {
+  if (!Array.isArray(b)) return null;
+  const n = b.length;
+  for (let i = n - 1; i >= Math.max(0, n - 3); i--) {
+    const c = b[i];
+    if ((c & 192) === 128) continue;
+    const len = c <= 127 ? 1 : c >= 194 && c <= 223 ? 2 : c >= 224 && c <= 239 ? 3 : c >= 240 && c <= 244 ? 4 : 1;
+    return n - i < len ? i : n;
+  }
+  return n;
+});
+var utf8Decode = ((b) => typeof b === "string" ? b : Array.isArray(b) ? new TextDecoder().decode(Uint8Array.from(b)) : null);
+var MAX_REQUEST_BYTES = 44e5;
+var DEFAULT_IDLE_TIMEOUT_MS = 18e4;
+var HYPERY_TEAM_HEADER = "x-hypery-active-organization-id";
+var HYPERY_PAYMENT_SOURCE_HEADER2 = "x-hypery-payment-source";
+function agentModelError(message, code, status) {
+  {
+    return { name: "AgentModelError", message, code: code ?? "ai_upstream", status: ((__v) => __v == null ? "null" : typeof __v)(status) === "number" ? status : 502 };
+  }
+}
+async function resolve(v) {
+  {
+    if (((__v) => __v == null ? "null" : typeof __v)(v) === "function") {
+      return await (v() ?? null);
+    }
+    return v ?? null;
+  }
+}
+function errorCodeFor(status, payload) {
+  {
+    if (payload != null && ((__v) => __v == null ? "null" : typeof __v)(payload) === "object" && payload.error != null && ((__v) => __v == null ? "null" : typeof __v)(payload.error) === "object" && ((__v) => __v == null ? "null" : typeof __v)(payload.error.code) === "string") {
+      return payload.error.code;
+    }
+    if (status === 401) {
+      return "ai_reauth";
+    }
+    if (status === 402) {
+      return "ai_credits";
+    }
+    if (status === 403) {
+      return "ai_scope";
+    }
+    if (status === 429) {
+      return "ai_rate_limited";
+    }
+    return "ai_upstream";
+  }
+}
+function streamErrorMessage(payload, fallback) {
+  {
+    let otherwise = fallback ?? "The AI request failed.";
+    if (payload == null || ((__v) => __v == null ? "null" : typeof __v)(payload) !== "object") {
+      return otherwise;
+    }
+    let err = payload.error ?? null;
+    if (((__v) => __v == null ? "null" : typeof __v)(err) === "string" && (err.trim() ?? null) !== "") {
+      return err;
+    }
+    let message = err != null && ((__v) => __v == null ? "null" : typeof __v)(err) === "object" ? err.message ?? null : null;
+    if (message == null) {
+      message = payload.message ?? null;
+    }
+    return ((__v) => __v == null ? "null" : typeof __v)(message) === "string" && (message.trim() ?? null) !== "" ? message : otherwise;
+  }
+}
+function createStreamAccumulator() {
+  {
+    let buffer = "";
+    let text = "";
+    let reasoning = "";
+    let sawDone = false;
+    let calls = /* @__PURE__ */ new Map() ?? null;
+    let order = [];
+    return { push: (part) => {
+      {
+        buffer = buffer + part;
+        let out = [];
+        let nl = buffer.indexOf("\n") ?? null;
+        while (nl >= 0) {
+          let line = (buffer.slice(0, nl) ?? null).trim() ?? null;
+          buffer = buffer.slice(nl + 1) ?? null;
+          nl = buffer.indexOf("\n") ?? null;
+          if (!(line.startsWith("data:") ?? null)) {
+            continue;
+          }
+          let data = (line.slice(5) ?? null).trim() ?? null;
+          if (data === "") {
+            continue;
+          }
+          if (data === "[DONE]") {
+            sawDone = true;
+            continue;
+          }
+          let chunk = null;
+          try {
+            {
+              chunk = JSON.parse(data) ?? null;
+            }
+          } catch (e) {
+            {
+              continue;
+            }
+          }
+          if (chunk == null || ((__v) => __v == null ? "null" : typeof __v)(chunk) !== "object") {
+            continue;
+          }
+          if (chunk.error) {
+            let code = ((__v) => __v == null ? "null" : typeof __v)(chunk.error) === "object" && ((__v) => __v == null ? "null" : typeof __v)(chunk.error.code) === "string" ? chunk.error.code : "ai_upstream";
+            throw agentModelError(streamErrorMessage(chunk, null) ?? null, code, 502) ?? null;
+          }
+          let choice = (Array.isArray(chunk.choices) ?? null) && chunk.choices.length > 0 ? chunk.choices[0] ?? null : null;
+          let delta = choice != null ? choice.delta ?? null : null;
+          if (delta == null) {
+            continue;
+          }
+          if (((__v) => __v == null ? "null" : typeof __v)(delta.content) === "string" && delta.content !== "") {
+            text = text + delta.content;
+            out.push({ textDelta: delta.content }) ?? null;
+          }
+          let r = ((__v) => __v == null ? "null" : typeof __v)(delta.reasoning) === "string" ? delta.reasoning : ((__v) => __v == null ? "null" : typeof __v)(delta.reasoning_content) === "string" ? delta.reasoning_content : "";
+          if (r !== "") {
+            reasoning = reasoning + r;
+            out.push({ reasoningDelta: r }) ?? null;
+          }
+          for (const tc of Array.isArray(delta.tool_calls) ?? null ? delta.tool_calls : []) {
+            let i = ((__v) => __v == null ? "null" : typeof __v)(tc.index) === "number" ? tc.index : order.length > 0 ? order[order.length - 1] ?? null : 0;
+            if (!(calls.has(i) ?? null)) {
+              calls.set(i, { id: null, name: "", arguments: "" }) ?? null;
+              order.push(i) ?? null;
+            }
+            let call = calls.get(i) ?? null;
+            if (((__v) => __v == null ? "null" : typeof __v)(tc.id) === "string" && tc.id !== "") {
+              call.id = tc.id;
+            }
+            let f = tc["function"] ?? null ?? null;
+            if (f != null && ((__v) => __v == null ? "null" : typeof __v)(f.name) === "string") {
+              call.name = call.name + f.name;
+            }
+            if (f != null && ((__v) => __v == null ? "null" : typeof __v)(f.arguments) === "string" && f.arguments !== "") {
+              call.arguments = call.arguments + f.arguments;
+              out.push({ toolProgress: { index: i, name: call.name, bytes: call.arguments.length, arguments: call.arguments } }) ?? null;
+            }
+          }
+        }
+        return out;
+      }
+    }, result: () => {
+      {
+        let toolCalls = [];
+        let n = 0;
+        for (const i of order) {
+          let c = calls.get(i) ?? null;
+          if (c.name !== "") {
+            toolCalls.push({ id: c.id ?? "call_" + (String(n) ?? null), name: c.name, arguments: c.arguments }) ?? null;
+          }
+          n = n + 1;
+        }
+        return { text, reasoning, sawDone, toolCalls };
+      }
+    } };
+  }
+}
+function appendBytes(pending, chunk) {
+  {
+    let out = pending.slice() ?? null;
+    let i = 0;
+    while (i < chunk.length) {
+      out.push(chunk[i] ?? null) ?? null;
+      i = i + 1;
+    }
+    return out;
+  }
+}
+function callHook(hooks, name, value) {
+  {
+    if (hooks == null || ((__v) => __v == null ? "null" : typeof __v)(hooks) !== "object") {
+      return;
+    }
+    let h = hooks[name] ?? null;
+    if (((__v) => __v == null ? "null" : typeof __v)(h) === "function") {
+      h(value) ?? null;
+    }
+  }
+}
+function createHyperyModel(opts) {
+  {
+    let idleMs = ((__v) => __v == null ? "null" : typeof __v)(opts.idleTimeoutMs) === "number" ? opts.idleTimeoutMs : DEFAULT_IDLE_TIMEOUT_MS;
+    let limit = ((__v) => __v == null ? "null" : typeof __v)(opts.maxRequestBytes) === "number" ? opts.maxRequestBytes : MAX_REQUEST_BYTES;
+    let base = ((__v) => __v == null ? "null" : typeof __v)(opts.gatewayUrl) === "string" && opts.gatewayUrl !== "" ? opts.gatewayUrl : "https://hypery.ai";
+    if (base.endsWith("/") ?? null) {
+      base = base.slice(0, base.length - 1) ?? null;
+    }
+    return async (messages, tools, hooks, signal, req) => {
+      {
+        let token = await (resolve(opts.token) ?? null);
+        if (((__v) => __v == null ? "null" : typeof __v)(token) !== "string" || token === "") {
+          throw agentModelError("Sign in to Hypery to use the agent.", "ai_reauth", 401) ?? null;
+        }
+        let model = await (resolve(opts.model) ?? null);
+        let team = await (resolve(opts.team) ?? null);
+        let paymentSource = await (resolve(opts.paymentSource) ?? null);
+        let hasTools = (Array.isArray(tools) ?? null) && tools.length > 0;
+        let request = { model, messages, stream: true, max_tokens: ((__v) => __v == null ? "null" : typeof __v)(opts.maxTokens) === "number" ? opts.maxTokens : hasTools ? 16384 : 4096 };
+        if (((__v) => __v == null ? "null" : typeof __v)(opts.temperature) === "number") {
+          request.temperature = opts.temperature;
+        }
+        if (hasTools) {
+          request.tools = tools;
+          let choice = req != null && ((__v) => __v == null ? "null" : typeof __v)(req) === "object" ? req.toolChoice ?? null : null;
+          request.tool_choice = choice != null ? choice : "auto";
+        }
+        let body = JSON.stringify(request) ?? null;
+        if (body.length > limit) {
+          throw agentModelError("This message is too large to send (" + ((body.length / 1e6).toFixed(1) ?? null) + " MB with its images). Send fewer or smaller images.", "too_large", 413) ?? null;
+        }
+        let headers = { Authorization: "Bearer " + token, "Content-Type": "application/json", Accept: "text/event-stream" };
+        if (((__v) => __v == null ? "null" : typeof __v)(team) === "string" && team !== "") {
+          headers[HYPERY_TEAM_HEADER] = team;
+        }
+        if (((__v) => __v == null ? "null" : typeof __v)(paymentSource) === "string" && paymentSource !== "") {
+          headers[HYPERY_PAYMENT_SOURCE_HEADER2] = paymentSource;
+        }
+        let init = { method: "POST", headers, body };
+        if (signal != null && ((__v) => __v == null ? "null" : typeof __v)(signal.addEventListener) === "function") {
+          init.signal = signal;
+        }
+        let res = null;
+        try {
+          {
+            res = await (opts.fetch(base + "/api/v1/chat/completions", init) ?? null);
+          }
+        } catch (err) {
+          {
+            if (err != null && ((__v) => __v == null ? "null" : typeof __v)(err) === "object" && err.name === "AbortError") {
+              throw err;
+            }
+            throw agentModelError("Could not reach Hypery. Check your connection.", "network", 0) ?? null;
+          }
+        }
+        if (res.ok !== true || res.body == null) {
+          let text = "";
+          try {
+            {
+              text = await (res.text() ?? null);
+            }
+          } catch (e) {
+            {
+              text = "";
+            }
+          }
+          let payload = text;
+          try {
+            {
+              payload = JSON.parse(text) ?? null;
+            }
+          } catch (e) {
+            {
+              payload = text;
+            }
+          }
+          throw agentModelError(streamErrorMessage(payload, "The AI request failed (" + (String(res.status) ?? null) + ").") ?? null, errorCodeFor(res.status, payload) ?? null, res.status) ?? null;
+        }
+        let acc = createStreamAccumulator() ?? null;
+        let reader = res.body.getReader() ?? null;
+        let pending = [];
+        let stopReading = () => {
+          {
+            if (((__v) => __v == null ? "null" : typeof __v)(reader.cancel) === "function") {
+              try {
+                {
+                  reader.cancel() ?? null;
+                }
+              } catch (e) {
+                {
+                }
+              }
+            }
+          }
+        };
+        while (true) {
+          if (signal != null && signal.aborted === true) {
+            stopReading() ?? null;
+            throw { name: "AbortError", message: "The request was stopped." };
+          }
+          let next = await (Promise.race([reader.read() ?? null, delay(idleMs) ?? null]) ?? null);
+          if (next == null) {
+            stopReading() ?? null;
+            throw agentModelError("The model stopped responding.", "ai_timeout", 504) ?? null;
+          }
+          if (next.done === true) {
+            break;
+          }
+          if (next.value == null) {
+            continue;
+          }
+          let bytes = appendBytes(pending, next.value) ?? null;
+          let whole = utf8Complete(bytes) ?? null;
+          pending = bytes.slice(whole) ?? null;
+          let events = [];
+          try {
+            {
+              events = acc.push(utf8Decode(bytes.slice(0, whole) ?? null) ?? null) ?? null;
+            }
+          } catch (err) {
+            {
+              stopReading() ?? null;
+              throw err;
+            }
+          }
+          for (const e of events) {
+            if (((__v) => __v == null ? "null" : typeof __v)(e.textDelta) === "string") {
+              callHook(hooks, "onTextDelta", e.textDelta) ?? null;
+            }
+            if (((__v) => __v == null ? "null" : typeof __v)(e.reasoningDelta) === "string") {
+              callHook(hooks, "onReasoningDelta", e.reasoningDelta) ?? null;
+            }
+            if (e.toolProgress != null) {
+              callHook(hooks, "onToolProgress", e.toolProgress) ?? null;
+            }
+          }
+        }
+        if (pending.length > 0) {
+          acc.push(utf8Decode(pending) ?? null) ?? null;
+        }
+        acc.push("\n") ?? null;
+        let r = acc.result() ?? null;
+        if (!r.sawDone && r.text === "" && r.toolCalls.length === 0) {
+          throw agentModelError("The response was cut off before it started. Try again.", "ai_upstream", 502) ?? null;
+        }
+        return { text: r.text, reasoning: r.reasoning, toolCalls: r.toolCalls };
+      }
+    };
+  }
+}
+
+// node_modules/.pnpm/@hyperyai+sdk@2.1.0_@types+react-dom@19.3.0_@types+react@19.3.0__@types+react@19.3.0_re_62022f8c0abbfd4c405f5fb20b5aa9ec/node_modules/@hyperyai/sdk/dist/agents/core/runtime.js
+init_define_POPCRAFT_COMPONENT_IDS();
+
+// node_modules/.pnpm/@hyperyai+sdk@2.1.0_@types+react-dom@19.3.0_@types+react@19.3.0__@types+react@19.3.0_re_62022f8c0abbfd4c405f5fb20b5aa9ec/node_modules/@hyperyai/sdk/dist/agents/core/loop.js
+init_define_POPCRAFT_COMPONENT_IDS();
+
+// node_modules/.pnpm/@hyperyai+sdk@2.1.0_@types+react-dom@19.3.0_@types+react@19.3.0__@types+react@19.3.0_re_62022f8c0abbfd4c405f5fb20b5aa9ec/node_modules/@hyperyai/sdk/dist/agents/core/context.js
+init_define_POPCRAFT_COMPONENT_IDS();
+var RENDER_TURN_PREFIX = "Result of ";
+var KEEP_IMAGE_TURNS = 2;
+function sizeOf(messages) {
+  {
+    return (JSON.stringify(messages) ?? null).length;
+  }
+}
+function isRenderTurn(m) {
+  {
+    if (m.role !== "user" || !(Array.isArray(m.content) ?? null) || m.content.length === 0) {
+      return false;
+    }
+    let first = m.content[0] ?? null;
+    return first.type === "text" && ((__v) => __v == null ? "null" : typeof __v)(first.text) === "string" && (first.text.startsWith(RENDER_TURN_PREFIX) ?? null);
+  }
+}
+function countImages(parts) {
+  {
+    return (parts.filter((p) => {
+      {
+        return p.type === "image_url";
+      }
+    }) ?? null).length;
+  }
+}
+function textOf(parts) {
+  {
+    return ((parts.filter((p) => {
+      {
+        return p.type === "text" && ((__v) => __v == null ? "null" : typeof __v)(p.text) === "string" && p.text !== "";
+      }
+    }) ?? null).map((p) => {
+      {
+        return p.text;
+      }
+    }) ?? null).join(" ") ?? null;
+  }
+}
+function imagesLabel(n) {
+  {
+    return n === 1 ? "image" : (String(n) ?? null) + " images";
+  }
+}
+function pruneOldImages(messages, keep) {
+  {
+    let limit = ((__v) => __v == null ? "null" : typeof __v)(keep) === "number" ? keep : KEEP_IMAGE_TURNS;
+    let seen = 0;
+    let i = messages.length - 1;
+    while (i >= 0) {
+      let m = messages[i] ?? null;
+      if ((isRenderTurn(m) ?? null) && (countImages(m.content) ?? null) > 0) {
+        seen = seen + 1;
+        if (seen > limit) {
+          let note = (textOf(m.content) ?? null) + " [" + (imagesLabel(countImages(m.content) ?? null) ?? null) + " omitted: superseded by a later view.]";
+          messages[i] = { ...m, content: note.trim() ?? null };
+        }
+      }
+      i = i - 1;
+    }
+  }
+}
+function fitImagesToBudget(messages, budget) {
+  {
+    if ((sizeOf(messages) ?? null) <= budget) {
+      return;
+    }
+    let i = 0;
+    while (i < messages.length && (sizeOf(messages) ?? null) > budget) {
+      let m = messages[i] ?? null;
+      if (isRenderTurn(m) ?? null) {
+        let parts = m.content.slice() ?? null;
+        let dropped = 0;
+        let j = parts.length - 1;
+        while (j >= 0 && (sizeOf(messages) ?? null) > budget) {
+          if ((parts[j] ?? null).type === "image_url") {
+            parts.splice(j, 1) ?? null;
+            dropped = dropped + 1;
+            messages[i] = { ...m, content: parts.slice() ?? null };
+          }
+          j = j - 1;
+        }
+        if (dropped > 0) {
+          let label = dropped === 1 ? "1 image" : (String(dropped) ?? null) + " images";
+          let note = (textOf(parts) ?? null) + " [" + label + " omitted to keep the request under the size limit.]";
+          messages[i] = { ...m, content: note.trim() ?? null };
+        }
+      }
+      i = i + 1;
+    }
+  }
+}
+function safeTailStart(messages, want) {
+  {
+    let i = Math.max(1, messages.length - want) ?? null;
+    while (i < messages.length && (messages[i] ?? null).role === "tool") {
+      i = i + 1;
+    }
+    return i;
+  }
+}
+async function compactTranscript(messages, opts) {
+  {
+    if ((sizeOf(messages) ?? null) <= opts.maxChars) {
+      return false;
+    }
+    let head = messages.length > 0 && (messages[0] ?? null).role === "system" ? 1 : 0;
+    let firstUser = -1;
+    let k = head;
+    while (k < messages.length && firstUser < 0) {
+      if ((messages[k] ?? null).role === "user") {
+        firstUser = k;
+      }
+      k = k + 1;
+    }
+    let keepFrom = firstUser >= 0 ? firstUser + 1 : head;
+    let tail = safeTailStart(messages, ((__v) => __v == null ? "null" : typeof __v)(opts.keepRecent) === "number" ? opts.keepRecent : 12) ?? null;
+    if (tail <= keepFrom) {
+      return false;
+    }
+    let dropped = messages.slice(keepFrom, tail) ?? null;
+    let summary = "";
+    if (((__v) => __v == null ? "null" : typeof __v)(opts.summarize) === "function") {
+      try {
+        {
+          summary = await (opts.summarize(dropped) ?? null);
+        }
+      } catch (e) {
+        {
+          summary = "";
+        }
+      }
+    }
+    let content = summary !== "" ? "Summary of the earlier work in this session (the details were compacted to save space):\n" + summary : "[" + (String(dropped.length) ?? null) + " earlier messages were compacted to save space. Look again at anything you need from them.]";
+    messages.splice(keepFrom, dropped.length, { role: "user", content }) ?? null;
+    return true;
+  }
+}
+
+// node_modules/.pnpm/@hyperyai+sdk@2.1.0_@types+react-dom@19.3.0_@types+react@19.3.0__@types+react@19.3.0_re_62022f8c0abbfd4c405f5fb20b5aa9ec/node_modules/@hyperyai/sdk/dist/agents/core/loop.js
+var DEFAULT_MAX_ROUNDS = 40;
+var DEFAULT_MAX_PARALLEL = 4;
+var DEFAULT_ACTION_NUDGE = "You have not changed anything yet. Stop reading and do what was asked now, with the tools that make changes. If you truly cannot, say exactly what is blocking you.";
+var RENDER_TURN_PREFIX2 = "Result of ";
+var RECOVERABLE_WORDS = ["timeout", "timed out", "stalled", "network", "fetch failed", "econnreset", "socket", "stream"];
+function batchCalls(calls, isParallel, max) {
+  {
+    let batches = [];
+    for (const call of calls) {
+      let last = batches.length > 0 ? batches[batches.length - 1] ?? null : null;
+      let parallel = isParallel(call.name) ?? null;
+      if (parallel && last != null && last.length < max && (isParallel((last[0] ?? null).name) ?? null)) {
+        last.push(call) ?? null;
+      } else {
+        batches.push([call]) ?? null;
+      }
+    }
+    return batches;
+  }
+}
+function truncateResult(text, max) {
+  {
+    if (text.length <= max) {
+      return text;
+    }
+    return (text.slice(0, max) ?? null) + "\n\u2026[truncated " + (String(text.length - max) ?? null) + " characters]";
+  }
+}
+function defaultIsRecoverable(err) {
+  {
+    if (err == null || ((__v) => __v == null ? "null" : typeof __v)(err) !== "object") {
+      return false;
+    }
+    if (((__v) => __v == null ? "null" : typeof __v)(err.status) === "number") {
+      return err.status >= 500 || err.status === 408 || err.status === 429;
+    }
+    let text = ((String(err.name ?? "") ?? null) + " " + (String(err.code ?? "") ?? null) + " " + (String(err.message ?? "") ?? null)).toLowerCase() ?? null;
+    return RECOVERABLE_WORDS.some((w) => {
+      {
+        return text.includes(w) ?? null;
+      }
+    }) ?? null;
+  }
+}
+function errorMessage(err) {
+  {
+    if (err != null && ((__v) => __v == null ? "null" : typeof __v)(err) === "object" && ((__v) => __v == null ? "null" : typeof __v)(err.message) === "string") {
+      return err.message;
+    }
+    return String(err) ?? null;
+  }
+}
+function repairTranscript(messages) {
+  {
+    let i = 0;
+    while (i < messages.length) {
+      let m = messages[i] ?? null;
+      if (m.role === "assistant" && (Array.isArray(m.tool_calls) ?? null) && m.tool_calls.length > 0) {
+        let j = i + 1;
+        let answered = /* @__PURE__ */ new Set() ?? null;
+        while (j < messages.length && (messages[j] ?? null).role === "tool") {
+          answered.add((messages[j] ?? null).tool_call_id ?? "") ?? null;
+          j = j + 1;
+        }
+        let missing = m.tool_calls.filter((c) => {
+          {
+            return !(answered.has(c.id) ?? null);
+          }
+        }) ?? null;
+        if (missing.length > 0) {
+          let fillers = missing.map((c) => {
+            {
+              return { role: "tool", tool_call_id: c.id, name: (c["function"] ?? null).name, content: JSON.stringify({ error: "interrupted: this call did not finish (the session was interrupted). Check its effect and run it again if needed." }) ?? null };
+            }
+          }) ?? null;
+          messages.splice(j, 0, ...fillers) ?? null;
+          i = j + missing.length - 1;
+        }
+      }
+      i = i + 1;
+    }
+    return messages;
+  }
+}
+function hook(hooks, name) {
+  {
+    if (hooks == null || ((__v) => __v == null ? "null" : typeof __v)(hooks) !== "object") {
+      return null;
+    }
+    let h = hooks[name] ?? null;
+    return ((__v) => __v == null ? "null" : typeof __v)(h) === "function" ? h : null;
+  }
+}
+async function runAgentLoop(opts) {
+  {
+    let maxRounds = ((__v) => __v == null ? "null" : typeof __v)(opts.maxRounds) === "number" ? opts.maxRounds : DEFAULT_MAX_ROUNDS;
+    let maxResultChars = ((__v) => __v == null ? "null" : typeof __v)(opts.maxResultChars) === "number" ? opts.maxResultChars : 8e3;
+    let maxParallel = ((__v) => __v == null ? "null" : typeof __v)(opts.maxParallel) === "number" ? opts.maxParallel : DEFAULT_MAX_PARALLEL;
+    let hooks = opts.hooks ?? null;
+    let specs = opts.tools.map((t) => {
+      {
+        return t.spec;
+      }
+    }) ?? null;
+    let parallelNames = new Set((opts.tools.filter((t) => {
+      {
+        return t.readOnly === true;
+      }
+    }) ?? null).map((t) => {
+      {
+        return (t.spec["function"] ?? null).name;
+      }
+    }) ?? null) ?? null;
+    let actingNames = new Set((opts.tools.filter((t) => {
+      {
+        return ((__v) => __v == null ? "null" : typeof __v)(t.acts) === "boolean" ? t.acts : t.readOnly !== true;
+      }
+    }) ?? null).map((t) => {
+      {
+        return (t.spec["function"] ?? null).name;
+      }
+    }) ?? null) ?? null;
+    let require2 = null;
+    if (opts.requireAction === true) {
+      require2 = {};
+    }
+    if (opts.requireAction != null && ((__v) => __v == null ? "null" : typeof __v)(opts.requireAction) === "object") {
+      require2 = opts.requireAction;
+    }
+    let resume = opts.resumeState ?? {};
+    let nudgesLeft = ((__v) => __v == null ? "null" : typeof __v)(resume.nudgesLeft) === "number" ? resume.nudgesLeft : require2 != null ? ((__v) => __v == null ? "null" : typeof __v)(require2.nudges) === "number" ? require2.nudges : 2 : 0;
+    let signal = opts.signal ?? null;
+    let isStopped = () => {
+      {
+        if (signal != null && signal.aborted === true) {
+          return true;
+        }
+        return ((__v) => __v == null ? "null" : typeof __v)(opts.stopped) === "function" && (opts.stopped() ?? null) === true;
+      }
+    };
+    let messages = repairTranscript(opts.messages.slice() ?? null) ?? null;
+    let text = "";
+    let acted = resume.acted === true;
+    let retries = ((__v) => __v == null ? "null" : typeof __v)(opts.modelRetries) === "number" ? opts.modelRetries : 2;
+    let recoverable = ((__v) => __v == null ? "null" : typeof __v)(opts.isRecoverable) === "function" ? opts.isRecoverable : defaultIsRecoverable;
+    let ctx = opts.context ?? {};
+    let maxRequestChars = ((__v) => __v == null ? "null" : typeof __v)(ctx.maxRequestChars) === "number" ? ctx.maxRequestChars : 43e5;
+    let save = async (round2, done) => {
+      {
+        if (((__v) => __v == null ? "null" : typeof __v)(opts.checkpoint) === "function") {
+          await (opts.checkpoint({ messages: messages.slice() ?? null, round: round2, acted, nudgesLeft, done }) ?? null);
+        }
+      }
+    };
+    let drain = () => {
+      {
+        if (((__v) => __v == null ? "null" : typeof __v)(opts.drainNotifications) !== "function") {
+          return [];
+        }
+        let notes = opts.drainNotifications() ?? null;
+        return Array.isArray(notes) ?? null ? notes : [];
+      }
+    };
+    let modelHooks = { onTextDelta: hook(hooks, "onTextDelta") ?? null, onReasoningDelta: hook(hooks, "onReasoningDelta") ?? null, onToolProgress: hook(hooks, "onToolProgress") ?? null };
+    let choiceFor = (round2) => {
+      {
+        let c = opts.toolChoice ?? null;
+        if (((__v) => __v == null ? "null" : typeof __v)(c) === "function") {
+          c = c(round2) ?? null ?? null;
+        }
+        return c;
+      }
+    };
+    let call = async (msgs, tools, choice) => {
+      {
+        let attempt = 0;
+        while (true) {
+          try {
+            {
+              if (choice == null || tools.length === 0) {
+                return await (opts.callModel(msgs, tools, modelHooks, signal) ?? null);
+              }
+              return await (opts.callModel(msgs, tools, modelHooks, signal, { toolChoice: choice }) ?? null);
+            }
+          } catch (err) {
+            {
+              if ((isStopped() ?? null) || attempt >= retries || !(recoverable(err) ?? null)) {
+                throw err;
+              }
+            }
+          }
+          attempt = attempt + 1;
+        }
+      }
+    };
+    let round = ((__v) => __v == null ? "null" : typeof __v)(resume.round) === "number" ? resume.round : 0;
+    while (maxRounds === 0 || round < maxRounds) {
+      if (isStopped() ?? null) {
+        await (save(round, true) ?? null);
+        return { messages, text, rounds: round, exhausted: false, stopped: true, acted };
+      }
+      for (const note of drain() ?? null) {
+        messages.push({ role: "user", content: note }) ?? null;
+      }
+      pruneOldImages(messages, ctx.keepImageTurns ?? null) ?? null;
+      if (ctx.compact != null && ((__v) => __v == null ? "null" : typeof __v)(ctx.compact) === "object") {
+        await (compactTranscript(messages, ctx.compact) ?? null);
+      }
+      fitImagesToBudget(messages, maxRequestChars - (JSON.stringify(specs) ?? null).length) ?? null;
+      let onStart = hook(hooks, "onAssistantStart") ?? null;
+      if (onStart != null) {
+        onStart(round) ?? null;
+      }
+      let turn = await (call(messages, specs, choiceFor(round) ?? null) ?? null);
+      text = turn.text;
+      let toolCalls = Array.isArray(turn.toolCalls) ?? null ? turn.toolCalls : [];
+      if (toolCalls.length > 0) {
+        messages.push({ role: "assistant", content: turn.text, tool_calls: toolCalls.map((c) => {
+          {
+            return { id: c.id, type: "function", function: { name: c.name, arguments: c.arguments } };
+          }
+        }) ?? null }) ?? null;
+      } else {
+        messages.push({ role: "assistant", content: turn.text }) ?? null;
+      }
+      if (toolCalls.length === 0) {
+        let onEnd = hook(hooks, "onRoundEnd") ?? null;
+        if (onEnd != null) {
+          onEnd(round) ?? null;
+        }
+        let late = drain() ?? null;
+        if (late.length > 0) {
+          for (const note of late) {
+            messages.push({ role: "user", content: note }) ?? null;
+          }
+          round = round + 1;
+          continue;
+        }
+        if (require2 != null && !acted && nudgesLeft > 0 && actingNames.size > 0) {
+          nudgesLeft = nudgesLeft - 1;
+          let nudge = ((__v) => __v == null ? "null" : typeof __v)(require2.message) === "string" ? require2.message : DEFAULT_ACTION_NUDGE;
+          let onNudge = hook(hooks, "onNudge") ?? null;
+          if (onNudge != null) {
+            onNudge(nudge) ?? null;
+          }
+          messages.push({ role: "user", content: nudge }) ?? null;
+          await (save(round + 1, false) ?? null);
+          round = round + 1;
+          continue;
+        }
+        await (save(round + 1, true) ?? null);
+        return { messages, text, rounds: round + 1, exhausted: false, stopped: false, acted };
+      }
+      let calls = toolCalls.map((c) => {
+        {
+          return { id: c.id, name: c.name, argsText: c.arguments };
+        }
+      }) ?? null;
+      let imageTurns = [];
+      for (const batch of batchCalls(calls, (n) => {
+        {
+          return parallelNames.has(n) ?? null;
+        }
+      }, maxParallel) ?? null) {
+        if (isStopped() ?? null) {
+          for (const c of calls) {
+            let answered = messages.some((m) => {
+              {
+                return m.role === "tool" && m.tool_call_id === c.id;
+              }
+            }) ?? null;
+            if (!answered) {
+              messages.push({ role: "tool", tool_call_id: c.id, name: c.name, content: JSON.stringify({ error: "stopped" }) ?? null }) ?? null;
+            }
+          }
+          await (save(round + 1, true) ?? null);
+          return { messages, text, rounds: round + 1, exhausted: false, stopped: true, acted };
+        }
+        let onToolStart = hook(hooks, "onToolStart") ?? null;
+        if (onToolStart != null) {
+          for (const info of batch) {
+            onToolStart(info) ?? null;
+          }
+        }
+        let runs2 = await (Promise.all(batch.map(async (info) => {
+          {
+            try {
+              {
+                return await (opts.execTool(info) ?? null);
+              }
+            } catch (err) {
+              {
+                let message = errorMessage(err) ?? null;
+                return { id: info.id, name: info.name, argsText: info.argsText, ok: false, summary: message, content: JSON.stringify({ error: message }) ?? null };
+              }
+            }
+          }
+        }) ?? null) ?? null);
+        let onToolEnd = hook(hooks, "onToolEnd") ?? null;
+        for (const run of runs2) {
+          let actedHere = ((__v) => __v == null ? "null" : typeof __v)(run.acted) === "boolean" ? run.acted : actingNames.has(run.name) ?? null;
+          if (run.ok === true && actedHere) {
+            acted = true;
+          }
+          if (onToolEnd != null) {
+            onToolEnd(run) ?? null;
+          }
+          messages.push({ role: "tool", tool_call_id: run.id, name: run.name, content: truncateResult(run.content, maxResultChars) ?? null }) ?? null;
+          if ((Array.isArray(run.images) ?? null) && run.images.length > 0) {
+            let label = run.images.length === 1 ? "the rendered view" : (String(run.images.length) ?? null) + " rendered views";
+            let parts = [{ type: "text", text: RENDER_TURN_PREFIX2 + run.name + ": " + label + "." }];
+            for (const url of run.images) {
+              parts.push({ type: "image_url", image_url: { url } }) ?? null;
+            }
+            imageTurns.push({ role: "user", content: parts }) ?? null;
+          }
+        }
+      }
+      for (const m of imageTurns) {
+        messages.push(m) ?? null;
+      }
+      let onRoundEnd = hook(hooks, "onRoundEnd") ?? null;
+      if (onRoundEnd != null) {
+        onRoundEnd(round) ?? null;
+      }
+      await (save(round + 1, false) ?? null);
+      round = round + 1;
+    }
+    messages.push({ role: "user", content: "You have reached the tool limit for this turn. Summarise what you changed and what is left, without calling more tools." }) ?? null;
+    let final = await (call(messages, [], null) ?? null);
+    messages.push({ role: "assistant", content: final.text }) ?? null;
+    await (save(maxRounds, true) ?? null);
+    return { messages, text: final.text, rounds: maxRounds, exhausted: true, stopped: false, acted };
+  }
+}
+
+// node_modules/.pnpm/@hyperyai+sdk@2.1.0_@types+react-dom@19.3.0_@types+react@19.3.0__@types+react@19.3.0_re_62022f8c0abbfd4c405f5fb20b5aa9ec/node_modules/@hyperyai/sdk/dist/agents/core/runtime.js
+var delay2 = ((ms) => new Promise((settle) => setTimeout(() => settle(null), Math.max(0, Number(ms) || 0))));
+var REPORT_TOOL = "report_to_parent";
+var REPORT_SPEC = { readOnly: true, acts: false, spec: { type: "function", function: { name: REPORT_TOOL, description: "Send the main agent a progress update, or a question (set question) when you need a decision you cannot make yourself. It arrives between its steps and it answers with a message you read at your next step \u2014 keep working on what you can meanwhile. Your final answer still goes back by itself when you finish.", parameters: { type: "object", properties: { message: { type: "string", description: "What to tell the main agent." }, question: { type: "boolean", description: "This needs an answer." } }, required: ["message"] } } } };
+var WAIT_STEP_MS = 25;
+function isBusy(s) {
+  {
+    return s != null && (s.status === "running" || s.status === "queued");
+  }
+}
+function plainStopControl() {
+  {
+    let flag = { aborted: false };
+    return { signal: flag, stop: () => {
+      {
+        flag.aborted = true;
+      }
+    } };
+  }
+}
+function allSessions(sessions) {
+  {
+    let out = [];
+    for (const s of sessions.values() ?? null) {
+      out.push(s) ?? null;
+    }
+    return out;
+  }
+}
+function errorMessage2(err) {
+  {
+    if (err != null && ((__v) => __v == null ? "null" : typeof __v)(err) === "object" && ((__v) => __v == null ? "null" : typeof __v)(err.message) === "string") {
+      return err.message;
+    }
+    return String(err) ?? null;
+  }
+}
+function createAgentRuntime(host) {
+  {
+    let sessions = /* @__PURE__ */ new Map() ?? null;
+    let controls = /* @__PURE__ */ new Map() ?? null;
+    let parentQueue = [];
+    let loaded = false;
+    let loading = null;
+    let active = 0;
+    let waiting = [];
+    let listeners = [];
+    let pendingSaves = 0;
+    let maxConcurrent = ((__v) => __v == null ? "null" : typeof __v)(host.maxConcurrent) === "number" ? host.maxConcurrent : 4;
+    let now = () => {
+      {
+        return ((__v) => __v == null ? "null" : typeof __v)(host.now) === "function" ? host.now() ?? null : Date.now() ?? null;
+      }
+    };
+    let changed = () => {
+      {
+        if (((__v) => __v == null ? "null" : typeof __v)(host.onChange) === "function") {
+          host.onChange() ?? null;
+        }
+        for (const l of listeners.slice() ?? null) {
+          l() ?? null;
+        }
+      }
+    };
+    let emit = (e) => {
+      {
+        if (((__v) => __v == null ? "null" : typeof __v)(host.onEvent) === "function") {
+          host.onEvent(e) ?? null;
+        }
+      }
+    };
+    let sessionEvent = (s) => {
+      {
+        emit({ type: "session", sessionId: s.id, status: s.status, profile: s.profile, description: s.description }) ?? null;
+      }
+    };
+    let persist = (s) => {
+      {
+        changed() ?? null;
+        if (host.store == null || ((__v) => __v == null ? "null" : typeof __v)(host.store) !== "object") {
+          return;
+        }
+        pendingSaves = pendingSaves + 1;
+        let save = async () => {
+          {
+            try {
+              {
+                await (host.store.save(s) ?? null);
+              }
+            } catch (e) {
+              {
+              }
+            }
+            pendingSaves = pendingSaves - 1;
+          }
+        };
+        save() ?? null;
+      }
+    };
+    let profileById = (id) => {
+      {
+        let found = (host.profiles() ?? null).filter((p) => {
+          {
+            return p.id === id;
+          }
+        }) ?? null;
+        return found.length > 0 ? found[0] ?? null : null;
+      }
+    };
+    let report = (fromId, text, question) => {
+      {
+        let s = sessions.get(fromId) ?? null ?? null;
+        let who = "agent " + fromId + (s != null ? " (" + s.profile + ")" : "");
+        let asks = question === true;
+        parentQueue.push(asks ? "QUESTION from " + who + " \u2014 it needs your answer (send_message " + fromId + "):\n" + text : "Report from " + who + ":\n" + text) ?? null;
+        emit({ type: "report", sessionId: fromId, message: text, question: asks }) ?? null;
+        changed() ?? null;
+      }
+    };
+    let run = async (session2, profile, prompt, forceReadOnly, parentSignal, fresh) => {
+      {
+        let control = ((__v) => __v == null ? "null" : typeof __v)(host.createSignal) === "function" ? host.createSignal() ?? null : plainStopControl() ?? null;
+        controls.set(session2.id, control) ?? null;
+        if (parentSignal != null) {
+          if (parentSignal.aborted === true) {
+            control.stop() ?? null;
+          } else if (((__v) => __v == null ? "null" : typeof __v)(parentSignal.addEventListener) === "function") {
+            parentSignal.addEventListener("abort", () => {
+              {
+                control.stop() ?? null;
+              }
+            }) ?? null;
+          }
+        }
+        let ctx = { session: session2, profile, readOnly: forceReadOnly || profile.readOnly === true, signal: control.signal };
+        let tools = (host.childTools(ctx) ?? null).concat([REPORT_SPEC]) ?? null;
+        let childModel = ((__v) => __v == null ? "null" : typeof __v)(host.childModel) === "function" ? host.childModel(ctx) ?? null : null;
+        let budget = ((__v) => __v == null ? "null" : typeof __v)(profile.maxRounds) === "number" && profile.maxRounds > 0 ? profile.maxRounds : ((__v) => __v == null ? "null" : typeof __v)(host.maxRounds) === "number" && host.maxRounds > 0 ? host.maxRounds : 30;
+        let ok = true;
+        let summary = "";
+        let rounds = 0;
+        let wasStopped = () => {
+          {
+            return control.signal.aborted === true || parentSignal != null && parentSignal.aborted === true;
+          }
+        };
+        try {
+          {
+            let messages = fresh ? [{ role: "system", content: await (host.childSystemPrompt(ctx) ?? null) }, { role: "user", content: prompt }] : session2.transcript.concat([{ role: "user", content: "Message from the main agent:\n" + prompt }]) ?? null;
+            let outcome = await (runAgentLoop({ messages, tools, callModel: ((__v) => __v == null ? "null" : typeof __v)(childModel) === "function" ? childModel : host.callModel, signal: control.signal, stopped: () => {
+              {
+                return parentSignal != null && parentSignal.aborted === true;
+              }
+            }, maxRounds: budget, drainNotifications: () => {
+              {
+                return (session2.inbox.splice(0, session2.inbox.length) ?? null).map((t) => {
+                  {
+                    return "Message from the main agent:\n" + t;
+                  }
+                }) ?? null;
+              }
+            }, execTool: async (call) => {
+              {
+                if (call.name === REPORT_TOOL) {
+                  let args = {};
+                  try {
+                    {
+                      args = JSON.parse(call.argsText === "" ? "{}" : call.argsText) ?? null;
+                    }
+                  } catch (e) {
+                    {
+                      args = {};
+                    }
+                  }
+                  report(session2.id, String(args.message ?? "") ?? null, args.question === true) ?? null;
+                  return { id: call.id, name: call.name, argsText: call.argsText, ok: true, summary: "reported", content: JSON.stringify({ ok: true }) ?? null };
+                }
+                return await (host.execChildTool(call, ctx) ?? null);
+              }
+            }, requireAction: fresh && !ctx.readOnly, hooks: { onToolStart: (c) => {
+              {
+                emit({ type: "tool-start", sessionId: session2.id, name: c.name }) ?? null;
+              }
+            }, onToolEnd: (r) => {
+              {
+                emit({ type: "tool-end", sessionId: session2.id, name: r.name, ok: r.ok, summary: r.summary }) ?? null;
+              }
+            }, onTextDelta: (d) => {
+              {
+                emit({ type: "text", sessionId: session2.id, delta: d }) ?? null;
+              }
+            }, onNudge: (m) => {
+              {
+                emit({ type: "nudge", sessionId: session2.id, message: m }) ?? null;
+              }
+            } } }) ?? null);
+            session2.transcript = outcome.messages;
+            rounds = outcome.rounds;
+            let said = outcome.text.trim() ?? null;
+            summary = said !== "" ? said : outcome.stopped ? "(stopped)" : "(finished without a summary)";
+            ok = !outcome.stopped;
+          }
+        } catch (err) {
+          {
+            ok = false;
+            summary = wasStopped() ?? null ? "(stopped)" : "(agent error: " + (errorMessage2(err) ?? null) + ")";
+          }
+        }
+        controls.delete(session2.id) ?? null;
+        session2.rounds = session2.rounds + rounds;
+        if (session2.status === "running") {
+          session2.status = ok ? "done" : wasStopped() ?? null ? "stopped" : "error";
+          session2.summary = summary;
+          session2.endedAt = now() ?? null;
+        } else {
+          session2.summary = summary;
+        }
+        if (session2.background && session2.status !== "stopped") {
+          parentQueue.push("Agent " + session2.id + " (" + session2.profile + ") " + (ok ? "finished" : "failed") + ":\n" + summary) ?? null;
+        }
+        sessionEvent(session2) ?? null;
+        persist(session2) ?? null;
+        return { ok, summary, rounds };
+      }
+    };
+    let takeNext = () => {
+      {
+        while (waiting.length > 0) {
+          let next = waiting.shift() ?? null;
+          if (next.session.status === "queued") {
+            next.session.status = "running";
+            sessionEvent(next.session) ?? null;
+            changed() ?? null;
+            return next;
+          }
+        }
+        return null;
+      }
+    };
+    let runSlot = (first) => {
+      {
+        ((f) => Promise.resolve().then(() => f()))(async () => {
+          {
+            let job = first;
+            while (job != null) {
+              try {
+                {
+                  if (job.session.status !== "stopped") {
+                    await (job.go() ?? null);
+                  }
+                }
+              } catch (e) {
+                {
+                }
+              }
+              job = takeNext() ?? null;
+              if (job == null) {
+                active = Math.max(0, active - 1) ?? null;
+                if (waiting.length > 0 && active < maxConcurrent) {
+                  active = active + 1;
+                  job = takeNext() ?? null;
+                  if (job == null) {
+                    active = Math.max(0, active - 1) ?? null;
+                  }
+                }
+              }
+            }
+          }
+        }) ?? null;
+      }
+    };
+    let startBackground = (session2, go) => {
+      {
+        if (active < maxConcurrent) {
+          active = active + 1;
+          runSlot({ session: session2, go }) ?? null;
+          return;
+        }
+        session2.status = "queued";
+        sessionEvent(session2) ?? null;
+        changed() ?? null;
+        waiting.push({ session: session2, go }) ?? null;
+      }
+    };
+    let stop = (id) => {
+      {
+        let s = sessions.get(id) ?? null ?? null;
+        if (s == null || s.status !== "running" && s.status !== "queued") {
+          return false;
+        }
+        let control = controls.get(id) ?? null ?? null;
+        if (control != null) {
+          control.stop() ?? null;
+        }
+        s.status = "stopped";
+        s.endedAt = now() ?? null;
+        persist(s) ?? null;
+        return true;
+      }
+    };
+    let load = async () => {
+      {
+        if (loaded) {
+          return;
+        }
+        loaded = true;
+        if (host.store != null && ((__v) => __v == null ? "null" : typeof __v)(host.store) === "object") {
+          let saved = await (host.store.load() ?? null);
+          for (const s of Array.isArray(saved) ?? null ? saved : []) {
+            if (s.status === "running" || s.status === "queued") {
+              s.status = "stopped";
+              if (((__v) => __v == null ? "null" : typeof __v)(s.endedAt) !== "number") {
+                s.endedAt = now() ?? null;
+              }
+            }
+            sessions.set(s.id, s) ?? null;
+          }
+        }
+        changed() ?? null;
+      }
+    };
+    let get = (id) => {
+      {
+        return sessions.get(id) ?? null ?? null;
+      }
+    };
+    return { load, flush: async () => {
+      {
+        while (pendingSaves > 0) {
+          await (delay2(WAIT_STEP_MS) ?? null);
+        }
+      }
+    }, subscribe: (l) => {
+      {
+        listeners.push(l) ?? null;
+        return () => {
+          {
+            let i = listeners.indexOf(l) ?? null;
+            if (i >= 0) {
+              listeners.splice(i, 1) ?? null;
+            }
+          }
+        };
+      }
+    }, list: () => {
+      {
+        return (allSessions(sessions) ?? null).sort((a, b) => {
+          {
+            return a.startedAt - b.startedAt;
+          }
+        }) ?? null;
+      }
+    }, get, wait: async (id, opts) => {
+      {
+        let o = opts ?? {};
+        let deadline = (now() ?? null) + (((__v) => __v == null ? "null" : typeof __v)(o.timeoutMs) === "number" ? o.timeoutMs : 12e4);
+        let signal = o.signal ?? null;
+        while ((isBusy(get(id) ?? null) ?? null) && (now() ?? null) < deadline && !(signal != null && signal.aborted === true)) {
+          await (delay2(Math.min(WAIT_STEP_MS, Math.max(1, deadline - (now() ?? null)) ?? null) ?? null) ?? null);
+        }
+        return get(id) ?? null;
+      }
+    }, dismissFinished: (id) => {
+      {
+        let prefix = "Agent " + id + " (";
+        let i = parentQueue.length - 1;
+        while (i >= 0) {
+          if ((parentQueue[i] ?? null).startsWith(prefix) ?? null) {
+            parentQueue.splice(i, 1) ?? null;
+          }
+          i = i - 1;
+        }
+      }
+    }, drainParentNotifications: () => {
+      {
+        return parentQueue.splice(0, parentQueue.length) ?? null;
+      }
+    }, hasPendingNotifications: () => {
+      {
+        return parentQueue.length > 0;
+      }
+    }, spawn: async (req) => {
+      {
+        let profile = profileById(req.profileId) ?? null;
+        if (profile == null) {
+          let ids = ((host.profiles() ?? null).map((p) => {
+            {
+              return p.id;
+            }
+          }) ?? null).join(", ") ?? null;
+          return { kind: "refused", reason: 'No agent type "' + req.profileId + '". Available: ' + ids + "." };
+        }
+        let prompt = ((__v) => __v == null ? "null" : typeof __v)(req.prompt) === "string" ? req.prompt.trim() ?? null : "";
+        if (prompt === "") {
+          return { kind: "refused", reason: "A task needs a self-contained prompt \u2014 the agent cannot see this conversation." };
+        }
+        let background = ((__v) => __v == null ? "null" : typeof __v)(req.background) === "boolean" ? req.background : profile.background === true;
+        let id = ((__v) => __v == null ? "null" : typeof __v)(host.newId) === "function" ? host.newId() ?? null : "agent-" + ((now() ?? null).toString(36) ?? null) + "-" + (((Math.random() ?? null).toString(36) ?? null).slice(2, 7) ?? null);
+        let session2 = { id, profile: profile.id, description: ((__v) => __v == null ? "null" : typeof __v)(req.description) === "string" && req.description !== "" ? req.description : prompt.slice(0, 80) ?? null, status: "running", background, transcript: [], inbox: [], startedAt: now() ?? null, rounds: 0, readOnly: req.readOnly === true || profile.readOnly === true };
+        if (((__v) => __v == null ? "null" : typeof __v)(req.parentCallId) === "string" && req.parentCallId !== "") {
+          session2.parentCallId = req.parentCallId;
+        }
+        sessions.set(session2.id, session2) ?? null;
+        changed() ?? null;
+        sessionEvent(session2) ?? null;
+        let forceReadOnly = req.readOnly === true;
+        let parentSignal = req.signal ?? null;
+        if (background) {
+          startBackground(session2, async () => {
+            {
+              return await (run(session2, profile, prompt, forceReadOnly, parentSignal, true) ?? null);
+            }
+          }) ?? null;
+          return { kind: "started", id: session2.id };
+        }
+        let out = await (run(session2, profile, prompt, forceReadOnly, parentSignal, true) ?? null);
+        return { kind: "done", id: session2.id, ok: out.ok, summary: out.summary, rounds: out.rounds };
+      }
+    }, message: async (id, text, opts) => {
+      {
+        await (load() ?? null);
+        let o = opts ?? {};
+        let session2 = sessions.get(id) ?? null ?? null;
+        if (session2 == null) {
+          return { kind: "unknown", id };
+        }
+        if (session2.status === "running" || session2.status === "queued") {
+          session2.inbox.push(text) ?? null;
+          persist(session2) ?? null;
+          return { kind: "queued", id };
+        }
+        let profile = profileById(session2.profile) ?? null;
+        if (profile == null) {
+          return { kind: "unknown", id };
+        }
+        let wait = o.wait === true;
+        let parentSignal = o.signal ?? null;
+        session2.status = "running";
+        session2.endedAt = null;
+        session2.background = !wait;
+        changed() ?? null;
+        if (!wait) {
+          startBackground(session2, async () => {
+            {
+              return await (run(session2, profile, text, false, parentSignal, false) ?? null);
+            }
+          }) ?? null;
+          return { kind: "resumed", id };
+        }
+        let out = await (run(session2, profile, text, false, parentSignal, false) ?? null);
+        return { kind: "done", id, ok: out.ok, summary: out.summary };
+      }
+    }, stop, stopAll: () => {
+      {
+        for (const s of allSessions(sessions) ?? null) {
+          stop(s.id) ?? null;
+        }
+        parentQueue.splice(0, parentQueue.length) ?? null;
+      }
+    }, report };
+  }
+}
+
+// node_modules/.pnpm/@hyperyai+sdk@2.1.0_@types+react-dom@19.3.0_@types+react@19.3.0__@types+react@19.3.0_re_62022f8c0abbfd4c405f5fb20b5aa9ec/node_modules/@hyperyai/sdk/dist/agents/core/types.js
+init_define_POPCRAFT_COMPONENT_IDS();
+function forceTool(name) {
+  {
+    return { type: "function", function: { name } };
+  }
+}
+
+// node_modules/.pnpm/@hyperyai+sdk@2.1.0_@types+react-dom@19.3.0_@types+react@19.3.0__@types+react@19.3.0_re_62022f8c0abbfd4c405f5fb20b5aa9ec/node_modules/@hyperyai/sdk/dist/agents/core/store.js
+init_define_POPCRAFT_COMPONENT_IDS();
+async function loadAll(kv, prefix) {
+  {
+    let out = [];
+    for (const k of await (kv.keys(prefix) ?? null)) {
+      let v = await (kv.get(k) ?? null);
+      if (v != null) {
+        out.push(v) ?? null;
+      }
+    }
+    return out;
+  }
+}
+function sessionStore(kv, scope) {
+  {
+    let prefix = (scope ?? "default") + ":session:";
+    return { load: async () => {
+      {
+        return await (loadAll(kv, prefix) ?? null);
+      }
+    }, save: async (s) => {
+      {
+        await (kv.set(prefix + s.id, s) ?? null);
+      }
+    }, remove: async (id) => {
+      {
+        await ((kv["delete"] ?? null)(prefix + id) ?? null);
+      }
+    } };
+  }
+}
+function runStore(kv, scope) {
+  {
+    let prefix = (scope ?? "default") + ":run:";
+    return { get: async (id) => {
+      {
+        return await (kv.get(prefix + id) ?? null);
+      }
+    }, save: async (run) => {
+      {
+        await (kv.set(prefix + run.id, run) ?? null);
+      }
+    }, list: async () => {
+      {
+        return await (loadAll(kv, prefix) ?? null);
+      }
+    }, remove: async (id) => {
+      {
+        await ((kv["delete"] ?? null)(prefix + id) ?? null);
+      }
+    } };
+  }
+}
+
+// node_modules/.pnpm/@hyperyai+sdk@2.1.0_@types+react-dom@19.3.0_@types+react@19.3.0__@types+react@19.3.0_re_62022f8c0abbfd4c405f5fb20b5aa9ec/node_modules/@hyperyai/sdk/dist/agents/core/run.js
+init_define_POPCRAFT_COMPONENT_IDS();
+function errorMessage3(err) {
+  {
+    if (err != null && ((__v) => __v == null ? "null" : typeof __v)(err) === "object" && ((__v) => __v == null ? "null" : typeof __v)(err.message) === "string") {
+      return err.message;
+    }
+    return String(err) ?? null;
+  }
+}
+async function runPersistent(opts) {
+  {
+    let now = ((__v) => __v == null ? "null" : typeof __v)(opts.now) === "function" ? opts.now : () => {
+      {
+        return Date.now() ?? null;
+      }
+    };
+    let existing = await (opts.runs.get(opts.id) ?? null);
+    let createdAt = existing != null ? existing.createdAt : now() ?? null;
+    let record = (status, checkpoint) => {
+      {
+        let todos = opts.todos != null && ((__v) => __v == null ? "null" : typeof __v)(opts.todos) === "object" ? opts.todos.get() ?? null : existing != null ? existing.todos ?? null : null;
+        let meta = opts.meta ?? (existing != null ? existing.meta ?? null : null);
+        return { id: opts.id, createdAt, updatedAt: now() ?? null, meta, todos, status, checkpoint };
+      }
+    };
+    let first = existing != null ? existing.checkpoint : { messages: opts.messages, round: 0, acted: false, nudgesLeft: 0, done: false };
+    await (opts.runs.save(record("running", first) ?? null) ?? null);
+    let mark = async (status, error) => {
+      {
+        let saved = await (opts.runs.get(opts.id) ?? null);
+        if (saved != null) {
+          let next = { ...saved, status, updatedAt: now() ?? null };
+          if (((__v) => __v == null ? "null" : typeof __v)(error) === "string") {
+            next.error = error;
+          }
+          await (opts.runs.save(next) ?? null);
+        }
+      }
+    };
+    let outcome = null;
+    try {
+      {
+        outcome = await (runAgentLoop({ ...opts, checkpoint: async (state) => {
+          {
+            await (opts.runs.save(record(state.done ? "done" : "running", state) ?? null) ?? null);
+            if (((__v) => __v == null ? "null" : typeof __v)(opts.checkpoint) === "function") {
+              await (opts.checkpoint(state) ?? null);
+            }
+          }
+        } }) ?? null);
+      }
+    } catch (err) {
+      {
+        await (mark("error", errorMessage3(err) ?? null) ?? null);
+        throw err;
+      }
+    }
+    if (outcome.stopped) {
+      await (mark("stopped", null) ?? null);
+    }
+    return outcome;
+  }
+}
+async function interruptedRuns(runs2, activeIds) {
+  {
+    let active = new Set(activeIds ?? []) ?? null;
+    return (await (runs2.list() ?? null)).filter((r) => {
+      {
+        return r.status === "running" && !(active.has(r.id) ?? null);
+      }
+    }) ?? null;
+  }
+}
+async function resumeRun(id, runs2, options) {
+  {
+    let saved = await (runs2.get(id) ?? null);
+    if (saved == null) {
+      throw { message: 'No saved run "' + id + '".', code: "not_found" };
+    }
+    let cp = saved.checkpoint;
+    return await (runPersistent({ ...options, id, runs: runs2, messages: cp.messages.concat([{ role: "user", content: "The session was interrupted and has resumed. Check the state of your work, then carry on where you left off." }]) ?? null, resumeState: { round: cp.round, acted: cp.acted, nudgesLeft: cp.nudgesLeft }, meta: options.meta ?? saved.meta ?? null }) ?? null);
+  }
+}
+
+// node_modules/.pnpm/@hyperyai+sdk@2.1.0_@types+react-dom@19.3.0_@types+react@19.3.0__@types+react@19.3.0_re_62022f8c0abbfd4c405f5fb20b5aa9ec/node_modules/@hyperyai/sdk/dist/agents/indexeddb.js
+init_define_POPCRAFT_COMPONENT_IDS();
+function indexedDbStore(name = "hypery-agents") {
+  let db = null;
+  const open = () => db ?? (db = new Promise((res, rej) => {
+    const req = indexedDB.open(name, 1);
+    req.onupgradeneeded = () => {
+      req.result.createObjectStore("kv");
+    };
+    req.onsuccess = () => res(req.result);
+    req.onerror = () => rej(req.error);
+  }));
+  const tx = async (mode, fn) => {
+    const store = (await open()).transaction("kv", mode).objectStore("kv");
+    return new Promise((res, rej) => {
+      const r = fn(store);
+      r.onsuccess = () => res(r.result);
+      r.onerror = () => rej(r.error);
+    });
+  };
+  return {
+    // A missing key reads as null, as the core's stores do.
+    get: async (k) => await tx("readonly", (s) => s.get(k)) ?? null,
+    set: async (k, v) => {
+      await tx("readwrite", (s) => s.put(structuredClone(v), k));
+    },
+    delete: async (k) => {
+      await tx("readwrite", (s) => s.delete(k));
+    },
+    keys: async (prefix) => (await tx("readonly", (s) => s.getAllKeys())).map(String).filter((k) => k.startsWith(prefix))
+  };
+}
+
+// node_modules/.pnpm/@hyperyai+sdk@2.1.0_@types+react-dom@19.3.0_@types+react@19.3.0__@types+react@19.3.0_re_62022f8c0abbfd4c405f5fb20b5aa9ec/node_modules/@hyperyai/sdk/dist/agents/index.js
+function createHyperyModel2(opts) {
+  return createHyperyModel({ ...opts, fetch: opts.fetch ?? ((url, init) => fetch(url, init)) });
+}
+function createAgentRuntime2(host) {
+  return createAgentRuntime({
+    ...host,
+    createSignal: host.createSignal ?? (() => {
+      const controller = new AbortController();
+      return { signal: controller.signal, stop: () => controller.abort() };
+    })
+    // The core types a child's signal as anything with `aborted`; here every one comes from `createSignal`, whose
+    // signals are AbortSignals — so the host's callbacks may rely on that.
+  });
+}
+
+// lib/agent/stream-parse.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+
+// lib/agent/gateway.ts
+var session = {
+  token: () => accessToken(),
+  team: () => activeHyperyTeamId(),
+  paymentSource: async () => (await paymentSourceHeaders())[HYPERY_PAYMENT_SOURCE_HEADER] === "credits" ? "credits" : null,
+  gatewayUrl: HYPERY_GATEWAY_URL
+};
+var agentModel2 = (model) => createHyperyModel2({
+  ...session,
+  model: () => {
+    const id = model();
+    if (!id) throw agentModelError("Pick a chat model for the agent first.", "no_model", 400);
+    return id;
+  }
+});
+
+// lib/agent/turn-recovery.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var ACTION_NUDGES = 2;
+var MAX_READ_ROUNDS = 4;
+var READ_BUDGET_NOTE = "You have read enough to start. Make the change now with a tool that edits the document; read more only if a write fails.";
+var ACTION_NUDGE = "Nothing has changed in the document yet. Make the change that was asked for now, with a tool that edits the document. If you truly cannot, say exactly what is blocking you.";
+var QUESTION_START = /^(what|why|how|which|who|where|when|is|are|does|do|did|can you (explain|tell)|could you (explain|tell)|explain|describe|tell me|list|show me what)\b/i;
+function wantsChange(text) {
+  const body = text.trim();
+  if (!body) return false;
+  return !(body.endsWith("?") && QUESTION_START.test(body));
+}
+function createActionGuard(opts) {
+  const maxReads = opts.maxReadRounds ?? MAX_READ_ROUNDS;
+  const maxNudges = opts.nudges ?? ACTION_NUDGES;
+  let readRounds = opts.initial?.readRounds ?? 0;
+  let nudges = opts.initial?.nudges ?? 0;
+  let acted = false;
+  let actedThisRound = false;
+  let ranThisRound = false;
+  let notes = [];
+  let choice = null;
+  let budgetSpent = readRounds >= maxReads;
+  return {
+    onRun(run, changed) {
+      ranThisRound = true;
+      if (run.ok && changed) {
+        acted = true;
+        actedThisRound = true;
+      }
+    },
+    onRoundEnd() {
+      if (!opts.enabled || acted || !ranThisRound) {
+        ranThisRound = false;
+        actedThisRound = false;
+        return;
+      }
+      if (!actedThisRound) readRounds++;
+      ranThisRound = false;
+      actedThisRound = false;
+      if (!budgetSpent && readRounds >= maxReads) {
+        budgetSpent = true;
+        notes.push(READ_BUDGET_NOTE);
+        choice = "required";
+      }
+    },
+    onNudge() {
+      nudges++;
+      if (opts.enabled && nudges >= maxNudges && opts.writeTool) choice = forceTool(opts.writeTool);
+      else if (opts.enabled) choice = "required";
+      return nudges;
+    },
+    drain() {
+      const out = notes;
+      notes = [];
+      return out;
+    },
+    toolChoice() {
+      if (acted) return null;
+      const c = choice;
+      choice = null;
+      return c;
+    },
+    get acted() {
+      return acted;
+    },
+    state: () => ({ readRounds, nudges, forced: budgetSpent })
+  };
+}
+function createToolLedger(initial = null) {
+  let done = { ...initial ?? {} };
+  return {
+    get: (id) => done[id],
+    record: (run) => {
+      done = { ...done, [run.id]: { id: run.id, name: run.name, argsText: run.argsText, ok: run.ok, summary: run.summary, content: run.content } };
+    },
+    entries: () => done,
+    clear: () => {
+      done = {};
+    }
+  };
+}
+async function runOnce(ledger, call, run) {
+  const seen = ledger.get(call.id);
+  if (seen) return { ...seen, acted: false, replayed: true };
+  const result = await run();
+  ledger.record(result);
+  return result;
+}
+function resumeTranscript(checkpoint, pending, ledger) {
+  if (!pending?.calls.length) return checkpoint;
+  const answered = new Set(checkpoint.filter((m) => m.role === "tool").map((m) => m.tool_call_id));
+  if (pending.calls.every((c) => answered.has(c.id))) return checkpoint;
+  const assistant = {
+    role: "assistant",
+    content: pending.text,
+    tool_calls: pending.calls.map((c) => ({ id: c.id, type: "function", function: { name: c.name, arguments: c.argsText } }))
+  };
+  const answers = pending.calls.map((c) => ledger?.[c.id]).filter((e) => !!e).map((e) => ({ role: "tool", tool_call_id: e.id, name: e.name, content: e.content }));
+  return [...checkpoint, assistant, ...answers];
+}
+var browserSignals = () => {
+  if (typeof document === "undefined" || typeof window === "undefined") return null;
+  return {
+    hidden: () => document.visibilityState === "hidden",
+    online: () => typeof navigator === "undefined" || navigator.onLine !== false,
+    subscribe: (fn) => {
+      document.addEventListener("visibilitychange", fn);
+      window.addEventListener("online", fn);
+      window.addEventListener("pageshow", fn);
+      return () => {
+        document.removeEventListener("visibilitychange", fn);
+        window.removeEventListener("online", fn);
+        window.removeEventListener("pageshow", fn);
+      };
+    }
+  };
+};
+function whenResumable(signals = browserSignals(), signal, offlineWaitMs = 0) {
+  if (!signals || signal?.aborted) return Promise.resolve();
+  const visible = () => !signals.hidden() ? Promise.resolve() : new Promise((resolve2) => {
+    const done = () => {
+      off();
+      signal?.removeEventListener("abort", done);
+      resolve2();
+    };
+    const off = signals.subscribe(() => {
+      if (!signals.hidden()) done();
+    });
+    signal?.addEventListener("abort", done);
+  });
+  return visible().then(() => {
+    if (!offlineWaitMs || signals.online() || signal?.aborted) return;
+    return new Promise((resolve2) => {
+      const done = () => {
+        clearTimeout(timer);
+        off();
+        signal?.removeEventListener("abort", done);
+        resolve2();
+      };
+      const timer = setTimeout(done, offlineWaitMs);
+      const off = signals.subscribe(() => {
+        if (signals.online()) done();
+      });
+      signal?.addEventListener("abort", done);
+    });
+  });
+}
+function isInterruption(err, hidden = false) {
+  if (hidden) return true;
+  const e = err ?? {};
+  if (e.code === "ai_timeout") return true;
+  if (typeof e.status === "number") return e.status >= 500 || e.status === 408;
+  const text = `${String(e.name ?? "")} ${String(e.code ?? "")} ${String(e.message ?? "")}`.toLowerCase();
+  return ["load failed", "failed to fetch", "network", "fetch failed", "econnreset", "socket", "stream", "stalled", "timed out", "timeout"].some((w) => text.includes(w));
+}
+function serialRuns(inner) {
+  const latest = /* @__PURE__ */ new Map();
+  let queue = Promise.resolve();
+  return {
+    peek: (id) => latest.get(id),
+    get: async (id) => latest.get(id) ?? inner.get(id),
+    save: (rec) => {
+      latest.set(rec.id, rec);
+      const write = queue.then(() => inner.save(rec));
+      queue = write.catch(() => {
+      });
+      return write;
+    },
+    list: async () => {
+      await queue;
+      return inner.list();
+    },
+    remove: (id) => {
+      latest.delete(id);
+      const write = queue.then(() => inner.remove(id));
+      queue = write.catch(() => {
+      });
+      return write;
+    }
+  };
+}
+
+// lib/agent/tools/subagent-tools.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+
+// lib/agent/subagent.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+
+// lib/agent/prompt.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+init_limits();
+var PROMPT_LIMITS = {
+  maxPromptChars: 14e3,
+  maxSkillIndexChars: 4800,
+  maxProfileIndexChars: 1600,
+  maxContextChars: AI_LIMITS.maxContextChars,
+  maxSelectionItems: 12
+};
+var IDENTITY = `You are the PopCraft design agent. PopCraft is a browser design tool (frames, vectors, text, components, styles, variables, auto layout), and you work inside the user's open document through tools that edit it live.`;
+var HOW_TO_WORK = `How you work:
+- Inspect before you edit. Read the selection and the layers you are about to change; never guess at node ids, colors or sizes.
+- Make designs as code. Anything bigger than a small tweak \u2014 a poster, a post, a reel, a page, an ad set \u2014 is ONE script built with write_design (read the design-code skill and read_design_reference first), not dozens of create_node and update_nodes calls: it builds in one step, shows on the canvas as you write it, returns a render to look at, and is changed by editing the script and building again. Before calling a design done, review it with the design-review skill: every size, moments in time, a light and a dark brand kit.
+- Prefer batched tools. One call that renames thirty layers or sets ten strings beats thirty calls: every write is one undo step for the user, and a wall of undo steps is a bad edit.
+- Stay inside the scope the user pointed at. The selection is the default scope; do not touch the rest of the page unless asked.
+- Explain briefly. A line or two about what you did and why, with counts rather than lists. No preamble, no restating the request.
+- Use skills. Before a multi-step job, read the matching skill with read_skill and follow it; skills carry the rules that make the result look designed rather than generated.
+- Plan visibly for anything longer than a couple of steps: manage_todos puts the plan in front of the user and keeps you honest.
+- When a tool fails, read the error and fix the call \u2014 do not retry the same arguments, and do not pretend a failed edit happened.
+- Ask only when you genuinely cannot proceed (a structural ambiguity), and ask once. ask_user puts the question in front of them with options to click \u2014 use it when a choice is both ambiguous AND consequential, and never when you can reasonably infer the answer from the document or the request, or when you could just try it and let them undo. If they skip the question, pick sensibly and say which way you went.
+- Delegate the heavy parts. Surveying a big page, writing all the copy, restyling dozens of layers \u2014 hand those to a subagent with task(); it burns its own context and hands you back a short summary, which is what keeps you able to finish the turn. Several task() calls in one message run at the same time.`;
+var describeNodes = (doc, ids) => {
+  const shown = ids.slice(0, PROMPT_LIMITS.maxSelectionItems);
+  const parts = shown.map((id) => {
+    const n = doc.nodes[id];
+    return n ? `${id} (${n.type}${n.name ? ` "${str(n.name, 40)}"` : ""})` : `${id} (missing)`;
+  });
+  const rest = ids.length - shown.length;
+  return parts.join(", ") + (rest > 0 ? `, +${rest} more` : "");
+};
+function buildContextBlock(ctx, maxChars = PROMPT_LIMITS.maxContextChars) {
+  const { doc, pageId, selection } = ctx;
+  const page = doc.nodes[pageId];
+  const lines = [
+    `Document: "${str(doc.name, AI_LIMITS.maxNameChars)}" (${doc.pages.length} page${doc.pages.length === 1 ? "" : "s"}, ${Object.keys(doc.nodes).length} nodes)`,
+    `Current page: ${page ? `"${str(page.name, AI_LIMITS.maxNameChars)}"` : "unknown"} (id ${pageId}, ${page?.childIds?.length ?? 0} top-level layers)`,
+    selection.length ? `Selection (${selection.length}): ${describeNodes(doc, selection)}` : "Selection: nothing selected \u2014 ask what to work on, or use find_nodes / get_document_outline to locate it."
+  ];
+  const mentions = mentionContext(ctx.mentions, doc);
+  if (mentions) lines.push(mentions);
+  if (ctx.camera) {
+    const z = Math.round(ctx.camera.zoom * 100);
+    const size = ctx.viewport ? `, ${Math.round(ctx.viewport.width / ctx.camera.zoom)}x${Math.round(ctx.viewport.height / ctx.camera.zoom)} canvas units visible` : "";
+    lines.push(`Viewport: ${z}% zoom at (${Math.round(ctx.camera.x)}, ${Math.round(ctx.camera.y)})${size}`);
+  }
+  const design = buildDesignContext(doc, Math.max(200, Math.floor(maxChars / 2)));
+  if (design) lines.push(design);
+  if (ctx.readOnly) lines.push("This document is currently read-only (a version-history preview, or you are in this file as a viewer or commenter) \u2014 editing tools will refuse; explain that instead of retrying.");
+  return joinWithin(lines, maxChars);
+}
+function buildSkillIndex(skills, maxChars = PROMPT_LIMITS.maxSkillIndexChars) {
+  return joinWithin(skills.map(skillIndexLine), maxChars);
+}
+function buildProfileIndex(profiles, maxChars = PROMPT_LIMITS.maxProfileIndexChars) {
+  return joinWithin(profiles.map(profileIndexLine), maxChars);
+}
+function buildSubagentPrompt(instructions, ctx) {
+  const prompt = [instructions, SUBAGENT_FRAMING, `Current context:
+${buildContextBlock(ctx)}`].join("\n\n");
+  return prompt.length <= PROMPT_LIMITS.maxPromptChars ? prompt : `${prompt.slice(0, PROMPT_LIMITS.maxPromptChars)}
+\u2026`;
+}
+function buildSystemPrompt(ctx) {
+  const skills = ctx.skills ?? allSkills();
+  const profiles = ctx.profiles ?? allProfiles();
+  const active = ctx.activeSkillId ? findSkill(ctx.activeSkillId) : void 0;
+  const sections = [
+    IDENTITY,
+    HOW_TO_WORK,
+    `Skills (read the full instructions with read_skill before you follow one \u2014 only the summaries are here):
+${buildSkillIndex(skills)}`,
+    `Subagent profiles (spawn one with task({ subagent_type, prompt }); it starts fresh, sees this document but not this conversation, and returns only a summary):
+${buildProfileIndex(profiles)}`,
+    active ? `The user selected the "${active.name}" skill (${active.id}) for this turn. Call read_skill("${active.id}") first and follow it.` : "",
+    // Last on purpose: selection, camera and viewport change every turn, and providers cache prompts by
+    // prefix — everything above is identical from turn to turn, so it stays cacheable.
+    `Current context:
+${buildContextBlock(ctx)}`
+  ].filter(Boolean);
+  const prompt = sections.join("\n\n");
+  return prompt.length <= PROMPT_LIMITS.maxPromptChars ? prompt : `${prompt.slice(0, PROMPT_LIMITS.maxPromptChars)}
+\u2026`;
+}
+
+// lib/agent/subagent.ts
+var PARENT_ONLY_TOOLS = ["task", "await_job", "send_message", "stop_agent", "list_agents"];
+var AGENT_SESSIONS_DB = "popcraft-agent-sessions";
+var FAST_HINTS = ["flash", "mini", "haiku", "lite", "nano", "small"];
+var isFastModelId = (id) => {
+  const lower = id.toLowerCase();
+  return FAST_HINTS.some((h) => lower.includes(h));
+};
+function canRunTools(model) {
+  if (model.capabilities && !model.capabilities.includes("tools")) return false;
+  const modalities = model.outputModalities;
+  if (modalities?.length && !modalities.includes("text")) return false;
+  return !/(^|[-/_])image([-/_]|$)/.test(model.id.toLowerCase());
+}
+function pickChildModel(profile, parentModel, catalog) {
+  const explicit = profile.model?.trim();
+  if (explicit && explicit !== "inherit") return explicit;
+  if (!profile.readOnly) return parentModel;
+  const fast = catalog.find((m) => isFastModelId(m.id) && canRunTools(m));
+  return fast?.id ?? parentModel;
+}
+function childToolNames(profile, registered, forceReadOnly) {
+  const wanted = profile.tools.includes(ALL_TOOLS) ? null : new Set(profile.tools);
+  const parentOnly = new Set(PARENT_ONLY_TOOLS);
+  return registered.filter((t) => !parentOnly.has(t.name)).filter((t) => t.confirm === void 0).filter((t) => t.interactive !== true).filter((t) => !wanted || wanted.has(t.name)).filter((t) => !forceReadOnly || t.readOnly === true).map((t) => t.name);
+}
+function editorPromptContext() {
+  const st = useEditorStore.getState();
+  return {
+    doc: st.document,
+    pageId: st.currentPageId,
+    selection: st.selection,
+    camera: st.camera,
+    viewport: typeof window === "undefined" ? void 0 : { width: window.innerWidth, height: window.innerHeight },
+    readOnly: !!editBlockReason()
+  };
+}
+var childToolListener = null;
+function onChildTool(fn) {
+  childToolListener = fn;
+  return () => {
+    if (childToolListener === fn) childToolListener = null;
+  };
+}
+function subagentHost(deps = {}) {
+  const profiles = deps.profiles ?? allProfiles;
+  const registered = deps.registeredTools ?? (() => allTools().map((t) => ({ name: t.name, readOnly: t.readOnly, confirm: t.confirm, interactive: t.interactive })));
+  const promptContext = deps.promptContext ?? editorPromptContext;
+  const parentModel = deps.parentModel ?? (() => effectiveChatModel());
+  const catalog = deps.catalog ?? (() => useAiStore.getState().catalog?.chat ?? []);
+  const modelCall = deps.modelCall ?? agentModel2;
+  const toolContext = deps.toolContext ?? editorToolContext;
+  const profileOf = (ctx) => profiles().find((p) => p.id === ctx.profile.id) ?? ctx.profile;
+  const readOnly = (ctx) => ctx.readOnly || promptContext().readOnly === true;
+  return {
+    profiles,
+    callModel: modelCall(parentModel),
+    childModel: (ctx) => {
+      const model = pickChildModel(profileOf(ctx), parentModel(), catalog());
+      return modelCall(() => model);
+    },
+    childSystemPrompt: (ctx) => buildSubagentPrompt(ctx.profile.instructions, promptContext()),
+    childTools: (ctx) => {
+      const all = registered();
+      const names = childToolNames(profileOf(ctx), all, readOnly(ctx));
+      return (names.length ? toolSpecs(names) : []).map((spec) => ({
+        spec,
+        readOnly: all.find((t) => t.name === spec.function.name)?.readOnly === true
+      }));
+    },
+    execChildTool: async (call, ctx) => {
+      if (!childToolNames(profileOf(ctx), registered(), readOnly(ctx)).includes(call.name)) {
+        const message = `${call.name} is not one of your tools. Do this work with the tools you have, or say in your summary what is missing.`;
+        return { ...call, ok: false, summary: message, content: JSON.stringify({ error: message }) };
+      }
+      const base = toolContext(ctx.signal);
+      const toolCtx = { ...base, actor: { ...base.actor ?? {}, kind: "agent", nested: true, id: ctx.session.id } };
+      try {
+        const result = await runTool(call.name, call.argsText, toolCtx);
+        return { ...call, ok: true, summary: result.summary, content: JSON.stringify(result.data ?? { ok: true, summary: result.summary }), images: result.images };
+      } catch (err) {
+        const message = err.message ?? String(err);
+        return { ...call, ok: false, summary: message, content: JSON.stringify({ error: message }) };
+      }
+    },
+    store: deps.store === null ? void 0 : deps.store ?? (typeof indexedDB === "undefined" ? void 0 : sessionStore(indexedDbStore(AGENT_SESSIONS_DB), "editor")),
+    onEvent: (event) => reportChildTool(runtimeRef, event)
+  };
+}
+var runtimeRef = null;
+var MAX_STEPS = 50;
+var activity = /* @__PURE__ */ new Map();
+var activityListeners = /* @__PURE__ */ new Set();
+function recordStep(event) {
+  if (event.type !== "tool-start" && event.type !== "tool-end") return;
+  const name = event.name ?? "";
+  const steps = [...activity.get(event.sessionId) ?? []];
+  if (event.type === "tool-start") steps.push({ name, status: "running" });
+  else {
+    const i = steps.findLastIndex((s) => s.name === name && s.status === "running");
+    const step = { name, status: event.ok ? "done" : "error", summary: event.summary ?? void 0 };
+    if (i >= 0) steps[i] = step;
+    else steps.push(step);
+  }
+  activity.set(event.sessionId, steps.slice(-MAX_STEPS));
+  for (const l of activityListeners) l();
+}
+function reportChildTool(runtime, event) {
+  recordStep(event);
+  if (!childToolListener || event.type !== "tool-start" && event.type !== "tool-end") return;
+  const session2 = runtime?.get(event.sessionId);
+  if (!session2) return;
+  const jobId = session2.background ? session2.id : void 0;
+  childToolListener({
+    profile: session2.profile,
+    toolCallId: session2.parentCallId ?? void 0,
+    jobId,
+    job: jobId,
+    name: event.name ?? "",
+    status: event.type === "tool-start" ? "running" : event.ok ? "done" : "error",
+    summary: event.type === "tool-end" ? event.summary ?? void 0 : void 0
+  });
+}
+function agentRuntime() {
+  if (!runtimeRef) {
+    runtimeRef = createAgentRuntime2(subagentHost());
+    void runtimeRef.load();
+  }
+  return runtimeRef;
+}
+
+// lib/agent/tools/subagent-tools.ts
+var MAX_WAIT_MS = 6e5;
+var DEFAULT_WAIT_MS = 12e4;
+function subagentDelegate(deps = {}) {
+  const runtime = deps.runtime ?? agentRuntime;
+  return async (raw) => {
+    const request = raw;
+    const rt = runtime();
+    await rt.load();
+    switch (request.op) {
+      case "spawn": {
+        const r = await rt.spawn({
+          profileId: request.profileId,
+          prompt: request.prompt,
+          description: request.description,
+          readOnly: deps.readOnly === true || request.readOnly === true,
+          background: request.background,
+          signal: deps.signal,
+          parentCallId: request.callId
+        });
+        if (r.kind === "refused") return { kind: "refused", reason: r.reason };
+        if (r.kind === "started") return { kind: "job", jobId: r.id };
+        return { kind: "result", jobId: r.id, ok: r.ok, rounds: r.rounds, summary: r.summary };
+      }
+      case "await": {
+        const ms = Math.min(Math.max(request.timeoutMs ?? DEFAULT_WAIT_MS, 1e3), MAX_WAIT_MS);
+        const s = await rt.wait(request.jobId, { timeoutMs: ms, signal: deps.signal });
+        if (!s) return { kind: "unknown-job", jobId: request.jobId };
+        if (s.status !== "running" && s.status !== "queued") rt.dismissFinished(s.id);
+        return { kind: "status", jobId: s.id, status: s.status, summary: s.summary ?? "" };
+      }
+      case "message": {
+        const r = await rt.message(request.jobId, request.text, { wait: request.wait === true, signal: deps.signal });
+        if (r.kind === "unknown") return { kind: "unknown-job", jobId: request.jobId };
+        if (r.kind === "queued") return { kind: "delivered", jobId: r.id, resumed: false };
+        if (r.kind === "resumed") return { kind: "delivered", jobId: r.id, resumed: true };
+        return { kind: "result", jobId: r.id, ok: r.ok, rounds: 0, summary: r.summary };
+      }
+      case "stop":
+        return { kind: "stopped", jobId: request.jobId, stopped: rt.stop(request.jobId) };
+      case "list":
+        return {
+          kind: "list",
+          agents: rt.list().map((s) => ({ id: s.id, profile: s.profile, description: s.description, status: s.status, summary: s.summary ?? void 0 }))
+        };
+    }
+  };
+}
+
+// lib/commands/delegate.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var TASK_DESCRIPTION = [
+  "Delegate a self-contained piece of work to a subagent, which runs with its own fresh context and hands back only a summary. Use it to keep your own context small: surveys of large pages, writing all the copy, restyling dozens of layers.",
+  "The child CANNOT see this conversation \u2014 put everything it needs in the prompt: the scope (node ids), the goal, the constraints, and what you want back. It cannot spawn subagents of its own; it may send you a progress report or a question while it works, which you answer with send_message.",
+  "Several task calls in one message run at the same time. Set run_in_background when you want to carry on working while it runs: you get its id immediately and its summary arrives as a notification. Every child has an id: send_message steers a running one or continues a finished one with its whole context, await_job waits for one, stop_agent stops one, list_agents lists them."
+].join("\n\n");
+var delegateTask = defineCommand({
+  id: "delegate.task",
+  title: "Delegate to a subagent",
+  domain: "delegate",
+  // NOT harmless: a background task or a full-tool child obviously edits the document. The loop's
+  // `readOnly` flag means "independent of the other calls in this batch", which a subagent spawn is, so
+  // the agent exposure keeps saying true while the honest effect says document.
+  effect: "document",
+  permission: null,
+  needs: ["delegate"],
+  params: external_exports.object({
+    subagent_type: external_exports.string().describe("Profile id \u2014 one of the profiles listed in your system prompt (list_profiles for the full set)."),
+    prompt: external_exports.string().describe("The self-contained task. The child does not see this conversation."),
+    description: external_exports.string().optional().describe('Short label for the panel row, e.g. "Survey the pricing page".'),
+    readonly: external_exports.boolean().optional().describe("Force read-only tools for this child, whatever the profile allows."),
+    run_in_background: external_exports.boolean().optional().describe("Return a job id immediately and notify you when the child finishes.")
+  }),
+  expose: {
+    agent: { name: "task", description: TASK_DESCRIPTION, readOnly: true }
+  },
+  run: async (args, ctx) => {
+    const reply = await ctx.use("delegate")({
+      op: "spawn",
+      profileId: args.subagent_type,
+      prompt: args.prompt,
+      description: args.description,
+      readOnly: args.readonly === true,
+      background: args.run_in_background,
+      // omitted → the profile's `background` default (the SDK applies it)
+      callId: ctx.callId
+    });
+    if (reply.kind === "refused") return { summary: "task refused (nested)", data: { error: reply.reason } };
+    if (reply.kind === "job") {
+      return {
+        summary: `${args.subagent_type} started (${reply.jobId})`,
+        data: {
+          job_id: reply.jobId,
+          status: "running",
+          subagent_type: args.subagent_type,
+          note: "Keep working. Its summary arrives as a notification when it finishes; await_job waits for it if you need it before you can go on."
+        }
+      };
+    }
+    const result = reply;
+    return {
+      summary: `${args.subagent_type}: ${result.ok ? "done" : "failed"} in ${result.rounds} round${result.rounds === 1 ? "" : "s"}`,
+      data: { job_id: result.jobId, subagent_type: args.subagent_type, ok: result.ok, rounds: result.rounds, summary: result.summary }
+    };
+  }
+});
+var delegateAwait = defineCommand({
+  id: "delegate.await",
+  title: "Wait for a subagent",
+  domain: "delegate",
+  effect: "document",
+  permission: null,
+  needs: ["delegate"],
+  params: external_exports.object({
+    job_id: external_exports.string().describe("The id a task call returned."),
+    timeout_ms: external_exports.number().optional().describe("How long to wait at most, in ms (default 120000, at most 600000).")
+  }),
+  expose: {
+    agent: {
+      name: "await_job",
+      description: "Wait for a subagent by id to finish and get its summary (or its status when the wait times out). Use it when you need the answer before you can go on; otherwise keep working and let it notify you.",
+      readOnly: true
+    }
+  },
+  run: async (args, ctx) => {
+    const reply = await ctx.use("delegate")({ op: "await", jobId: args.job_id, timeoutMs: args.timeout_ms });
+    if (reply.kind === "unknown-job") {
+      return { summary: `No job ${args.job_id}`, data: { error: `No background task with id "${args.job_id}".` } };
+    }
+    const status = reply;
+    if (status.status === "running" || status.status === "queued") {
+      return {
+        summary: `${args.job_id}: ${status.status}`,
+        data: {
+          job_id: args.job_id,
+          status: status.status,
+          note: "Still going after the wait. Carry on with other work; its summary is delivered to you automatically when it lands."
+        }
+      };
+    }
+    return { summary: `${args.job_id}: ${status.status}`, data: { job_id: args.job_id, status: status.status, summary: status.summary ?? "" } };
+  }
+});
+var delegateMessage = defineCommand({
+  id: "delegate.message",
+  title: "Message a subagent",
+  domain: "delegate",
+  // A message can resume a builder, which edits the document.
+  effect: "document",
+  permission: null,
+  needs: ["delegate"],
+  params: external_exports.object({
+    job_id: external_exports.string().describe("The id a task call returned."),
+    message: external_exports.string().describe("What to tell it: a correction, an answer to its question, or the next piece of work."),
+    wait: external_exports.boolean().optional().describe("For a finished subagent: resume it and wait for its answer now.")
+  }),
+  expose: {
+    agent: {
+      name: "send_message",
+      description: "Message a subagent by id. A running one reads it at its next step (steer it, answer its question). A finished one is resumed with its whole context and this message; set wait to get its answer now, otherwise it arrives as a notification.",
+      readOnly: true
+    }
+  },
+  run: async (args, ctx) => {
+    const reply = await ctx.use("delegate")({ op: "message", jobId: args.job_id, text: args.message, wait: args.wait === true });
+    if (reply.kind === "unknown-job") return { summary: `No subagent ${args.job_id}`, data: { error: `No subagent with id "${args.job_id}".` } };
+    if (reply.kind === "delivered") {
+      return reply.resumed ? { summary: `${args.job_id}: resumed`, data: { job_id: args.job_id, status: "running", note: "Resumed with your message. Its answer arrives as a notification." } } : { summary: `${args.job_id}: message delivered`, data: { job_id: args.job_id, status: "running", note: "It reads this at its next step." } };
+    }
+    const result = reply;
+    return { summary: `${args.job_id}: ${result.ok ? "answered" : "failed"}`, data: { job_id: args.job_id, ok: result.ok, summary: result.summary } };
+  }
+});
+var delegateStop = defineCommand({
+  id: "delegate.stop",
+  title: "Stop a subagent",
+  domain: "delegate",
+  effect: "none",
+  permission: null,
+  needs: ["delegate"],
+  params: external_exports.object({ job_id: external_exports.string().describe("The id a task call returned.") }),
+  expose: { agent: { name: "stop_agent", description: "Stop one running subagent by id. Edits it already made stay.", readOnly: true } },
+  run: async (args, ctx) => {
+    const reply = await ctx.use("delegate")({ op: "stop", jobId: args.job_id });
+    const stopped = reply.kind === "stopped" && reply.stopped;
+    return { summary: stopped ? `${args.job_id}: stopped` : `${args.job_id}: not running`, data: { job_id: args.job_id, stopped } };
+  }
+});
+var delegateList = defineCommand({
+  id: "delegate.list",
+  title: "List subagents",
+  domain: "delegate",
+  effect: "none",
+  permission: null,
+  needs: ["delegate"],
+  params: external_exports.object({}),
+  expose: { agent: { name: "list_agents", description: "List your subagents: id, profile, what each was asked, its status and its last summary.", readOnly: true } },
+  run: async (_args, ctx) => {
+    const reply = await ctx.use("delegate")({ op: "list" });
+    const agents = reply.kind === "list" ? reply.agents : [];
+    return {
+      summary: `${agents.length} subagent${agents.length === 1 ? "" : "s"}`,
+      data: { agents: agents.map((a) => ({ job_id: a.id, subagent_type: a.profile, description: a.description, status: a.status, summary: a.summary })) }
+    };
+  }
+});
+var profileList = defineCommand({
+  id: "delegate.listProfiles",
+  title: "List subagent profiles",
+  domain: "delegate",
+  effect: "none",
+  permission: null,
+  params: external_exports.object({}),
+  expose: {
+    agent: {
+      name: "list_profiles",
+      description: "List the subagent profiles you can delegate to with task (id, what each is for, when to use it)."
+    }
+  },
+  run: () => {
+    const profiles = allProfiles();
+    return {
+      summary: `${profiles.length} profile${profiles.length === 1 ? "" : "s"}`,
+      data: {
+        profiles: profiles.map((p) => ({
+          id: p.id,
+          name: p.name,
+          description: p.description,
+          whenToUse: p.whenToUse,
+          readOnly: p.readOnly,
+          tools: p.tools,
+          maxRounds: p.maxRounds
+        }))
+      }
+    };
+  }
+});
+var profileRead = defineCommand({
+  id: "delegate.readProfile",
+  title: "Read a subagent profile",
+  domain: "delegate",
+  effect: "none",
+  permission: null,
+  params: external_exports.object({ id: external_exports.string().describe('The profile id, e.g. "inspector".') }),
+  expose: {
+    agent: {
+      name: "read_profile",
+      description: "Read a subagent profile in full \u2014 its instructions, tool allowlist and round budget \u2014 before you delegate to it."
+    }
+  },
+  run: ({ id }) => {
+    const profile = findProfile(id);
+    if (!profile) {
+      return { summary: `No profile "${id}"`, data: { error: `No subagent profile with id "${id}".`, available: allProfiles().map(profileIndexLine) } };
+    }
+    return {
+      summary: `Read profile: ${profile.name}`,
+      data: { id: profile.id, name: profile.name, readOnly: profile.readOnly, tools: profile.tools, maxRounds: profile.maxRounds, instructions: profile.instructions }
+    };
+  }
+});
+var delegateCommands = [delegateTask, delegateAwait, delegateMessage, delegateStop, delegateList, profileList, profileRead];
+function registerDelegateCommands() {
+  registerCommand(...delegateCommands);
+}
+
+// lib/commands/skill.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+var skillList = defineCommand({
+  id: "skill.list",
+  title: "List skills",
+  domain: "skill",
+  effect: "none",
+  // The skill sheets are the agent's own instructions, not the user's document.
+  permission: null,
+  params: external_exports.object({}),
+  expose: {
+    agent: {
+      name: "list_skills",
+      description: "List the available skills (name, what they are for, and when to use them). The full instructions come from read_skill."
+    }
+  },
+  run: () => {
+    const skills = allSkills();
+    return {
+      summary: `${skills.length} skill${skills.length === 1 ? "" : "s"}`,
+      data: { skills: skills.map((s) => ({ id: s.id, name: s.name, description: s.description, whenToUse: s.whenToUse, tools: s.tools })) }
+    };
+  }
+});
+var skillRead = defineCommand({
+  id: "skill.read",
+  title: "Read a skill",
+  domain: "skill",
+  effect: "none",
+  permission: null,
+  params: external_exports.object({ id: external_exports.string().describe('The skill id, e.g. "fill-content".') }),
+  expose: {
+    agent: {
+      name: "read_skill",
+      description: "Read a skill\u2019s full instructions by id. Do this before following a skill; the system prompt only carries the summaries."
+    }
+  },
+  run: ({ id }) => {
+    const skill = findSkill(id);
+    if (!skill) {
+      return {
+        summary: `No skill "${id}"`,
+        data: { error: `No skill with id "${id}".`, available: allSkills().map(skillIndexLine) }
+      };
+    }
+    return {
+      summary: `Read skill: ${skill.name}`,
+      data: { id: skill.id, name: skill.name, tools: skill.tools, instructions: skill.instructions }
+    };
+  }
+});
+var skillCommands = [skillList, skillRead];
+function registerSkillCommands() {
+  registerCommand(...skillCommands);
+}
+
+// lib/agent/parts.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+function todoItemsFrom(rows) {
+  if (!Array.isArray(rows)) return null;
+  return rows.map((row) => {
+    const t = row ?? {};
+    return {
+      text: String(t.title ?? t.text ?? ""),
+      done: typeof t.done === "boolean" ? t.done : t.status === "done"
+    };
+  });
+}
+var textOf2 = (m) => m.parts.filter((p) => p.type === "text").map((p) => p.text).join("");
+function pushTextDelta(parts, delta) {
+  const last = parts[parts.length - 1];
+  if (last?.type === "text") {
+    parts[parts.length - 1] = { type: "text", text: last.text + delta };
+    return parts;
+  }
+  return [...parts, { type: "text", text: delta }];
+}
+function pushReasoningDelta(parts, delta) {
+  const last = parts[parts.length - 1];
+  if (last?.type === "reasoning") {
+    parts[parts.length - 1] = { type: "reasoning", text: last.text + delta };
+    return parts;
+  }
+  return [...parts, { type: "reasoning", text: delta }];
+}
+function upsertToolPart(parts, part) {
+  const i = parts.findIndex((p) => p.type === "tool" && p.id === part.id);
+  if (i < 0) return [...parts, part];
+  const next = [...parts];
+  next[i] = { ...next[i], ...part };
+  return next;
+}
+
+// lib/agent/runner.ts
+var ALWAYS_ALLOWED = ["list_skills", "read_skill", "manage_todos", "notify", "get_selection", "task", "await_job", "send_message", "stop_agent", "list_agents", "list_profiles", "read_profile", "ask_user"];
+var MAX_HISTORY_MESSAGES = 24;
+var MAX_PARALLEL_TOOLS = 4;
+var MAX_TOOL_RESULT_CHARS = 48e3;
+var TURN_MAX_ROUNDS = 500;
+function needsEditableSession(name) {
+  const tool = getTool(name);
+  if (tool?.readOnly) return false;
+  if (tool?.interactive) return false;
+  return true;
+}
+function guardEdit(name) {
+  if (!needsEditableSession(name)) return;
+  const reason = editBlockReason();
+  if (reason) throw new ToolError(`${name} cannot run: ${reason}`);
+}
+function historyMessages() {
+  return activeMessages().slice(-MAX_HISTORY_MESSAGES).map((m) => ({ role: m.role, content: textOf2(m).trim() })).filter((m) => !!m.content);
+}
+function systemMessage(skillId, mentions = []) {
+  const st = useEditorStore.getState();
+  return {
+    role: "system",
+    content: buildSystemPrompt({
+      doc: st.document,
+      pageId: st.currentPageId,
+      selection: st.selection,
+      camera: st.camera,
+      viewport: typeof window === "undefined" ? void 0 : { width: window.innerWidth, height: window.innerHeight },
+      activeSkillId: skillId,
+      readOnly: !!editBlockReason(),
+      mentions
+    })
+  };
+}
+var registerTurnTools = (deps) => {
+  registerBuiltinTools();
+  registerSkillCommands();
+  registerDelegateCommands();
+  registerDangerousCommands();
+  provideAgentCapability("delegate", subagentDelegate(deps));
+};
+var specsFor = (skillId) => {
+  const skill = skillId ? findSkill(skillId) : void 0;
+  return skill?.tools.length ? toolSpecs([.../* @__PURE__ */ new Set([...skill.tools, ...ALWAYS_ALLOWED])]) : toolSpecs();
+};
+var loopTools = (skillId) => specsFor(skillId).map((spec) => ({ spec, readOnly: getTool(spec.function.name)?.readOnly === true }));
+function syncTodos(run) {
+  if (run.name !== "manage_todos" || !run.ok) return;
+  try {
+    const data = JSON.parse(run.content);
+    const items = todoItemsFrom(data.todos);
+    if (items) setTodos(items);
+  } catch {
+  }
+}
+var runs;
+var agentRuns = () => runs ??= serialRuns(runStore(indexedDbStore(AGENT_SESSIONS_DB), "editor"));
+var setAgentRuns = (store) => {
+  runs = store && serialRuns(store);
+};
+var RESUME_WINDOW_MS = 30 * 6e4;
+var MAX_INTERRUPTIONS = 6;
+var SUSPEND_RESTART_MS = 5e3;
+var STOPPED_MESSAGE = "Stopped. Any edits already applied are still there.";
+async function runTurn(text, mentions = []) {
+  const availability = aiAvailability();
+  if (!availability.ok) {
+    useAgentStore.setState({ error: { message: availability.message, code: availability.reason } });
+    return;
+  }
+  if (!agentModel()) {
+    useAgentStore.setState({ error: { message: "Pick a chat model for the agent first.", code: "no_model" } });
+    return;
+  }
+  const skillId = mentions.find((m) => m.kind === "skill")?.id ?? useAgentStore.getState().skillId;
+  const checkpoint = rememberCheckpoint(useEditorStore.getState().document);
+  const user = { id: newId(), role: "user", parts: [{ type: "text", text }], createdAt: Date.now() };
+  appendMessage(user);
+  const assistantId = newId();
+  appendMessage({ id: assistantId, role: "assistant", parts: [], createdAt: Date.now(), checkpoint });
+  const s = useAgentStore.getState();
+  const meta = {
+    documentId: s.documentId ?? useEditorStore.getState().document.id,
+    threadId: s.activeThreadId ?? "",
+    assistantId,
+    skillId,
+    mentions,
+    wantsChange: wantsChange(text)
+  };
+  await drive(meta, { messages: [systemMessage(skillId, mentions), ...historyMessages()], checkpoint });
+}
+async function resumeInterrupted(documentId) {
+  if (useAgentStore.getState().running) return false;
+  const store = agentRuns();
+  let list;
+  try {
+    list = await interruptedRuns(store);
+  } catch {
+    return false;
+  }
+  const mine = list.filter((r) => r.meta?.documentId === documentId).sort((a, b) => b.updatedAt - a.updatedAt);
+  const [latest, ...rest] = mine;
+  for (const r of rest) await store.save({ ...r, status: "stopped", updatedAt: Date.now() });
+  if (!latest) return false;
+  if (Date.now() - latest.updatedAt > RESUME_WINDOW_MS || !findMessage(latest.meta)) {
+    await store.save({ ...latest, status: "stopped", updatedAt: Date.now() });
+    return false;
+  }
+  if (useAgentStore.getState().running) return false;
+  await drive(latest.meta, { resume: latest });
+  return true;
+}
+async function continueTurn() {
+  const s = useAgentStore.getState();
+  if (s.running) return false;
+  const messages = activeMessages();
+  const last = [...messages].reverse().find((m) => m.role === "assistant");
+  if (!last) return false;
+  const record = await agentRuns().get(last.id).catch(() => null);
+  if (record?.meta && record.meta.threadId === s.activeThreadId) {
+    await drive(record.meta, { resume: { ...record, status: "running" } });
+    return true;
+  }
+  const ask = [...messages].reverse().find((m) => m.role === "user");
+  if (!ask) return false;
+  await runTurn(textOf2(ask));
+  return true;
+}
+function findMessage(meta) {
+  if (!meta) return void 0;
+  return useAgentStore.getState().threads.find((t) => t.id === meta.threadId)?.messages.find((m) => m.id === meta.assistantId);
+}
+function installPageHandlers() {
+  if (typeof window === "undefined") return () => {
+  };
+  const save = () => persistThreads();
+  const onVisibility = () => {
+    if (document.visibilityState === "hidden") save();
+  };
+  window.addEventListener("pagehide", save);
+  document.addEventListener("visibilitychange", onVisibility);
+  return () => {
+    window.removeEventListener("pagehide", save);
+    document.removeEventListener("visibilitychange", onVisibility);
+  };
+}
+function resilientModel(model, turn, parts) {
+  return async (messages, specs, hooks, _signal, request) => {
+    await whenResumable(void 0, turn);
+    const call = new AbortController();
+    const onTurnAbort = () => call.abort();
+    turn.addEventListener("abort", onTurnAbort);
+    let hiddenAt = 0;
+    const onVisibility = () => {
+      if (document.visibilityState === "hidden") hiddenAt = Date.now();
+      else if (hiddenAt && Date.now() - hiddenAt > SUSPEND_RESTART_MS) call.abort();
+    };
+    if (typeof document !== "undefined") document.addEventListener("visibilitychange", onVisibility);
+    const base = parts.get();
+    try {
+      const cut = new Promise((_, reject) => call.signal.addEventListener("abort", () => reject(new Error("aborted")), { once: true }));
+      cut.catch(() => {
+      });
+      return await Promise.race([model(messages, specs, hooks, call.signal, request), cut]);
+    } catch (err) {
+      parts.set(base);
+      if (call.signal.aborted && !turn.aborted) throw { message: "The stream was interrupted.", code: "interrupted" };
+      throw err;
+    } finally {
+      turn.removeEventListener("abort", onTurnAbort);
+      if (typeof document !== "undefined") document.removeEventListener("visibilitychange", onVisibility);
+    }
+  };
+}
+async function drive(meta, start) {
+  const model = agentModel();
+  if (!model) {
+    useAgentStore.setState({ error: { message: "Pick a chat model for the agent first.", code: "no_model" } });
+    return;
+  }
+  const store = agentRuns();
+  const id = meta.assistantId;
+  const before = useEditorStore.getState().document;
+  if (useAgentStore.getState().activeThreadId !== meta.threadId) useAgentStore.setState({ activeThreadId: meta.threadId });
+  let checkpoint = "checkpoint" in start ? start.checkpoint : findMessage(meta)?.checkpoint;
+  if (!checkpoint) {
+    checkpoint = rememberCheckpoint(before);
+    updateMessage(id, (m) => ({ ...m, checkpoint }), { save: false });
+  }
+  const ledger = createToolLedger(meta.ledger);
+  let parts = [...findMessage(meta)?.parts ?? []].filter((p) => !(p.type === "error" && p.message === STOPPED_MESSAGE));
+  const flush = (save = false) => setParts(id, parts, { save });
+  if ("resume" in start) {
+    parts = parts.map((p) => {
+      if (p.type !== "tool" || p.status !== "running") return p;
+      const done = ledger.get(p.id);
+      return done ? { ...p, status: done.ok ? "done" : "error", summary: done.summary, result: done.content } : { ...p, status: "error", summary: "interrupted", error: "interrupted" };
+    });
+    parts = [...parts, { type: "notice", kind: "resumed" }];
+    flush(true);
+  }
+  const abort = new AbortController();
+  useAgentStore.setState({ running: true, resuming: false, abort, error: null });
+  const ctx = editorToolContext(abort.signal);
+  const { createDesignPreview, DESIGN_TOOL } = await import("./live-SJGND5BC.js");
+  const preview = createDesignPreview();
+  const readOnly = !!editBlockReason();
+  registerTurnTools({ readOnly, signal: abort.signal });
+  const runtime = agentRuntime();
+  const tools = loopTools(meta.skillId);
+  const canWrite = !readOnly && meta.wantsChange;
+  const writeTool = tools.some((t) => t.spec.function.name === DESIGN_TOOL) ? DESIGN_TOOL : null;
+  const guard = createActionGuard({ enabled: canWrite, writeTool, initial: meta.guard });
+  let pending = null;
+  let saving = Promise.resolve();
+  const saveMeta = () => {
+    meta.guard = guard.state();
+    meta.ledger = ledger.entries();
+    meta.pending = pending;
+    const rec = store.peek(id);
+    if (rec) saving = store.save({ ...rec, meta: { ...meta }, updatedAt: Date.now() }).catch(() => {
+    });
+    return saving;
+  };
+  const offPage = installPageHandlers();
+  let interruptions = 0;
+  let resumeFrom = "resume" in start ? start.resume : null;
+  try {
+    while (true) {
+      const options = {
+        tools,
+        meta,
+        stopped: () => abort.signal.aborted,
+        drainNotifications: () => {
+          const notes = guard.drain();
+          if (notes.length) {
+            parts = [...parts, { type: "notice", kind: "read-budget" }];
+            flush();
+          }
+          return [...notes, ...runtime.drainParentNotifications()];
+        },
+        maxParallel: MAX_PARALLEL_TOOLS,
+        // The loop's default cut every result at 8000 characters AFTER the tool had honoured its own limit, so
+        // export_svg with maxChars 40000 still came back without its last paths and the model could not
+        // rebuild the artwork. Tools bound their own output; this is only the backstop.
+        maxResultChars: MAX_TOOL_RESULT_CHARS,
+        maxRounds: TURN_MAX_ROUNDS,
+        modelRetries: 3,
+        isRecoverable: (err) => !abort.signal.aborted && isInterruption(err),
+        requireAction: canWrite ? { nudges: ACTION_NUDGES, message: ACTION_NUDGE } : false,
+        toolChoice: () => guard.toolChoice(),
+        callModel: resilientModel(agentModel2(() => model), abort.signal, { get: () => parts, set: (p) => {
+          parts = p;
+          flush();
+        } }),
+        checkpoint: async () => {
+          pending = null;
+          ledger.clear();
+          await saveMeta();
+        },
+        execTool: (call) => runOnce(ledger, call, async () => {
+          const row = { type: "tool", id: call.id, name: call.name, argsText: call.argsText, status: "running" };
+          parts = upsertToolPart(parts, row);
+          flush();
+          const docBefore = useEditorStore.getState().document;
+          try {
+            if (call.name === DESIGN_TOOL) preview.end();
+            guardEdit(call.name);
+            const result = await runTool(call.name, call.argsText, { ...ctx, toolCallId: call.id });
+            const content = JSON.stringify(result.data ?? { ok: true, summary: result.summary });
+            parts = upsertToolPart(parts, { ...row, status: "done", summary: result.summary, result: content });
+            for (const url of result.images ?? []) parts = [...parts, { type: "image", url, caption: call.name }];
+            const acted = useEditorStore.getState().document !== docBefore;
+            return { id: call.id, name: call.name, argsText: call.argsText, ok: true, summary: result.summary, content, images: result.images, acted };
+          } catch (err) {
+            const message = err.message ?? String(err);
+            parts = upsertToolPart(parts, { ...row, status: "error", summary: message, error: message });
+            return { id: call.id, name: call.name, argsText: call.argsText, ok: false, summary: message, content: JSON.stringify({ error: message }), acted: false };
+          } finally {
+            flush(true);
+          }
+        }).then((run) => {
+          void saveMeta();
+          return run;
+        }),
+        hooks: {
+          onAssistantStart: () => {
+            pending = { text: "", calls: [] };
+          },
+          onTextDelta: (d) => {
+            parts = pushTextDelta([...parts], d);
+            if (pending) pending.text += d;
+            flush();
+          },
+          onReasoningDelta: (d) => {
+            parts = pushReasoningDelta([...parts], d);
+            flush();
+          },
+          onToolProgress: (p) => preview.update(p.name, p.arguments),
+          onToolStart: (call) => {
+            pending?.calls.push({ id: call.id, name: call.name, argsText: call.argsText });
+            void saveMeta();
+          },
+          onToolEnd: (run) => {
+            guard.onRun(run, run.acted === true);
+            syncTodos(run);
+          },
+          onRoundEnd: () => guard.onRoundEnd(),
+          onNudge: () => {
+            const count = guard.onNudge();
+            parts = [...parts, { type: "notice", kind: "nudge", count, max: ACTION_NUDGES }];
+            flush(true);
+          }
+        }
+      };
+      try {
+        let outcome;
+        if (resumeFrom) {
+          const cp = resumeFrom.checkpoint;
+          const nudgesLeft = canWrite ? Math.max(0, ACTION_NUDGES - guard.state().nudges) : 0;
+          const patched = { ...resumeFrom, status: "running", checkpoint: { ...cp, nudgesLeft, messages: resumeTranscript(cp.messages, meta.pending, meta.ledger) } };
+          await store.save(patched);
+          pending = null;
+          outcome = await resumeRun(id, store, options);
+        } else {
+          if (!("messages" in start)) throw new Error("nothing to run");
+          outcome = await runPersistent({ ...options, id, runs: store, messages: start.messages });
+        }
+        if (canWrite && !outcome.stopped && !outcome.acted && !guard.acted) parts = [...parts, { type: "notice", kind: "no-change" }];
+        break;
+      } catch (err) {
+        if (abort.signal.aborted) break;
+        const hidden = typeof document !== "undefined" && document.visibilityState === "hidden";
+        if (isInterruption(err, hidden) && interruptions < MAX_INTERRUPTIONS) {
+          interruptions++;
+          await saving;
+          const rec = await store.get(id);
+          if (!rec) throw err;
+          await store.save({ ...rec, status: "running", error: void 0, updatedAt: Date.now() });
+          useAgentStore.setState({ resuming: true });
+          persistThreads();
+          await whenResumable(void 0, abort.signal, Math.min(3e4, 1e3 * 2 ** interruptions));
+          if (abort.signal.aborted) break;
+          useAgentStore.setState({ resuming: false });
+          resumeFrom = await store.get(id);
+          parts = [...parts, { type: "notice", kind: "resumed" }];
+          flush(true);
+          continue;
+        }
+        throw err;
+      }
+    }
+  } catch (err) {
+    if (!abort.signal.aborted) {
+      const message = err?.message ?? String(err);
+      const code = err?.code;
+      parts = [...parts, { type: "error", message, code }];
+    }
+  } finally {
+    offPage();
+    preview.end();
+    if (abort.signal.aborted) {
+      runtime.stopAll();
+      parts = [...parts, { type: "error", message: STOPPED_MESSAGE }];
+    }
+    if (useEditorStore.getState().document === before) updateMessage(id, (m) => ({ ...m, checkpoint: void 0 }), { save: false });
+    flush(true);
+    updateActiveThread((t) => ({ ...t, checkpoint: { id: checkpoint, label: "Undo these changes" } }));
+    useAgentStore.setState({ running: false, resuming: false, abort: null });
+  }
+}
+export {
+  agentRuns,
+  continueTurn,
+  editorToolContext,
+  needsEditableSession,
+  onChildTool,
+  resumeInterrupted,
+  runTurn,
+  setAgentRuns
+};