privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-CWRFLGQU.mjs

@@ -0,0 +1,1883 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  acquireAccountCredential,
+  authedFetch,
+  currentUser,
+  describeAccountBalanceError,
+  hasCredentials,
+  isConnectionFailureText,
+  logout,
+  notifySignedIn,
+  refreshAccountCredentials,
+  runDeviceLogin,
+  serverBaseUrl
+} from "./c-EC3LJ2KF.mjs";
+import {
+  agentDir,
+  globalDir
+} from "./c-YGQHSVSK.mjs";
+import {
+  interpretReport,
+  teePosture,
+  tierFromTeePosture
+} from "./c-76QH4UCP.mjs";
+import {
+  SecureClient
+} from "./c-FJ5T42DS.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// src/providers/account.ts?ext=privateer-gate
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join4 } from "node:path";
+
+// src/util/openBrowser.ts?ext=privateer-gate
+import { spawn } from "node:child_process";
+function canOpenBrowser(env = process.env, platform = process.platform) {
+  if (env.PRIVATEER_NO_BROWSER?.trim()) return false;
+  if (env.SSH_TTY || env.SSH_CONNECTION) return false;
+  if (platform !== "darwin" && platform !== "win32" && !env.DISPLAY && !env.WAYLAND_DISPLAY) return false;
+  return true;
+}
+__name(canOpenBrowser, "canOpenBrowser");
+function browsableUrl(raw) {
+  const s = (raw ?? "").trim();
+  if (!s) return void 0;
+  try {
+    const u = new URL(s);
+    if (u.protocol !== "https:" && u.protocol !== "http:") return void 0;
+    return u.href;
+  } catch {
+    return void 0;
+  }
+}
+__name(browsableUrl, "browsableUrl");
+function openInBrowser(rawUrl) {
+  const url = browsableUrl(rawUrl);
+  if (!url) return Promise.resolve(false);
+  let cmd;
+  let args;
+  if (process.platform === "darwin") {
+    cmd = "open";
+    args = [url];
+  } else if (process.platform === "win32") {
+    cmd = "cmd";
+    args = ["/c", "start", "", url.replace(/&/g, "^&")];
+  } else {
+    cmd = "xdg-open";
+    args = [url];
+  }
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = /* @__PURE__ */ __name((ok) => {
+      if (!settled) {
+        settled = true;
+        resolve(ok);
+      }
+    }, "done");
+    try {
+      const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+      child.once("error", () => done(false));
+      child.once("exit", (code) => done(code === 0));
+      child.unref();
+      setTimeout(() => done(true), 2e3).unref?.();
+    } catch {
+      done(false);
+    }
+  });
+}
+__name(openInBrowser, "openInBrowser");
+
+// src/util/gzipRequestBody.ts?ext=privateer-gate
+import { gzipSync } from "node:zlib";
+var INFERENCE_PATH = "/api/agent/v1";
+var REJECTS_ENCODING = /* @__PURE__ */ new Set([400, 411, 415]);
+var installed = null;
+var enabled = true;
+function compressible(body) {
+  return typeof body === "string" || body instanceof ArrayBuffer || ArrayBuffer.isView(body);
+}
+__name(compressible, "compressible");
+function toBuffer(body) {
+  if (typeof body === "string") return Buffer.from(body, "utf8");
+  if (body instanceof ArrayBuffer) return Buffer.from(body);
+  return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+}
+__name(toBuffer, "toBuffer");
+function targetsInference(url) {
+  try {
+    const base = new URL(serverBaseUrl());
+    const u = new URL(url, base);
+    if (u.origin !== base.origin) return false;
+    const mount = base.pathname === "/" ? "" : base.pathname.replace(/\/+$/, "");
+    return u.pathname.startsWith(`${mount}${INFERENCE_PATH}`);
+  } catch {
+    return false;
+  }
+}
+__name(targetsInference, "targetsInference");
+function urlOf(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.href;
+  return input.url;
+}
+__name(urlOf, "urlOf");
+function installGzipRequestBodies() {
+  if (installed) return;
+  if (process.env.PRIVATEER_NO_GZIP === "1") return;
+  const inner = globalThis.fetch;
+  installed = inner;
+  globalThis.fetch = async (input, init) => {
+    const body = init?.body;
+    if (!enabled || !init || !compressible(body) || !targetsInference(urlOf(input))) {
+      return await inner(input, init);
+    }
+    const headers = new Headers(init.headers);
+    if (headers.has("content-encoding")) return await inner(input, init);
+    headers.set("content-encoding", "gzip");
+    headers.delete("content-length");
+    const gz = gzipSync(toBuffer(body), { level: 1 });
+    const res = await inner(input, { ...init, headers, body: gz });
+    if (!REJECTS_ENCODING.has(res.status)) return res;
+    const plain = await inner(input, init);
+    if (plain.ok) {
+      enabled = false;
+      void res.body?.cancel().catch(() => {
+      });
+      return plain;
+    }
+    void plain.body?.cancel().catch(() => {
+    });
+    return res;
+  };
+}
+__name(installGzipRequestBodies, "installGzipRequestBodies");
+
+// src/providers/defaultModel.ts?ext=privateer-gate
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+var TINFOIL_MODEL_ID = "tinfoil/gemma4-31b";
+var TINFOIL_DEFAULT_SPEC = TINFOIL_MODEL_ID;
+var ACCOUNT_DEFAULT_MODEL_ID = TINFOIL_MODEL_ID;
+var ACCOUNT_DEFAULT_SPEC = `privateer/${ACCOUNT_DEFAULT_MODEL_ID}`;
+var ACCOUNT_NEAR_MODEL_ID = "near/zai-org/GLM-5.1-FP8";
+var LEGACY_BYO_FALLBACK = "openrouter/openai/gpt-4o-mini";
+var BYO_BY_KEY = [
+  { env: "ANTHROPIC_API_KEY", spec: "anthropic/claude-opus-4-8" },
+  { env: "OPENAI_API_KEY", spec: "openai/gpt-5.5" },
+  { env: "OPENROUTER_API_KEY", spec: LEGACY_BYO_FALLBACK }
+];
+function savedPiDefaultSpec() {
+  try {
+    const raw = readFileSync(join(agentDir(), "settings.json"), "utf8").trim();
+    if (!raw) return null;
+    const s = JSON.parse(raw);
+    const provider = typeof s.defaultProvider === "string" ? s.defaultProvider.trim() : "";
+    const modelId = typeof s.defaultModel === "string" ? s.defaultModel.trim() : "";
+    return provider && modelId ? `${provider}/${modelId}` : null;
+  } catch {
+    return null;
+  }
+}
+__name(savedPiDefaultSpec, "savedPiDefaultSpec");
+function resolveDefaultModel(opts = {}) {
+  const env = opts.env ?? process.env;
+  const explicit = opts.explicit?.trim();
+  if (explicit) return explicit;
+  const fromEnv = env.PRIVATEER_MODEL?.trim();
+  if (fromEnv) return fromEnv;
+  const saved = opts.saved === void 0 ? savedPiDefaultSpec() : opts.saved;
+  if (saved) return saved;
+  if (env.TINFOIL_API_KEY?.trim()) return TINFOIL_DEFAULT_SPEC;
+  const signedIn = opts.signedIn ?? hasCredentials();
+  if (signedIn) return ACCOUNT_DEFAULT_SPEC;
+  for (const { env: keyName, spec } of BYO_BY_KEY) {
+    if (env[keyName]?.trim()) return spec;
+  }
+  return ACCOUNT_DEFAULT_SPEC;
+}
+__name(resolveDefaultModel, "resolveDefaultModel");
+function resolveSignedInModel(env = process.env) {
+  return resolveDefaultModel({ env, signedIn: true, saved: null });
+}
+__name(resolveSignedInModel, "resolveSignedInModel");
+function splitSpec(spec) {
+  const slash = spec.indexOf("/");
+  if (slash <= 0 || slash === spec.length - 1) return null;
+  return { provider: spec.slice(0, slash), modelId: spec.slice(slash + 1) };
+}
+__name(splitSpec, "splitSpec");
+function ensurePiDefaultModel(spec = resolveSignedInModel()) {
+  return writeSettingsDefaultModel(spec, true);
+}
+__name(ensurePiDefaultModel, "ensurePiDefaultModel");
+function writeSettingsDefaultModel(spec, onlyIfUnset) {
+  const parts = splitSpec(spec);
+  if (!parts) return null;
+  const dir = agentDir();
+  const settingsPath = join(dir, "settings.json");
+  try {
+    mkdirSync(dir, { recursive: true });
+    let settings = {};
+    if (existsSync(settingsPath)) {
+      const raw = readFileSync(settingsPath, "utf8").trim();
+      if (raw) settings = JSON.parse(raw);
+    }
+    if (onlyIfUnset && typeof settings.defaultModel === "string" && settings.defaultModel.trim()) {
+      return null;
+    }
+    settings.defaultProvider = parts.provider;
+    settings.defaultModel = parts.modelId;
+    writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
+`);
+    return spec;
+  } catch {
+    return null;
+  }
+}
+__name(writeSettingsDefaultModel, "writeSettingsDefaultModel");
+
+// src/providers/vision.ts?ext=privateer-gate
+var VISION_PATTERNS = [
+  // ── Named in the id ────────────────────────────────────────────────────────
+  // Qwen's vision line (qwen3-vl-*, qwen2.5-vl-72b, near/Qwen/Qwen3-VL-30B-A3B) and
+  // Baidu's (ernie-4.5-vl-424b). Qwen ships VL as a SEPARATE line, which is also why
+  // the plain qwen3.x ids below are deliberately absent.
+  /-vl[-_.]/i,
+  // Z.ai marks vision with a trailing v on the version: glm-4.5v, glm-4.6v,
+  // glm-5v-turbo. Same reasoning — the unsuffixed glm-5.x are their text siblings.
+  /\bglm-\d+(?:\.\d+)?v\b/i,
+  // ByteDance's GUI agent reads screenshots; that is the whole point of it.
+  /\bui-tars\b/i,
+  // ── Families that are multimodal throughout ────────────────────────────────
+  // Every Claude from 3 onwards takes images, and 3 is the oldest in the catalog.
+  /(^|\/)anthropic\/claude-/i,
+  // Gemini has been multimodal since 1.0.
+  /(^|\/)google\/gemini-/i,
+  // Gemma from 3 on is multimodal; gemma-2 is not, so the version is part of the
+  // match. Covers google/gemma-3-27b-it, google/gemma-4-31b-it, tinfoil/gemma4-31b,
+  // near/google/gemma-4-31B-it, phala/google/gemma-4-31b-it and the Phala
+  // gemma-4 derivatives.
+  /gemma-?[34]/i,
+  // gpt-4o, gpt-4.1 and the whole gpt-5 line. Deliberately NOT `openai/gpt-4`
+  // (the original is text-only), not gpt-3.5, and not gpt-oss — the open-weights
+  // models are text-only, which is what our own default was until this change.
+  /(^|\/)openai\/gpt-(?:4o|4\.1|5)/i,
+  // Llama 4 (maverick, scout) is natively multimodal; 3.x is not.
+  /(^|\/)meta-llama\/llama-4-/i,
+  // Nova lite/pro/premier take images; nova-micro is text-only.
+  /(^|\/)amazon\/nova-(?:2-)?(?:lite|pro|premier)/i,
+  // Grok 4 and up.
+  /(^|\/)x-ai\/grok-4/i,
+  // Mistral's multimodal tiers: small 3.2 and the medium 3 line.
+  /(^|\/)mistralai\/mistral-(?:small-3\.2|medium-3)/i
+];
+function acceptsImages(modelId) {
+  return VISION_PATTERNS.some((re) => re.test(modelId));
+}
+__name(acceptsImages, "acceptsImages");
+function visionInput(modelId) {
+  return acceptsImages(modelId) ? ["text", "image"] : ["text"];
+}
+__name(visionInput, "visionInput");
+
+// src/providers/piAuthStore.ts?ext=privateer-gate
+import { join as join2 } from "node:path";
+function resolveAgentDir(agentDir2) {
+  return agentDir2 ?? process.env.PI_CODING_AGENT_DIR ?? agentDir();
+}
+__name(resolveAgentDir, "resolveAgentDir");
+var cached;
+var override;
+function piAuthStore(agentDir2) {
+  if (override) return override;
+  const path = join2(resolveAgentDir(agentDir2), "auth.json");
+  if (cached?.path !== path) {
+    cached = {
+      path,
+      store: import("./c-RDMJZCOX.mjs").then((pi) => {
+        const ctor = pi.AuthStorage;
+        if (!ctor) {
+          throw new Error(
+            "pi's AuthStorage export is missing \u2014 the privateer patch for @earendil-works/pi-coding-agent has not been applied to this install. Run `privateer` once with write access to node_modules (a root-owned global install needs sudo), or reinstall with a release bundle."
+          );
+        }
+        return ctor.create(path);
+      })
+    };
+  }
+  return cached.store;
+}
+__name(piAuthStore, "piAuthStore");
+
+// src/providers/sealedShim.ts?ext=privateer-gate
+import http from "node:http";
+import { Readable } from "node:stream";
+
+// src/providers/phala/aci-verifier/errors.ts?ext=privateer-gate
+var AciError = class extends Error {
+  static {
+    __name(this, "AciError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "AciError";
+  }
+};
+var AciFormatError = class extends AciError {
+  static {
+    __name(this, "AciFormatError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "AciFormatError";
+  }
+};
+
+// src/providers/phala/aci-verifier/jcs.ts?ext=privateer-gate
+function canonicalize(value) {
+  if (value === null) return "null";
+  switch (typeof value) {
+    case "boolean":
+      return value ? "true" : "false";
+    case "number":
+      if (!Number.isInteger(value)) {
+        throw new AciFormatError(
+          `JCS: ACI restricts numbers to integers, got ${value} (\xA73)`
+        );
+      }
+      return Object.is(value, -0) ? "0" : String(value);
+    case "string":
+      return JSON.stringify(value);
+    case "object":
+      if (Array.isArray(value)) {
+        return "[" + value.map(canonicalize).join(",") + "]";
+      }
+      return serializeObject(value);
+    default:
+      throw new AciFormatError(`JCS: unsupported type ${typeof value}`);
+  }
+}
+__name(canonicalize, "canonicalize");
+function serializeObject(obj) {
+  const keys = Object.keys(obj).filter((k) => obj[k] !== void 0).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  let out = "{";
+  for (let i = 0; i < keys.length; i++) {
+    const k = keys[i];
+    if (i > 0) out += ",";
+    out += JSON.stringify(k) + ":" + canonicalize(obj[k]);
+  }
+  return out + "}";
+}
+__name(serializeObject, "serializeObject");
+function jcsBytes(value) {
+  return new TextEncoder().encode(canonicalize(value));
+}
+__name(jcsBytes, "jcsBytes");
+
+// src/providers/phala/aci-verifier/crypto.ts?ext=privateer-gate
+var subtle = globalThis.crypto.subtle;
+function toHex(bytes) {
+  let out = "";
+  for (const b of bytes) out += b.toString(16).padStart(2, "0");
+  return out;
+}
+__name(toHex, "toHex");
+function fromHex(hex) {
+  const h = hex.startsWith("0x") || hex.startsWith("0X") ? hex.slice(2) : hex;
+  if (h.length % 2 !== 0) {
+    throw new AciFormatError(`hex string has odd length: ${hex.length} chars`);
+  }
+  const out = new Uint8Array(h.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    const byte = Number.parseInt(h.slice(i * 2, i * 2 + 2), 16);
+    if (Number.isNaN(byte)) {
+      throw new AciFormatError(`invalid hex at offset ${i * 2}: "${h.slice(i * 2, i * 2 + 2)}"`);
+    }
+    out[i] = byte;
+  }
+  return out;
+}
+__name(fromHex, "fromHex");
+async function sha256(bytes) {
+  return new Uint8Array(await subtle.digest("SHA-256", bytes));
+}
+__name(sha256, "sha256");
+async function sha256Hex(bytes) {
+  return toHex(await sha256(bytes));
+}
+__name(sha256Hex, "sha256Hex");
+async function sha256Prefixed(bytes) {
+  return "sha256:" + await sha256Hex(bytes);
+}
+__name(sha256Prefixed, "sha256Prefixed");
+
+// src/providers/phala/aci-verifier/digest.ts?ext=privateer-gate
+var DIGEST_RE = /^sha256:[0-9a-f]{64}$/;
+var NONCE_RE = /^[0-9a-f]{64}$/;
+async function computeKeysetDigest(keyset) {
+  return sha256Prefixed(jcsBytes(keyset));
+}
+__name(computeKeysetDigest, "computeKeysetDigest");
+function attestationStatement(keysetDigest, nonce) {
+  if (!DIGEST_RE.test(keysetDigest)) {
+    throw new AciFormatError(`keyset digest is not sha256:<64-hex>: "${keysetDigest}"`);
+  }
+  if (nonce != null && !NONCE_RE.test(nonce)) {
+    throw new AciFormatError("nonce must be exactly 64 lowercase hex characters (\xA73.2)");
+  }
+  const noncePart = nonce == null ? "null" : `"${nonce}"`;
+  return new TextEncoder().encode(
+    `{"keyset_digest":"${keysetDigest}","nonce":${noncePart},"purpose":"aci.report_data.v1"}`
+  );
+}
+__name(attestationStatement, "attestationStatement");
+async function computeReportData(keysetDigest, nonce) {
+  return sha256Hex(attestationStatement(keysetDigest, nonce));
+}
+__name(computeReportData, "computeReportData");
+
+// src/providers/phala/aci-verifier/e2ee.ts?ext=privateer-gate
+function requestAad(params) {
+  return jcsBytes({
+    purpose: "aci.e2ee.request.v2",
+    algo: params.algo,
+    model: params.model,
+    field: params.field,
+    nonce: params.nonce,
+    ts: params.ts
+  });
+}
+__name(requestAad, "requestAad");
+function responseAad(params) {
+  return jcsBytes({
+    purpose: "aci.e2ee.response.v2",
+    algo: params.algo,
+    model: params.model,
+    id: params.id,
+    field: params.field,
+    nonce: params.nonce,
+    ts: params.ts
+  });
+}
+__name(responseAad, "responseAad");
+
+// src/providers/phala/aci-verifier/e2ee-channel.ts?ext=privateer-gate
+var ALGO = "x25519-aes-256-gcm-hkdf-sha256";
+var subtle2 = globalThis.crypto.subtle;
+var enc = new TextEncoder();
+var dec = new TextDecoder();
+var HKDF_INFO = enc.encode("aci.e2ee.v2.x25519");
+async function openE2eeChannel(report, verification) {
+  if (!verification.ok || verification.workloadKeysetDigest !== report.workload_keyset_digest) {
+    throw new Error("openE2eeChannel: report is not verified \u2014 call verifyReportBinding and check .ok");
+  }
+  const keys = verification.keyset?.e2ee_public_keys ?? [];
+  const service = keys.find((k) => k?.algo === ALGO);
+  if (!service) throw new Error(`openE2eeChannel: no attested ${ALGO} key in the keyset`);
+  const serviceRaw = fromHex(service.public_key);
+  const client2 = await subtle2.generateKey({ name: "X25519" }, true, ["deriveBits"]);
+  const clientPubHex = toHex(new Uint8Array(await subtle2.exportKey("raw", client2.publicKey)));
+  let sent;
+  return {
+    async seal(request) {
+      const model = request.model;
+      if (typeof model !== "string") throw new Error("seal: request.model must be a string");
+      const nonce = toHex(crypto.getRandomValues(new Uint8Array(32)));
+      const ts = Math.floor(Date.now() / 1e3);
+      sent = { model, nonce, ts };
+      const encField = /* @__PURE__ */ __name((text, field) => sealField(serviceRaw, enc.encode(text), requestAad({ algo: ALGO, model, field, nonce, ts })), "encField");
+      const body = { ...request };
+      if (Array.isArray(request.messages)) {
+        body.messages = await Promise.all(
+          request.messages.map(async (m, i) => {
+            if (m?.content == null) return m;
+            const text = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+            return { ...m, content: await encField(text, `messages.${i}.content`) };
+          })
+        );
+      } else if (request.prompt !== void 0) {
+        body.prompt = await sealStringOrArray(request.prompt, "prompt", encField);
+      } else if (request.input !== void 0) {
+        body.input = await sealStringOrArray(request.input, "input", encField);
+      }
+      return {
+        body,
+        headers: {
+          "X-E2EE-Version": "2",
+          "X-Client-Pub-Key": clientPubHex,
+          "X-Model-Pub-Key": service.public_key,
+          "X-E2EE-Nonce": nonce,
+          "X-E2EE-Timestamp": String(ts)
+        }
+      };
+    },
+    async open(response) {
+      const decField = responseDecryptor(client2.privateKey, sent, textFrom(response.id));
+      const body = { ...response };
+      if (Array.isArray(response.choices)) {
+        body.choices = await Promise.all(
+          response.choices.map(async (c, pos) => {
+            const i = indexOf(c, pos);
+            const out = { ...c };
+            if (out.message && typeof out.message === "object") {
+              const m = { ...out.message };
+              await openStr(m, "content", `choices.${i}.message.content`, decField);
+              await openStr(m, "reasoning_content", `choices.${i}.message.reasoning_content`, decField);
+              if (m.audio && typeof m.audio === "object") {
+                const a = { ...m.audio };
+                await openStr(a, "data", `choices.${i}.message.audio.data`, decField);
+                m.audio = a;
+              }
+              out.message = m;
+            } else {
+              await openStr(out, "text", `choices.${i}.text`, decField);
+            }
+            return out;
+          })
+        );
+      }
+      if (Array.isArray(response.data)) {
+        body.data = await Promise.all(
+          response.data.map(async (d, pos) => {
+            const i = indexOf(d, pos);
+            const out = { ...d };
+            if (typeof out.embedding === "string") {
+              out.embedding = JSON.parse(await decField(out.embedding, `data.${i}.embedding`));
+            }
+            return out;
+          })
+        );
+      }
+      return body;
+    },
+    async openChunk(chunk) {
+      const decField = responseDecryptor(client2.privateKey, sent, textFrom(chunk.id));
+      const body = { ...chunk };
+      if (Array.isArray(chunk.choices)) {
+        body.choices = await Promise.all(
+          chunk.choices.map(async (c, pos) => {
+            const i = indexOf(c, pos);
+            const out = { ...c };
+            if (out.delta && typeof out.delta === "object") {
+              const d = { ...out.delta };
+              await openStr(d, "content", `choices.${i}.delta.content`, decField);
+              await openStr(d, "reasoning_content", `choices.${i}.delta.reasoning_content`, decField);
+              out.delta = d;
+            } else {
+              await openStr(out, "text", `choices.${i}.text`, decField);
+            }
+            return out;
+          })
+        );
+      }
+      return body;
+    }
+  };
+}
+__name(openE2eeChannel, "openE2eeChannel");
+function responseDecryptor(clientPriv, sent, id) {
+  if (!sent) throw new Error("open: call seal first");
+  const { model, nonce, ts } = sent;
+  return async (blobHex, field) => dec.decode(await openField(clientPriv, blobHex, responseAad({ algo: ALGO, model, id, field, nonce, ts })));
+}
+__name(responseDecryptor, "responseDecryptor");
+function indexOf(entry, position) {
+  return typeof entry.index === "number" ? entry.index : position;
+}
+__name(indexOf, "indexOf");
+function textFrom(v) {
+  return typeof v === "string" ? v : "";
+}
+__name(textFrom, "textFrom");
+async function openStr(obj, key, field, decField) {
+  if (typeof obj[key] === "string") obj[key] = await decField(obj[key], field);
+}
+__name(openStr, "openStr");
+async function sealStringOrArray(value, name, encField) {
+  if (typeof value === "string") return encField(value, name);
+  if (Array.isArray(value)) {
+    return Promise.all(value.map((v, i) => typeof v === "string" ? encField(v, `${name}.${i}`) : v));
+  }
+  return value;
+}
+__name(sealStringOrArray, "sealStringOrArray");
+var bs = /* @__PURE__ */ __name((u) => u, "bs");
+async function aesKey(shared, usage) {
+  const hk = await subtle2.importKey("raw", bs(shared), "HKDF", false, ["deriveKey"]);
+  return subtle2.deriveKey(
+    { name: "HKDF", hash: "SHA-256", salt: bs(new Uint8Array(0)), info: bs(HKDF_INFO) },
+    hk,
+    { name: "AES-GCM", length: 256 },
+    false,
+    [usage]
+  );
+}
+__name(aesKey, "aesKey");
+async function sealField(serviceRaw, plaintext, aad) {
+  const eph = await subtle2.generateKey({ name: "X25519" }, true, ["deriveBits"]);
+  const ephPub = new Uint8Array(await subtle2.exportKey("raw", eph.publicKey));
+  const service = await subtle2.importKey("raw", bs(serviceRaw), { name: "X25519" }, false, []);
+  const shared = new Uint8Array(await subtle2.deriveBits({ name: "X25519", public: service }, eph.privateKey, 256));
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const ct = new Uint8Array(await subtle2.encrypt({ name: "AES-GCM", iv: bs(iv), additionalData: bs(aad) }, await aesKey(shared, "encrypt"), bs(plaintext)));
+  const blob = new Uint8Array(ephPub.length + iv.length + ct.length);
+  blob.set(ephPub);
+  blob.set(iv, ephPub.length);
+  blob.set(ct, ephPub.length + iv.length);
+  return toHex(blob);
+}
+__name(sealField, "sealField");
+async function openField(clientPriv, blobHex, aad) {
+  const blob = fromHex(blobHex);
+  const ephPub = await subtle2.importKey("raw", bs(blob.slice(0, 32)), { name: "X25519" }, false, []);
+  const shared = new Uint8Array(await subtle2.deriveBits({ name: "X25519", public: ephPub }, clientPriv, 256));
+  const pt = await subtle2.decrypt({ name: "AES-GCM", iv: bs(blob.slice(32, 44)), additionalData: bs(aad) }, await aesKey(shared, "decrypt"), bs(blob.slice(44)));
+  return new Uint8Array(pt);
+}
+__name(openField, "openField");
+
+// src/providers/phala/aci-verifier/report.ts?ext=privateer-gate
+async function verifyReportBinding(report, nonce, options = {}) {
+  const now = options.now ?? Math.floor(Date.now() / 1e3);
+  const checks = [];
+  const versionOk = report.api_version === "aci/1";
+  checks.push({
+    name: "api_version",
+    ok: versionOk,
+    ...versionOk ? {} : { detail: `api_version "${report.api_version}" is not "aci/1"` }
+  });
+  const keysetValue = report.attestation.workload_keyset;
+  if (keysetValue === null || typeof keysetValue !== "object" || Array.isArray(keysetValue)) {
+    const detail = "workload_keyset is not a JSON object";
+    for (const name of ["workload_keyset_digest", "report_data", "not_after"]) {
+      checks.push({ name, ok: false, detail });
+    }
+    return { ok: false, checks };
+  }
+  const digest = await computeKeysetDigest(keysetValue);
+  pushEqual(checks, "workload_keyset_digest", report.workload_keyset_digest, digest);
+  const expectedReportData = await computeReportData(digest, nonce);
+  pushEqual(checks, "report_data", report.attestation.report_data, expectedReportData);
+  const keyset = keysetValue;
+  if (typeof keyset.not_after !== "number") {
+    checks.push({
+      name: "not_after",
+      ok: false,
+      detail: "keyset has no numeric not_after"
+    });
+  } else {
+    const ok = now < keyset.not_after;
+    checks.push({
+      name: "not_after",
+      ok,
+      ...ok ? {} : { detail: `now ${now} >= not_after ${keyset.not_after}` }
+    });
+  }
+  return {
+    ok: checks.every((c) => c.ok),
+    checks,
+    workloadKeysetDigest: digest,
+    keyset
+  };
+}
+__name(verifyReportBinding, "verifyReportBinding");
+function pushEqual(checks, name, actual, expected) {
+  const ok = actual === expected;
+  checks.push({ name, ok, ...ok ? {} : { detail: `report ${actual} != recomputed ${expected}` } });
+}
+__name(pushEqual, "pushEqual");
+
+// src/providers/phala/measurements.ts?ext=privateer-gate
+import { createHash } from "node:crypto";
+var RTMR_KEYS = ["rtMr0", "rtMr1", "rtMr2", "rtMr3"];
+function parseEventLog(raw) {
+  let value = raw;
+  if (typeof raw === "string") {
+    try {
+      value = JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+  if (!Array.isArray(value)) return [];
+  return value.filter(
+    (e) => !!e && typeof e === "object" && typeof e.imr === "number" && typeof e.digest === "string"
+  );
+}
+__name(parseEventLog, "parseEventLog");
+function replayRtmrs(events) {
+  const out = {};
+  RTMR_KEYS.forEach((key, imr) => {
+    let acc = Buffer.alloc(48);
+    for (const ev of events) {
+      if (ev.imr !== imr) continue;
+      let digest;
+      try {
+        digest = Buffer.from(ev.digest, "hex");
+      } catch {
+        continue;
+      }
+      acc = createHash("sha384").update(Buffer.concat([acc, digest])).digest();
+    }
+    out[key] = acc.toString("hex");
+  });
+  return out;
+}
+__name(replayRtmrs, "replayRtmrs");
+function appIdentityFrom(events) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const ev of events) {
+    if (ev.imr === 3 && ev.event && typeof ev.event_payload === "string" && ev.event_payload) {
+      byName.set(ev.event, ev.event_payload);
+    }
+  }
+  return {
+    appId: byName.get("app-id"),
+    composeHash: byName.get("compose-hash"),
+    osImageHash: byName.get("os-image-hash"),
+    instanceId: byName.get("instance-id"),
+    mrKms: byName.get("mr-kms"),
+    keyProvider: byName.get("key-provider")
+  };
+}
+__name(appIdentityFrom, "appIdentityFrom");
+function computeComposeHash(appCompose) {
+  if (typeof appCompose !== "string" || !appCompose) return void 0;
+  return createHash("sha256").update(Buffer.from(appCompose, "utf8")).digest("hex");
+}
+__name(computeComposeHash, "computeComposeHash");
+function checkReportConsistency(args) {
+  const checks = [];
+  const skipped = [];
+  if (args.events.length === 0) {
+    skipped.push("rtmr-replay");
+  } else {
+    const replayed = replayRtmrs(args.events);
+    for (const key of RTMR_KEYS) {
+      const ok = replayed[key] === args.quoted[key];
+      checks.push({
+        name: `rtmr-replay:${key}`,
+        ok,
+        detail: ok ? void 0 : `replayed ${replayed[key].slice(0, 16)}\u2026 but the quote signed ${args.quoted[key].slice(0, 16)}\u2026`
+      });
+    }
+  }
+  const computed = computeComposeHash(args.appCompose);
+  if (!computed || !args.identity.composeHash) {
+    skipped.push("compose-hash");
+  } else {
+    const ok = computed === args.identity.composeHash;
+    checks.push({
+      name: "compose-hash",
+      ok,
+      detail: ok ? void 0 : `sha256(app_compose)=${computed.slice(0, 16)}\u2026 but the log attests ${args.identity.composeHash.slice(0, 16)}\u2026`
+    });
+  }
+  return { checks, ok: checks.every((c) => c.ok), skipped };
+}
+__name(checkReportConsistency, "checkReportConsistency");
+
+// src/providers/phala/pin.ts?ext=privateer-gate
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+var PIN_VERSION = 1;
+function pinPath() {
+  return join3(globalDir(), "phala-enclave-pin.json");
+}
+__name(pinPath, "pinPath");
+function readPin() {
+  try {
+    const parsed = JSON.parse(readFileSync2(pinPath(), "utf8"));
+    if (parsed?.v !== PIN_VERSION || !parsed.pin || typeof parsed.pin !== "object") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+__name(readPin, "readPin");
+function writePin(pin, firstSeenAt) {
+  try {
+    mkdirSync2(globalDir(), { recursive: true });
+    writeFileSync2(pinPath(), JSON.stringify({ v: PIN_VERSION, firstSeenAt, pin }, null, 2) + "\n", "utf8");
+  } catch {
+  }
+}
+__name(writePin, "writePin");
+function checkPin(current, now = () => (/* @__PURE__ */ new Date()).toISOString()) {
+  const stored = readPin();
+  if (!stored?.pin) {
+    const firstSeenAt = now();
+    writePin(current, firstSeenAt);
+    return { state: "first-seen", changed: [], firstSeenAt };
+  }
+  const changed = [];
+  for (const key of Object.keys(current)) {
+    const was = stored.pin[key];
+    const is = current[key];
+    if (was && is && was !== is) changed.push(`${key}: ${was.slice(0, 12)}\u2026 \u2192 ${is.slice(0, 12)}\u2026`);
+  }
+  if (changed.length === 0) return { state: "unchanged", changed: [], firstSeenAt: stored.firstSeenAt };
+  writePin(current, stored.firstSeenAt ?? now());
+  return { state: "changed", changed, firstSeenAt: stored.firstSeenAt };
+}
+__name(checkPin, "checkPin");
+
+// src/providers/phalaSeal.ts?ext=privateer-gate
+var DEFAULT_ACCEPTABLE_TCB = ["UpToDate"];
+function relayBase() {
+  return `${serverBaseUrl().replace(/\/+$/, "")}/api/sealed/phala`;
+}
+__name(relayBase, "relayBase");
+function requireQuote() {
+  const v = process.env.PRIVATEER_PHALA_REQUIRE_QUOTE;
+  return !(v === "0" || v === "false");
+}
+__name(requireQuote, "requireQuote");
+function pccsUrl() {
+  return process.env.PRIVATEER_PHALA_PCCS_URL || void 0;
+}
+__name(pccsUrl, "pccsUrl");
+function acceptableTcb() {
+  const v = process.env.PRIVATEER_PHALA_TCB;
+  const list = v ? v.split(",").map((s) => s.trim()).filter(Boolean) : DEFAULT_ACCEPTABLE_TCB;
+  return new Set(list);
+}
+__name(acceptableTcb, "acceptableTcb");
+function extractQuoteMeasurements(report) {
+  const td = report.asTd10?.() ?? report.asTd15?.()?.base;
+  const fields = [td?.mrTd, td?.rtMr0, td?.rtMr1, td?.rtMr2, td?.rtMr3];
+  if (fields.some((f) => !f?.length)) return void 0;
+  const [mrTd, rtMr0, rtMr1, rtMr2, rtMr3] = fields.map((f) => toHex(new Uint8Array(f)));
+  return { mrTd, rtMr0, rtMr1, rtMr2, rtMr3 };
+}
+__name(extractQuoteMeasurements, "extractQuoteMeasurements");
+function extractQuoteReportData(report) {
+  const td10 = report.asTd10?.();
+  if (td10?.reportData) return new Uint8Array(td10.reportData);
+  const td15 = report.asTd15?.();
+  if (td15?.base?.reportData) return new Uint8Array(td15.base.reportData);
+  const data = report.data;
+  if (data?.reportData) return new Uint8Array(data.reportData);
+  throw new Error("phala: verified quote report has no reportData");
+}
+__name(extractQuoteReportData, "extractQuoteReportData");
+var attestationPromise = null;
+function attest() {
+  if (!attestationPromise) {
+    attestationPromise = establishAttestation().catch((err) => {
+      attestationPromise = null;
+      throw err;
+    });
+  }
+  return attestationPromise;
+}
+__name(attest, "attest");
+async function establishAttestation() {
+  const nonce = toHex(globalThis.crypto.getRandomValues(new Uint8Array(32)));
+  const res = await fetch(`${relayBase()}/attestation?nonce=${nonce}`, { method: "GET" });
+  if (!res.ok) throw new Error(`phala attestation HTTP ${res.status}`);
+  const report = await res.json();
+  const verification = await verifyReportBinding(report, nonce);
+  if (!verification.ok) {
+    const failed = verification.checks.filter((c) => !c.ok).map((c) => c.name).join(", ");
+    throw new Error(`phala attestation binding failed: ${failed}`);
+  }
+  const enclave = await verifyHardwareQuote(report);
+  return { report, verification, enclave };
+}
+__name(establishAttestation, "establishAttestation");
+async function verifyHardwareQuote(report) {
+  if (!requireQuote()) return void 0;
+  const attestation = report.attestation;
+  const teeType = String(attestation?.tee_type || "");
+  if (teeType !== "tdx") throw new Error(`phala: unsupported/absent tee_type "${teeType}" (only tdx is wired)`);
+  const quoteHex = attestation.evidence?.quote;
+  if (typeof quoteHex !== "string" || !quoteHex) throw new Error("phala: attestation evidence has no TDX quote");
+  const reportDataHex = String(attestation.report_data || "").toLowerCase();
+  if (!reportDataHex) throw new Error("phala: report has no report_data");
+  const { getCollateralAndVerify } = await import("./c-77GO5L5Y.mjs");
+  const verified = await getCollateralAndVerify(fromHex(quoteHex), pccsUrl());
+  const status = String(verified.status);
+  if (!acceptableTcb().has(status)) throw new Error(`phala: TDX quote TCB status not accepted: "${status}"`);
+  const quoteReportData = extractQuoteReportData(verified.report);
+  if (toHex(quoteReportData.slice(0, 32)) !== reportDataHex) {
+    throw new Error("phala: TDX quote report_data does not bind the attested report_data");
+  }
+  const declared = attestation.evidence?.quote_report_data;
+  if (typeof declared === "string" && declared && toHex(quoteReportData) !== declared.toLowerCase()) {
+    throw new Error("phala: evidence.quote_report_data does not match the verified quote");
+  }
+  const measurements = extractQuoteMeasurements(verified.report);
+  if (!measurements) return void 0;
+  const events = parseEventLog(attestation.evidence?.event_log);
+  const identity = appIdentityFrom(events);
+  const consistency = checkReportConsistency({
+    events,
+    quoted: measurements,
+    appCompose: attestation.evidence?.app_compose,
+    identity
+  });
+  if (!consistency.ok) {
+    const failed = consistency.checks.filter((c) => !c.ok).map((c) => `${c.name} (${c.detail})`).join("; ");
+    throw new Error(`phala: attestation self-consistency failed: ${failed}`);
+  }
+  const pin = checkPin({
+    mrTd: measurements.mrTd,
+    rtMr0: measurements.rtMr0,
+    rtMr1: measurements.rtMr1,
+    rtMr2: measurements.rtMr2,
+    appId: identity.appId,
+    composeHash: identity.composeHash,
+    osImageHash: identity.osImageHash,
+    mrKms: identity.mrKms
+  });
+  const provenance = attestation.source_provenance;
+  const downstream = attestation.evidence?.downstream_tls_binding;
+  return {
+    measurements,
+    identity,
+    pin,
+    skippedChecks: consistency.skipped,
+    // Named so a human can go read the source; self-declared by the enclave and NOT
+    // proven by the quote (image_digest/image_provenance come back null), so it is a
+    // pointer to audit, never evidence that this binary came from that commit.
+    repoUrl: provenance?.repo_url,
+    repoCommit: provenance?.repo_commit,
+    // The attested enclave forwards to this downstream host over TLS. Surfaced because
+    // it marks where our attested boundary ENDS — that host is a separate trust domain
+    // we do not attest.
+    downstreamDomain: downstream?.domain,
+    downstreamSpkiSha256: downstream?.spki_sha256
+  };
+}
+__name(verifyHardwareQuote, "verifyHardwareQuote");
+async function attestPhala() {
+  try {
+    const { enclave } = await attest();
+    return { ok: true, enclaveIdentity: enclave };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+__name(attestPhala, "attestPhala");
+async function phalaSealedFetch(rawBody, authHeader, signal) {
+  const { report, verification } = await attest();
+  const channel = await openE2eeChannel(report, verification);
+  let request;
+  try {
+    request = JSON.parse(rawBody);
+  } catch {
+    throw new Error("phala: request body is not JSON");
+  }
+  const fullModel = typeof request.model === "string" ? request.model : "unknown";
+  const streaming = request.stream !== false;
+  request.model = fullModel.replace(/^phala\//, "");
+  request.stream = streaming;
+  const { body, headers: e2ee } = await channel.seal(request);
+  const headers = {
+    "Content-Type": "application/json",
+    "X-Sealed-Model": fullModel,
+    ...e2ee
+  };
+  if (authHeader) headers.Authorization = authHeader;
+  const res = await fetch(`${relayBase()}/v1/chat/completions`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+    signal
+  });
+  return { res, channel, streaming };
+}
+__name(phalaSealedFetch, "phalaSealedFetch");
+
+// src/providers/phala/sse.ts?ext=privateer-gate
+async function* iterateSSE(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      const lines = buf.split("\n");
+      buf = lines.pop() ?? "";
+      for (const obj of parseDataLines(lines)) yield obj;
+    }
+    if (buf.trim()) for (const obj of parseDataLines([buf])) yield obj;
+  } finally {
+    try {
+      await reader.cancel();
+    } catch {
+    }
+  }
+}
+__name(iterateSSE, "iterateSSE");
+function parseDataLines(lines) {
+  const out = [];
+  for (const line of lines) {
+    if (!line.startsWith("data:")) continue;
+    const t = line.slice(5).trim();
+    if (!t || t === "[DONE]") continue;
+    try {
+      out.push(JSON.parse(t));
+    } catch {
+    }
+  }
+  return out;
+}
+__name(parseDataLines, "parseDataLines");
+
+// src/providers/sealedShim.ts?ext=privateer-gate
+function sealedEnabled() {
+  const v = process.env.PRIVATEER_SEALED;
+  return !(v === "0" || v === "false");
+}
+__name(sealedEnabled, "sealedEnabled");
+function sealedProviderFor(modelId) {
+  if (modelId.startsWith("tinfoil/")) return "tinfoil";
+  if (modelId.startsWith("phala/")) return "phala";
+  return null;
+}
+__name(sealedProviderFor, "sealedProviderFor");
+function relayBase2(provider) {
+  return `${serverBaseUrl().replace(/\/+$/, "")}/api/sealed/${provider}`;
+}
+__name(relayBase2, "relayBase");
+var clients = /* @__PURE__ */ new Map();
+var readyPromises = /* @__PURE__ */ new Map();
+function client(provider) {
+  let c = clients.get(provider);
+  if (!c) {
+    const base = relayBase2(provider);
+    c = new SecureClient({ baseURL: base, attestationBundleURL: base, transport: "ehbp" });
+    clients.set(provider, c);
+  }
+  return c;
+}
+__name(client, "client");
+function ready(provider) {
+  let p = readyPromises.get(provider);
+  if (!p) {
+    p = client(provider).ready().catch((err) => {
+      readyPromises.delete(provider);
+      throw err;
+    });
+    readyPromises.set(provider, p);
+  }
+  return p;
+}
+__name(ready, "ready");
+async function attestSealed(provider) {
+  if (provider === "phala") return attestPhala();
+  try {
+    await ready(provider);
+    return { ok: true, enclave: client(provider).getEnclaveURL() };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+__name(attestSealed, "attestSealed");
+function buildForward(provider, rawBody, authHeader) {
+  let body = rawBody;
+  let sealedModel = "unknown";
+  try {
+    const parsed = JSON.parse(rawBody);
+    if (parsed && typeof parsed.model === "string") {
+      sealedModel = parsed.model;
+      const prefix = `${provider}/`;
+      if (parsed.model.startsWith(prefix)) parsed.model = parsed.model.slice(prefix.length);
+      body = JSON.stringify(parsed);
+    }
+  } catch {
+  }
+  const headers = {
+    // MUST carry the charset. EHBP seals the body but headers travel in cleartext
+    // (tinfoil/dist/encrypted-body-fetch.js: "EHBP only seals the body"), so this
+    // Content-Type is what the enclave's router actually validates — and it rejects a
+    // bare `application/json` with "Unsupported Media Type: Only 'application/json' is
+    // allowed" (verified live 2026-07-31: bare → 400, any `charset=` variant → 200).
+    "Content-Type": "application/json; charset=utf-8",
+    "X-Sealed-Model": sealedModel
+  };
+  if (authHeader) headers.Authorization = authHeader;
+  return { url: `${relayBase2(provider)}/v1/chat/completions`, headers, body, sealedModel };
+}
+__name(buildForward, "buildForward");
+var PATH_RE = /^\/(tinfoil|phala)\/v1\/chat\/completions$/;
+var LOOPBACK = /* @__PURE__ */ new Set(["127.0.0.1", "::1", "::ffff:127.0.0.1"]);
+var shimBase = null;
+var shimStarting = null;
+var shimServer = null;
+function sealedShimBase() {
+  return shimBase;
+}
+__name(sealedShimBase, "sealedShimBase");
+function ensureSealedShim() {
+  if (shimBase) return Promise.resolve(shimBase);
+  if (!shimStarting) shimStarting = startShim();
+  return shimStarting;
+}
+__name(ensureSealedShim, "ensureSealedShim");
+function stopSealedShim() {
+  const server = shimServer;
+  shimServer = null;
+  shimBase = null;
+  shimStarting = null;
+  if (!server) return Promise.resolve();
+  return new Promise((resolve) => server.close(() => resolve()));
+}
+__name(stopSealedShim, "stopSealedShim");
+function startShim() {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      void handle(req, res).catch((e) => {
+        if (!res.headersSent) res.writeHead(502, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: { message: `sealed shim: ${e.message}` } }));
+      });
+    });
+    server.on("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (addr && typeof addr === "object") {
+        shimServer = server;
+        shimBase = `http://127.0.0.1:${addr.port}`;
+        resolve(shimBase);
+      } else {
+        reject(new Error("sealed shim: could not determine listen port"));
+      }
+    });
+    server.unref();
+  });
+}
+__name(startShim, "startShim");
+async function handle(req, res) {
+  if (!LOOPBACK.has(req.socket.remoteAddress ?? "")) {
+    res.writeHead(403).end();
+    return;
+  }
+  const path = (req.url ?? "").split("?")[0];
+  const m = PATH_RE.exec(path);
+  if (req.method !== "POST" || !m) {
+    res.writeHead(404).end();
+    return;
+  }
+  const provider = m[1];
+  const raw = await readBody(req);
+  const authHeader = typeof req.headers["authorization"] === "string" ? req.headers["authorization"] : void 0;
+  if (provider === "phala") {
+    await handlePhala(raw.toString("utf8"), authHeader, res);
+    return;
+  }
+  const plan = buildForward(provider, raw.toString("utf8"), authHeader);
+  await ready(provider);
+  const upstream = await client(provider).fetch(plan.url, {
+    method: "POST",
+    headers: plan.headers,
+    body: plan.body
+  });
+  res.writeHead(upstream.status, {
+    "Content-Type": upstream.headers.get("content-type") ?? "application/json"
+  });
+  if (upstream.body) {
+    const nodeStream = Readable.fromWeb(upstream.body);
+    res.on("close", () => nodeStream.destroy());
+    nodeStream.pipe(res);
+    nodeStream.on("error", () => {
+      if (!res.writableEnded) res.end();
+    });
+  } else {
+    res.end(await upstream.text());
+  }
+}
+__name(handle, "handle");
+async function handlePhala(rawBody, authHeader, res) {
+  const ac = new AbortController();
+  res.on("close", () => ac.abort());
+  const { res: up, channel, streaming } = await phalaSealedFetch(rawBody, authHeader, ac.signal);
+  if (!up.ok) {
+    res.writeHead(up.status, { "Content-Type": up.headers.get("content-type") ?? "application/json" });
+    res.end(await up.text());
+    return;
+  }
+  if (streaming && up.body) {
+    res.writeHead(up.status, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache, no-transform" });
+    for await (const obj of iterateSSE(up.body)) {
+      const opened2 = await channel.openChunk(obj);
+      res.write(`data: ${JSON.stringify(opened2)}
+
+`);
+    }
+    res.write("data: [DONE]\n\n");
+    res.end();
+    return;
+  }
+  const opened = await channel.open(await up.json());
+  res.writeHead(up.status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(opened));
+}
+__name(handlePhala, "handlePhala");
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+__name(readBody, "readBody");
+
+// src/providers/account.ts?ext=privateer-gate
+var DEFAULT_MODELS = [
+  ACCOUNT_DEFAULT_MODEL_ID,
+  ACCOUNT_NEAR_MODEL_ID,
+  // All three former defaults (see TINFOIL_MODEL_ID for the dates). They stay in the
+  // floor so a user who saved any of them as their own default still resolves it
+  // synchronously at launch, rather than falling through to "first model with
+  // configured auth" — the BYO dead end this seed list exists to prevent.
+  "tinfoil/gpt-oss-120b",
+  "tinfoil/kimi-k2-6",
+  "tinfoil/glm-5-2",
+  "anthropic/claude-opus-5",
+  "anthropic/claude-sonnet-5",
+  "openai/gpt-5.6-sol",
+  "deepseek/deepseek-v4-flash",
+  // 2026-08 releases, confirmed live on OpenRouter (ZDR-covered ids reach the
+  // account catalog automatically; these seeds just make them resolve at launch).
+  "moonshotai/kimi-k3",
+  "z-ai/glm-5.2",
+  // Both verified 2026-08-19 against /endpoints/zdr and GET /api/models: ZDR-covered
+  // and servable. Same reason as the line above — the live catalog already carries
+  // them, this only closes the first-launch window where a saved default that isn't
+  // yet in the cache would fall through to a BYO provider.
+  "x-ai/grok-4.6",
+  "openai/gpt-5.6-luna"
+];
+var DEFAULT_CONTEXT_WINDOW = 128e3;
+var MIN_PUBLISHED_CONTEXT_WINDOW = 8192;
+var MAX_PUBLISHED_CONTEXT_WINDOW = 1e7;
+function validContextWindow(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= MIN_PUBLISHED_CONTEXT_WINDOW && value <= MAX_PUBLISHED_CONTEXT_WINDOW ? Math.floor(value) : void 0;
+}
+__name(validContextWindow, "validContextWindow");
+var DEFAULT_MAX_OUTPUT_TOKENS = 16384;
+var ACCOUNT_MAX_OUTPUT_TOKENS = 32e3;
+var MIN_PUBLISHED_MAX_OUTPUT = 1024;
+function validMaxOutputTokens(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= MIN_PUBLISHED_MAX_OUTPUT ? Math.min(Math.floor(value), ACCOUNT_MAX_OUTPUT_TOKENS) : void 0;
+}
+__name(validMaxOutputTokens, "validMaxOutputTokens");
+function seedModel(id) {
+  return {
+    id,
+    name: id,
+    // reasoning + how to steer it, for the enclave models where we verified the
+    // control shape live; `reasoning: false` (Pi's "not a thinking model") for the rest.
+    ...thinkingProfile(id) ?? { reasoning: false },
+    // Honest modalities. This was hardcoded to text for the whole catalog, which made
+    // Pi strip every image from every account request — including the ones `read`
+    // attaches when the user points at a screenshot. See providers/vision.ts.
+    input: visionInput(id),
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    // The model's real window when the server published one, else the fallback.
+    // This is not cosmetic: pi sizes each turn's answer budget as
+    // (contextWindow − estimated prompt − 4096) and clamps max_tokens to it
+    // (pi-ai clampMaxTokensToContext, and see src/engine/contextBudget.ts). A window
+    // that under-states the model's real one therefore throttles the answer — and
+    // used to collapse it to a single token — while the model still has room.
+    contextWindow: accountContextWindow(id) ?? DEFAULT_CONTEXT_WINDOW,
+    // The model's real output cap when published. Not cosmetic either: reasoning and
+    // the answer share this one budget, and pi only compact-and-retries a length stop
+    // that ended BELOW it — a thinking model that spends all of a too-small budget
+    // reasoning ends the run with "Response was truncated before completion."
+    // (measured: glm-5.3-flash spending all 16384 on 50k+ chars of reasoning, whose
+    // real cap is far higher). See also ext/truncationRecovery.ts.
+    maxTokens: accountMaxOutputTokens(id) ?? DEFAULT_MAX_OUTPUT_TOKENS
+  };
+}
+__name(seedModel, "seedModel");
+var CHAT_TEMPLATE_THINKING = {
+  reasoning: true,
+  thinkingLevelMap: { minimal: null, low: null, high: null, xhigh: null },
+  compat: { thinkingFormat: "qwen-chat-template" }
+};
+var REASONING_EFFORT_THINKING = {
+  reasoning: true,
+  thinkingLevelMap: { off: "low", minimal: "low", xhigh: null }
+};
+var OPENROUTER_THINKING = {
+  reasoning: true,
+  thinkingLevelMap: { off: "low", minimal: "low" },
+  compat: { thinkingFormat: "openrouter" }
+};
+var PROXIED_THINKING_MODEL = [
+  /^google\/gemini-/i,
+  //           gemini-2.5+ all take an effort; gemma-* deliberately excluded
+  /^z-ai\/glm-/i,
+  //                the whole GLM line reasons, vision variants included
+  /^deepseek\/deepseek-(r1|v3\.[12]|v4)/i,
+  // NOT deepseek-chat*, which is the non-thinking split
+  /^x-ai\/grok-4/i,
+  //              grok-4.x; grok-build-0.1 is unprobed
+  /^openai\/gpt-(5|6|oss)/i
+  //     gpt-4*/gpt-3.5* do not reason
+];
+var NON_THINKING_VARIANT = /(?:^|[-/])(?:chat|instruct)(?:[-.]|$)/i;
+var TEE_MODEL = /^(tinfoil|phala|near)\//;
+function teeThinkingProfile(id) {
+  if (/instruct/i.test(id)) return null;
+  if (/gpt-oss/i.test(id)) return REASONING_EFFORT_THINKING;
+  if (/glm|qwen/i.test(id)) return CHAT_TEMPLATE_THINKING;
+  return null;
+}
+__name(teeThinkingProfile, "teeThinkingProfile");
+function proxiedThinkingProfile(id) {
+  if (NON_THINKING_VARIANT.test(id)) return null;
+  return PROXIED_THINKING_MODEL.some((re) => re.test(id)) ? OPENROUTER_THINKING : null;
+}
+__name(proxiedThinkingProfile, "proxiedThinkingProfile");
+function thinkingProfile(id) {
+  const profile = TEE_MODEL.test(id) ? teeThinkingProfile(id) : proxiedThinkingProfile(id);
+  return profile && { ...profile, thinkingLevelMap: { ...profile.thinkingLevelMap }, ...profile.compat ? { compat: { ...profile.compat } } : {} };
+}
+__name(thinkingProfile, "thinkingProfile");
+var CATALOG_CACHE_MAX = 2e3;
+function catalogCachePath() {
+  return join4(globalDir(), "account-models.json");
+}
+__name(catalogCachePath, "catalogCachePath");
+function saveCachedCatalog(infos) {
+  try {
+    mkdirSync3(globalDir(), { recursive: true });
+    const kept = infos.slice(0, CATALOG_CACHE_MAX);
+    const windows = {};
+    const maxOutputs = {};
+    for (const info of kept) {
+      if (info.contextWindow !== void 0) windows[info.id] = info.contextWindow;
+      if (info.maxOutputTokens !== void 0) maxOutputs[info.id] = info.maxOutputTokens;
+    }
+    const payload = {
+      v: 2,
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ids: kept.map((info) => info.id),
+      windows,
+      // Same reasoning as `windows`: a capability needed at launch. Absent in older
+      // files, which then fall back per model.
+      maxOutputs
+    };
+    writeFileSync3(catalogCachePath(), JSON.stringify(payload) + "\n", "utf8");
+    forgetCachedContextWindows();
+  } catch {
+  }
+}
+__name(saveCachedCatalog, "saveCachedCatalog");
+var cachedCapabilities = null;
+function cachedCapabilityMaps() {
+  if (cachedCapabilities) return cachedCapabilities;
+  cachedCapabilities = { windows: /* @__PURE__ */ new Map(), maxOutputs: /* @__PURE__ */ new Map() };
+  try {
+    const path = catalogCachePath();
+    if (existsSync2(path)) {
+      const parsed = JSON.parse(readFileSync3(path, "utf8"));
+      readCapability(parsed.windows, validContextWindow, cachedCapabilities.windows);
+      readCapability(parsed.maxOutputs, validMaxOutputTokens, cachedCapabilities.maxOutputs);
+    }
+  } catch {
+  }
+  return cachedCapabilities;
+}
+__name(cachedCapabilityMaps, "cachedCapabilityMaps");
+function readCapability(raw, valid, into) {
+  if (!raw || typeof raw !== "object") return;
+  for (const [id, value] of Object.entries(raw)) {
+    const n = valid(value);
+    if (n !== void 0 && into.size < CATALOG_CACHE_MAX) into.set(id, n);
+  }
+}
+__name(readCapability, "readCapability");
+function cachedContextWindows() {
+  return cachedCapabilityMaps().windows;
+}
+__name(cachedContextWindows, "cachedContextWindows");
+function forgetCachedContextWindows() {
+  cachedCapabilities = null;
+}
+__name(forgetCachedContextWindows, "forgetCachedContextWindows");
+function loadCachedCatalogIds() {
+  try {
+    const path = catalogCachePath();
+    if (!existsSync2(path)) return [];
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    if (!Array.isArray(parsed.ids)) return [];
+    return parsed.ids.filter((id) => typeof id === "string" && id.length > 0).slice(0, CATALOG_CACHE_MAX);
+  } catch {
+    return [];
+  }
+}
+__name(loadCachedCatalogIds, "loadCachedCatalogIds");
+function isServableAccountModel(id) {
+  if (!id.startsWith("phala/")) return true;
+  return sealedEnabled() && sealedShimBase() !== null;
+}
+__name(isServableAccountModel, "isServableAccountModel");
+function seedCatalogIds() {
+  const ids = [...DEFAULT_MODELS];
+  const seen = new Set(ids);
+  for (const id of loadCachedCatalogIds()) {
+    if (!seen.has(id)) {
+      seen.add(id);
+      ids.push(id);
+    }
+  }
+  return ids;
+}
+__name(seedCatalogIds, "seedCatalogIds");
+var VALID_TIERS = /* @__PURE__ */ new Set([
+  "tee-verified",
+  "tee-unverified",
+  "local",
+  "zdr-enforced",
+  "zdr-policy",
+  "standard"
+]);
+function tierFromPrefix(modelId) {
+  return modelId.startsWith("near/") || modelId.startsWith("tinfoil/") || modelId.startsWith("phala/") ? "tee-unverified" : "standard";
+}
+__name(tierFromPrefix, "tierFromPrefix");
+function normalizeTier(tier, modelId) {
+  return tier && VALID_TIERS.has(tier) ? tier : tierFromPrefix(modelId);
+}
+__name(normalizeTier, "normalizeTier");
+var accountTierMap = /* @__PURE__ */ new Map();
+var accountWindowMap = /* @__PURE__ */ new Map();
+function accountContextWindow(id) {
+  return accountWindowMap.get(id) ?? cachedContextWindows().get(id);
+}
+__name(accountContextWindow, "accountContextWindow");
+var accountMaxOutputMap = /* @__PURE__ */ new Map();
+function accountMaxOutputTokens(id) {
+  return accountMaxOutputMap.get(id) ?? cachedCapabilityMaps().maxOutputs.get(id);
+}
+__name(accountMaxOutputTokens, "accountMaxOutputTokens");
+function accountBaselineTier(modelId) {
+  return accountTierMap.get(modelId);
+}
+__name(accountBaselineTier, "accountBaselineTier");
+function accountCatalogLoaded() {
+  return accountTierMap.size > 0;
+}
+__name(accountCatalogLoaded, "accountCatalogLoaded");
+async function fetchAccountCatalog() {
+  const fallback = /* @__PURE__ */ __name(() => DEFAULT_MODELS.map((id) => ({ id, tier: tierFromPrefix(id) })), "fallback");
+  let infos;
+  try {
+    const res = await fetch(`${serverBaseUrl()}/api/models`);
+    if (!res.ok) {
+      infos = fallback();
+    } else {
+      const data = await res.json();
+      const parsed = (data.models ?? []).map(
+        (m) => m.modelId ? {
+          id: m.modelId,
+          tier: normalizeTier(m.privacy?.tier, m.modelId),
+          // `contextLength` is null for a model upstream has no window for, and
+          // absent entirely on a server older than the field — both mean
+          // "unknown", and validContextWindow collapses them to undefined.
+          contextWindow: validContextWindow(m.contextLength),
+          maxOutputTokens: validMaxOutputTokens(m.maxCompletionTokens)
+        } : null
+      ).filter((x) => !!x);
+      if (parsed.length) saveCachedCatalog(parsed);
+      infos = parsed.length ? parsed : fallback();
+    }
+  } catch {
+    infos = fallback();
+  }
+  accountTierMap.clear();
+  accountWindowMap.clear();
+  accountMaxOutputMap.clear();
+  for (const info of infos) {
+    accountTierMap.set(info.id, info.tier);
+    if (info.contextWindow !== void 0) accountWindowMap.set(info.id, info.contextWindow);
+    if (info.maxOutputTokens !== void 0) accountMaxOutputMap.set(info.id, info.maxOutputTokens);
+  }
+  return infos;
+}
+__name(fetchAccountCatalog, "fetchAccountCatalog");
+async function fetchAccountModels() {
+  return (await fetchAccountCatalog()).map((m) => m.id);
+}
+__name(fetchAccountModels, "fetchAccountModels");
+function verificationLink(raw) {
+  const uri = (raw ?? "").trim();
+  if (!uri) return "";
+  if (/^https?:\/\//i.test(uri)) return uri;
+  return `https://${uri.replace(/^\/+/, "")}`;
+}
+__name(verificationLink, "verificationLink");
+var privateerOAuthProvider = {
+  name: "Privateer account",
+  usesCallbackServer: false,
+  // Pi's login dialog passes `signal` (its cancel AbortController) alongside the
+  // callbacks. We MUST thread it into runDeviceLogin — otherwise escape/ctrl+c
+  // aborts the dialog's signal but our poll loop never sees it, the login()
+  // promise never settles, and Pi never restores the editor: the "Waiting for
+  // authentication…" screen hangs with no way out. See auth/privateer.ts
+  // pollForToken, which checks the signal and rejects with "Login cancelled.".
+  async login(cb) {
+    let wasLinked = hasCredentials();
+    if (wasLinked && cb.onSelect) {
+      const user = currentUser();
+      const who = user?.email ?? user?.id ?? "this account";
+      const choice = await cb.onSelect({
+        message: `Already signed in as ${who}.`,
+        options: [
+          { id: "keep", label: `Stay signed in as ${who}` },
+          { id: "switch", label: "Sign in as a different account (signs this machine out first)" }
+        ]
+      });
+      if (choice === void 0) throw new Error("Login cancelled");
+      if (choice === "switch") {
+        await logout();
+        wasLinked = false;
+      }
+    }
+    if (!wasLinked) {
+      try {
+        await runDeviceLogin({
+          signal: cb.signal,
+          onCode: /* @__PURE__ */ __name((code) => {
+            const uri = verificationLink(code.verification_uri_complete ?? code.verification_uri);
+            if (uri && canOpenBrowser()) void openInBrowser(uri);
+            cb.onDeviceCode?.({
+              userCode: code.user_code,
+              verificationUri: uri,
+              intervalSeconds: code.interval,
+              expiresInSeconds: code.expires_in
+            });
+          }, "onCode")
+        });
+      } catch (e) {
+        if (cb.signal?.aborted) throw new Error("Login cancelled");
+        throw e;
+      }
+    }
+    if (cb.signal?.aborted) throw new Error("Login cancelled");
+    const creds = await accountCredential();
+    ensurePiDefaultModel();
+    notifySignedIn();
+    return creds;
+  },
+  async refreshToken(creds) {
+    const mine = armSlot().cred?.refresh;
+    const refresh = mine && creds.refresh !== mine ? mine : creds.refresh;
+    let next;
+    try {
+      next = await refreshAccountCredentials(refresh);
+    } catch {
+      next = await acquireAccountCredential();
+    }
+    rememberAccountCredential(next);
+    return next;
+  },
+  getApiKey(creds) {
+    return creds.access;
+  }
+};
+var TEE_PREFIXES = ["near/", "tinfoil/", "phala/"];
+function privateerChannel(modelId) {
+  return TEE_PREFIXES.some((p) => modelId.startsWith(p)) ? "tee" : "zdr";
+}
+__name(privateerChannel, "privateerChannel");
+async function accountPosture(modelId) {
+  if (privateerChannel(modelId) === "zdr") {
+    return { tier: "zdr-policy" };
+  }
+  const sealedProvider = sealedEnabled() ? sealedProviderFor(modelId) : null;
+  if (sealedProvider) {
+    const att = await attestSealed(sealedProvider);
+    return att.ok ? { tier: "tee-verified", enclaveIdentity: att.enclaveIdentity } : { tier: "tee-unverified", error: att.error };
+  }
+  if (!modelId.startsWith("near/")) {
+    return { tier: "tee-unverified" };
+  }
+  try {
+    const res = await authedFetch(
+      `${serverBaseUrl()}/api/models/near/attestation?model=${encodeURIComponent(modelId)}`
+    );
+    if (!res.ok) return { tier: "tee-unverified", error: `HTTP ${res.status}` };
+    const data = await res.json();
+    const att = interpretReport(modelId, data.nonce ?? "", data.report ?? {});
+    const tp = teePosture(att);
+    const tier = tierFromTeePosture(tp);
+    return { tier, teePosture: tp };
+  } catch (e) {
+    return { tier: "tee-unverified", error: e.message };
+  }
+}
+__name(accountPosture, "accountPosture");
+function modelEntry(id) {
+  const base = seedModel(id);
+  const provider = sealedEnabled() ? sealedProviderFor(id) : null;
+  const shim = sealedShimBase();
+  return provider && shim ? { ...base, baseUrl: `${shim}/${provider}/v1` } : base;
+}
+__name(modelEntry, "modelEntry");
+function accountProviderConfig(ids) {
+  return {
+    name: "Privateer account",
+    baseUrl: `${serverBaseUrl()}/api/agent/v1`,
+    api: "openai-completions",
+    oauth: privateerOAuthProvider,
+    // Filter HERE rather than at the catalog, so callers keep passing the server's
+    // full list and every registration re-evaluates servability against the CURRENT
+    // shim state. That is what lets the post-shim re-registration in makeAccountProvider
+    // put `phala/*` back: had the ids been filtered upstream, the sealed-only models
+    // would have been dropped from `lastIds` before the shim ever finished starting and
+    // nothing would have brought them back.
+    models: ids.filter(isServableAccountModel).map(modelEntry)
+  };
+}
+__name(accountProviderConfig, "accountProviderConfig");
+function registerAccountModels(pi) {
+  pi.registerProvider?.("privateer", accountProviderConfig(seedCatalogIds()));
+}
+__name(registerAccountModels, "registerAccountModels");
+function makeAccountProvider(opts = {}) {
+  return (pi) => {
+    if (typeof pi.registerProvider !== "function") return;
+    installGzipRequestBodies();
+    let lastIds = seedCatalogIds();
+    const register = /* @__PURE__ */ __name((ids) => {
+      lastIds = ids;
+      pi.registerProvider("privateer", accountProviderConfig(ids));
+    }, "register");
+    register(lastIds);
+    if (sealedEnabled()) {
+      void ensureSealedShim().then(() => register(lastIds)).catch(() => {
+      });
+    }
+    void fetchAccountCatalog().then((infos) => infos.length && register(infos.map((m) => m.id))).catch(() => {
+    });
+    if (opts.armOnStart !== false) {
+      pi.on?.("session_start", async (_e, ctx) => {
+        const arming = armAccountCredential(ctx);
+        if (!ctx?.hasUI) await arming;
+      });
+    }
+    pi.on?.("before_agent_start", async (_e, ctx) => {
+      try {
+        await ensureAccountArmed(ctx);
+      } catch {
+      }
+    });
+    pi.on?.("message_end", (e, ctx) => {
+      const msg = e?.message;
+      if (msg?.role !== "assistant" || msg.stopReason !== "error" || !msg.errorMessage) return;
+      if (msg.provider !== "privateer") return;
+      const balance = hasCredentials() ? describeAccountBalanceError(msg.errorMessage) : null;
+      if (balance) {
+        return { message: { ...msg, errorMessage: `402 ${balance.message}
+${balance.hint}` } };
+      }
+      void recoverAccountSession(ctx, msg.errorMessage);
+      if (isConnectionFailureText(msg.errorMessage)) {
+        void recoverAccountConnection(ctx, msg.model ?? "", () => register(lastIds));
+      }
+    });
+  };
+}
+__name(makeAccountProvider, "makeAccountProvider");
+var ARMED = /* @__PURE__ */ Symbol.for("privateer.accountCredential");
+function armSlot() {
+  const g = globalThis;
+  return g[ARMED] ??= {};
+}
+__name(armSlot, "armSlot");
+function rememberAccountCredential(cred) {
+  armSlot().cred = cred;
+}
+__name(rememberAccountCredential, "rememberAccountCredential");
+function ownedAccountCredential() {
+  return armSlot().cred;
+}
+__name(ownedAccountCredential, "ownedAccountCredential");
+function liveAccountCredential() {
+  const cred = armSlot().cred;
+  return cred && cred.expires > Date.now() + 6e4 ? cred : void 0;
+}
+__name(liveAccountCredential, "liveAccountCredential");
+async function accountCredential() {
+  const live = liveAccountCredential();
+  if (live) return live;
+  const slot = armSlot();
+  slot.inFlight ??= acquireAccountCredential().then((cred) => {
+    slot.cred = cred;
+    return cred;
+  }).finally(() => {
+    slot.inFlight = void 0;
+  });
+  return slot.inFlight;
+}
+__name(accountCredential, "accountCredential");
+async function armAccountCredential(ctx, opts = {}) {
+  if (!hasCredentials()) return false;
+  try {
+    const cred = await accountCredential();
+    await (await piAuthStore()).modify("privateer", async () => ({ type: "oauth", ...cred }));
+    return true;
+  } catch (e) {
+    const c = ctx;
+    if (opts.notify !== false && hasCredentials()) {
+      const message = `Privateer account channel unavailable \u2014 ${e.message}`;
+      if (c?.hasUI) c.ui?.notify?.(message, "error");
+      else console.error(message);
+    }
+    return false;
+  }
+}
+__name(armAccountCredential, "armAccountCredential");
+async function persistAccountCredential(creds) {
+  await (await piAuthStore()).modify("privateer", async () => ({ type: "oauth", ...creds }));
+}
+__name(persistAccountCredential, "persistAccountCredential");
+async function dropPersistedAccountCredential(opts = {}) {
+  const store = await piAuthStore();
+  const mine = ownedAccountCredential()?.access;
+  armSlot().cred = void 0;
+  try {
+    if (!opts.force) {
+      const persisted = await store.read("privateer");
+      if (!persisted) return false;
+      if (typeof persisted.access === "string" && persisted.access !== mine) return false;
+    }
+    await store.delete("privateer");
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(dropPersistedAccountCredential, "dropPersistedAccountCredential");
+async function dropPersistedAccountCredentialBeforeExit(timeoutMs = 2e3) {
+  let timer;
+  await Promise.race([
+    dropPersistedAccountCredential().catch(() => false),
+    new Promise((resolve) => {
+      timer = setTimeout(resolve, timeoutMs);
+    })
+  ]);
+  clearTimeout(timer);
+}
+__name(dropPersistedAccountCredentialBeforeExit, "dropPersistedAccountCredentialBeforeExit");
+async function ensureAccountArmed(ctx) {
+  if (!hasCredentials()) return;
+  try {
+    if (await (await piAuthStore()).read("privateer")) return;
+  } catch {
+    return;
+  }
+  await armAccountCredential(ctx, { notify: false });
+}
+__name(ensureAccountArmed, "ensureAccountArmed");
+var ACCOUNT_AUTH_FAILURE = /\b401\b|SESSION_REVOKED|Authentication required|Invalid token|Failed to refresh OAuth token|No API key\b[^\n]*privateer/i;
+var RECOVERY_COOLDOWN_MS = 3e4;
+async function probeAccountToken(access) {
+  try {
+    const res = await fetch(`${serverBaseUrl()}/auth/me`, {
+      headers: { Authorization: `Bearer ${access}` },
+      signal: AbortSignal.timeout(8e3)
+    });
+    void res.body?.cancel().catch(() => {
+    });
+    return res.status;
+  } catch {
+    return null;
+  }
+}
+__name(probeAccountToken, "probeAccountToken");
+async function recoverAccountConnection(ctx, modelId, reRegister, probe = probeAccountToken) {
+  const renewed = { shim: false, session: false };
+  if (!hasCredentials()) return renewed;
+  const slot = armSlot();
+  const now = Date.now();
+  if (slot.connectionRecoveredAt !== void 0 && now - slot.connectionRecoveredAt < RECOVERY_COOLDOWN_MS) return renewed;
+  slot.connectionRecoveredAt = now;
+  if (sealedEnabled() && sealedProviderFor(modelId)) {
+    try {
+      await stopSealedShim();
+      await ensureSealedShim();
+      reRegister();
+      renewed.shim = true;
+    } catch {
+      try {
+        reRegister();
+      } catch {
+      }
+    }
+  }
+  const held = slot.cred;
+  const status = held ? await probe(held.access) : null;
+  if (status === 401 || status === 403) {
+    slot.cred = void 0;
+    renewed.session = await armAccountCredential(ctx, { notify: false });
+  }
+  const c = ctx;
+  if (c?.hasUI && (renewed.shim || renewed.session)) {
+    c.ui?.notify?.(
+      `Couldn't reach Privateer \u2014 renewed this session's ${[renewed.shim ? "sealed connection" : "", renewed.session ? "credential" : ""].filter(Boolean).join(" and ")}. Send that message again.`,
+      "warning"
+    );
+  }
+  return renewed;
+}
+__name(recoverAccountConnection, "recoverAccountConnection");
+async function recoverAccountSession(ctx, errorMessage) {
+  if (!hasCredentials()) return false;
+  if (!ACCOUNT_AUTH_FAILURE.test(errorMessage)) return false;
+  const slot = armSlot();
+  const now = Date.now();
+  if (slot.recoveredAt !== void 0 && now - slot.recoveredAt < RECOVERY_COOLDOWN_MS) return false;
+  slot.recoveredAt = now;
+  slot.cred = void 0;
+  const armed = await armAccountCredential(ctx, { notify: false });
+  const c = ctx;
+  if (c?.hasUI) {
+    c.ui?.notify?.(
+      armed ? "Your Privateer account session had expired \u2014 opened a new one. Send that message again." : "Your Privateer account session isn't valid any more and couldn't be renewed. Run /login to sign back in.",
+      armed ? "warning" : "error"
+    );
+  }
+  return armed;
+}
+__name(recoverAccountSession, "recoverAccountSession");
+
+export {
+  thinkingProfile,
+  loadCachedCatalogIds,
+  isServableAccountModel,
+  seedCatalogIds,
+  accountContextWindow,
+  accountMaxOutputTokens,
+  accountBaselineTier,
+  accountCatalogLoaded,
+  fetchAccountCatalog,
+  fetchAccountModels,
+  verificationLink,
+  privateerOAuthProvider,
+  privateerChannel,
+  accountPosture,
+  accountProviderConfig,
+  registerAccountModels,
+  makeAccountProvider,
+  rememberAccountCredential,
+  ownedAccountCredential,
+  armAccountCredential,
+  persistAccountCredential,
+  dropPersistedAccountCredential,
+  dropPersistedAccountCredentialBeforeExit,
+  ensureAccountArmed,
+  recoverAccountConnection,
+  recoverAccountSession
+};