@my-life-buddies/cli-windowscompat 0.0.0-stage → 0.29.0-dev.0

package/dist/bin/preview.js

@@ -0,0 +1,2924 @@
+// apps/preview/src/controller.ts
+import { readBuddyConfig } from "./core.js";
+
+// apps/preview/src/device-preview.ts
+function createBuddyPreviewUrl(buddyId) {
+  if (!/^[a-zA-Z0-9._-]{1,124}-dev$/u.test(buddyId)) {
+    throw new TypeError("\u771F\u673A\u9884\u89C8\u9700\u8981\u4E0D\u8D85\u8FC7 128 \u5B57\u7B26\u7684\u5F00\u53D1\u7248 Buddy ID");
+  }
+  return `mlb://preview?${new URLSearchParams({ buddyId })}`;
+}
+
+// apps/preview/src/runtime-diagnostics.ts
+function parseInspectedData(text2) {
+  let at = 0;
+  const space = () => {
+    while (/\s/u.test(text2[at] ?? "") && at < text2.length) at++;
+  };
+  const fail = () => {
+    throw new Error("Unsupported log data");
+  };
+  function string() {
+    const quote = text2[at++];
+    let result = "";
+    while (at < text2.length) {
+      const char = text2[at++];
+      if (char === quote) return result;
+      if (char !== "\\") {
+        result += char;
+        continue;
+      }
+      const escaped = text2[at++];
+      const escapes = { n: "\n", r: "\r", t: "	", b: "\b", f: "\f", v: "\v", "0": "\0", "\\": "\\", "'": "'", '"': '"', "`": "`", "$": "$" };
+      if (escaped === "x" || escaped === "u") {
+        const length = escaped === "x" ? 2 : 4;
+        const hex = text2.slice(at, at + length);
+        if (!new RegExp(`^[0-9a-fA-F]{${length}}$`, "u").test(hex)) fail();
+        result += String.fromCharCode(parseInt(hex, 16));
+        at += length;
+      } else if (escaped !== void 0 && Object.hasOwn(escapes, escaped)) result += escapes[escaped];
+      else fail();
+    }
+    return fail();
+  }
+  function value(depth = 0) {
+    if (depth > 40) fail();
+    space();
+    const char = text2[at];
+    if (char === "'" || char === '"' || char === "`") {
+      let result = string();
+      space();
+      while (text2[at] === "+") {
+        at++;
+        space();
+        if (!["'", '"', "`"].includes(text2[at] ?? "")) fail();
+        result += string();
+        space();
+      }
+      return result;
+    }
+    if (char === "{" || char === "[") {
+      const array = char === "[";
+      const end = array ? "]" : "}";
+      const result = /* @__PURE__ */ Object.create(null);
+      const items = [];
+      at++;
+      space();
+      while (text2[at] !== end) {
+        if (at >= text2.length) fail();
+        if (array) items.push(value(depth + 1));
+        else {
+          const quoted = ["'", '"', "`"].includes(text2[at] ?? "");
+          const key = quoted ? string() : /^[\w$]+/u.exec(text2.slice(at))?.[0];
+          if (key === void 0) return fail();
+          if (!quoted) at += key.length;
+          space();
+          if (text2[at++] !== ":" || Object.hasOwn(result, key)) fail();
+          result[key] = value(depth + 1);
+        }
+        space();
+        if (text2[at] === end) break;
+        if (text2[at++] !== ",") fail();
+        space();
+      }
+      at++;
+      return array ? items : result;
+    }
+    const literal = /^(true|false|null|undefined|[-+]?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?)(?=[\s,\]}]|$)/iu.exec(text2.slice(at))?.[0];
+    if (!literal) return fail();
+    at += literal.length;
+    if (literal === "true") return true;
+    if (literal === "false") return false;
+    if (literal === "null" || literal === "undefined") return null;
+    const number = Number(literal);
+    return Number.isFinite(number) ? number : fail();
+  }
+  try {
+    if (text2.length > 98304) return void 0;
+    const result = value();
+    space();
+    return at === text2.length && result !== null && typeof result === "object" && !Array.isArray(result) ? result : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var HEADER = /^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}) \[[^\]\r\n]+\] (INFO|WARN|ERROR)\s+(.+)$/u;
+var MAX_RECORD = 98304;
+var MAX_BYTES = 15e5;
+var RuntimeDiagnostics = class {
+  #sequence = 0;
+  #records = [];
+  #active = /* @__PURE__ */ new Map();
+  #sizes = /* @__PURE__ */ new Map();
+  #bytes = 0;
+  #dropped = 0;
+  write(source, text2, observedAt) {
+    for (const line of text2.split(/\r?\n/u)) {
+      if (!line) continue;
+      const header = HEADER.exec(line);
+      const previousIndex = this.#records.findIndex((record3) => record3.id === this.#active.get(source));
+      const previous = this.#records[previousIndex];
+      const continuation = !header && previous && (/^\s/u.test(line) || line === "}");
+      let record2;
+      if (continuation) {
+        const raw = `${previous.raw}
+${line}`;
+        record2 = { ...previous, raw: raw.slice(0, MAX_RECORD), truncated: previous.truncated || raw.length > MAX_RECORD || line.endsWith(" \u2026[truncated]") };
+      } else {
+        const title = header ? header[3].replace(/ \{.*$/u, "") : line.slice(0, 180);
+        const time = header ? Date.parse(`${header[1].replace(" ", "T")}+08:00`) : NaN;
+        record2 = {
+          id: `runtime-${++this.#sequence}`,
+          timestamp: Number.isFinite(time) ? new Date(time).toISOString() : observedAt,
+          source,
+          level: header ? header[2].toLowerCase() : source === "agent.stderr" ? "error" : "info",
+          title,
+          kind: header && title === "\u6A21\u578B\u8BF7\u6C42\u4F53" ? "request" : header && title === "\u6A21\u578B\u54CD\u5E94" ? "response" : "log",
+          raw: line.slice(0, MAX_RECORD),
+          truncated: line.length > MAX_RECORD || line.endsWith(" \u2026[truncated]")
+        };
+        this.#active.set(source, record2.id);
+      }
+      if (!record2.truncated && line.trimEnd().endsWith("}")) {
+        const head = HEADER.exec(record2.raw.split("\n")[0]);
+        const offset = head ? record2.raw.indexOf(" {", record2.raw.indexOf(head[3])) : -1;
+        const data = offset < 0 ? void 0 : parseInspectedData(record2.raw.slice(offset + 1));
+        if (data) record2 = { ...record2, data, ...typeof data.convoKey === "string" ? { convoKey: data.convoKey } : {} };
+      }
+      if (continuation && previous.data) {
+        const { data: _data, convoKey: _convoKey, ...rawRecord } = record2;
+        record2 = rawRecord;
+      }
+      this.#bytes -= this.#sizes.get(record2.id) ?? 0;
+      const size = Buffer.byteLength(JSON.stringify(record2));
+      this.#sizes.set(record2.id, size);
+      this.#bytes += size;
+      if (continuation) this.#records[previousIndex] = record2;
+      else this.#records.push(record2);
+      while (this.#records.length > 200 || this.#bytes > MAX_BYTES) {
+        const removed = this.#records.shift();
+        this.#bytes -= this.#sizes.get(removed.id) ?? 0;
+        this.#sizes.delete(removed.id);
+        this.#dropped++;
+      }
+    }
+  }
+  boundary() {
+    this.#active.clear();
+  }
+  clear() {
+    this.#records = [];
+    this.#active.clear();
+    this.#sizes.clear();
+    this.#bytes = 0;
+    this.#dropped = 0;
+  }
+  snapshot() {
+    return { records: [...this.#records].reverse(), dropped: this.#dropped };
+  }
+};
+
+// apps/preview/src/project-inspection.ts
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { parse } from "acorn";
+import { RUNTIME_PACKAGE_NAME } from "./platform.js";
+var Unknown = class {
+  constructor(reason = "\u914D\u7F6E\u4F9D\u8D56\u8FD0\u884C\u65F6\u4FE1\u606F\u6216\u6682\u4E0D\u652F\u6301\u7684\u8868\u8FBE\u5F0F\u3002", textPrefix) {
+    this.reason = reason;
+    this.textPrefix = textPrefix;
+  }
+  reason;
+  textPrefix;
+};
+var Api = class {
+  constructor(name) {
+    this.name = name;
+  }
+  name;
+};
+var PlatformTool = class {
+  constructor(name) {
+    this.name = name;
+  }
+  name;
+};
+var Fn = class {
+  constructor(node, scope) {
+    this.node = node;
+    this.scope = scope;
+  }
+  node;
+  scope;
+};
+var Fields = class _Fields {
+  constructor(entries, optional = false) {
+    this.entries = entries;
+    this.optional = optional;
+  }
+  entries;
+  optional;
+  get(key) {
+    for (let i = this.entries.length - 1; i >= 0; i--) {
+      const entry = this.entries[i];
+      if (entry.key !== void 0) {
+        if (entry.key === key) return entry.value();
+      } else {
+        const spread = entry.value();
+        if (!(spread instanceof _Fields)) return new Unknown("\u5BF9\u8C61\u5305\u542B\u52A8\u6001\u5C55\u5F00\uFF0C\u65E0\u6CD5\u786E\u5B9A\u6700\u7EC8\u914D\u7F6E\u3002");
+        const keys = spread.keys();
+        if (!keys || keys.includes(key)) return spread.get(key);
+      }
+    }
+    return void 0;
+  }
+  keys() {
+    const keys = /* @__PURE__ */ new Set();
+    for (const entry of this.entries) {
+      if (entry.key !== void 0) keys.add(entry.key);
+      else {
+        const spread = entry.value(), nested = spread instanceof _Fields ? spread.keys() : void 0;
+        if (!nested) return void 0;
+        nested.forEach((key) => keys.add(key));
+      }
+    }
+    return [...keys];
+  }
+};
+var fields = (data) => new Fields(Object.entries(data).map(([key, value]) => ({ key, value: () => value })));
+var unknown = () => new Unknown();
+var isPrimitive = (value) => value === null || value === void 0 || ["string", "number", "boolean"].includes(typeof value);
+var Scope = class {
+  constructor(file, parent) {
+    this.file = file;
+    this.parent = parent;
+  }
+  file;
+  parent;
+  bindings = /* @__PURE__ */ new Map();
+  mutable = /* @__PURE__ */ new Set();
+  get(name) {
+    if (this.mutable.has(name)) return new Unknown("\u914D\u7F6E\u5305\u542B\u53EF\u53D8\u503C\u6216\u540E\u7EED\u4FEE\u6539\uFF0C\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\u3002");
+    const binding = this.bindings.get(name);
+    return binding ? binding() : this.parent?.get(name) ?? new Unknown();
+  }
+};
+var within = (root, file) => {
+  const path = relative(root, file);
+  return !isAbsolute(path) && path !== ".." && !path.startsWith(`..${sep}`);
+};
+var keyOf = (node, computed = false) => !computed && node.type === "Identifier" ? node.name : node.type === "Literal" && ["string", "number"].includes(typeof node.value) ? String(node.value) : void 0;
+var unwrap = (node) => node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration" ? node.declaration ?? node : node;
+function walk(node, visit, functions = false) {
+  visit(node);
+  if (!functions && /^(?:Function|ArrowFunction)/u.test(node.type)) return;
+  for (const value of Object.values(node)) {
+    if (Array.isArray(value)) {
+      for (const child of value) if (child?.type) walk(child, visit, functions);
+    } else if (value && typeof value === "object" && value.type) walk(value, visit, functions);
+  }
+}
+var Reader = class {
+  sources = /* @__PURE__ */ new Map();
+  dependencies = /* @__PURE__ */ new Map();
+  root;
+  runtimeRoot;
+  bytes = 0;
+  steps = 0;
+  depth = 0;
+  constructor(root) {
+    this.root = realpathSync(root);
+  }
+  tick() {
+    if (++this.steps > 5e4) throw new Error("inspection budget");
+  }
+  lazy(read) {
+    let state = 0, result;
+    return () => {
+      this.tick();
+      if (state === 1) return new Unknown("\u914D\u7F6E\u5B58\u5728\u5FAA\u73AF\u5F15\u7528\u3002");
+      if (state === 2) return result;
+      state = 1;
+      try {
+        result = read();
+      } catch {
+        result = new Unknown("\u914D\u7F6E\u65E0\u6CD5\u9759\u6001\u8BFB\u53D6\uFF0C\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\u3002");
+      }
+      state = 2;
+      return result;
+    };
+  }
+  source(path) {
+    if (!this.dependencies.has(path)) this.dependencies.set(path, fingerprint(path));
+    const file = realpathSync(path);
+    const inRuntime = this.runtimeRoot && within(this.runtimeRoot, file);
+    if ((!within(this.root, file) || relative(this.root, file).split(sep).includes("node_modules")) && !inRuntime) throw new Error("outside project");
+    if (![".js", ".mjs", ".cjs"].includes(extname(file))) throw new Error("unsupported source");
+    const existing = this.sources.get(file);
+    if (existing) return existing;
+    const size = statSync(file).size;
+    if (this.sources.size >= 80 || size > 512e3 || (this.bytes += size) > 3e6) throw new Error("inspection size");
+    const tree = parse(readFileSync(file, "utf8"), { ecmaVersion: "latest", sourceType: "module" });
+    const scope = new Scope(file), exports = /* @__PURE__ */ new Map();
+    const result = { tree, scope, exports };
+    this.sources.set(file, result);
+    this.bind(tree.body, scope);
+    for (const statement of tree.body) {
+      if (statement.type === "ImportDeclaration") {
+        for (const specifier of statement.specifiers) {
+          const name = specifier.type === "ImportDefaultSpecifier" ? "default" : specifier.type === "ImportNamespaceSpecifier" ? "*" : keyOf(specifier.imported);
+          scope.bindings.set(specifier.local.name, this.lazy(() => this.imported(scope.file, statement.source.value, name ?? "")));
+        }
+      } else if (statement.type === "ExportDefaultDeclaration") {
+        exports.set("default", this.lazy(() => this.expression(statement.declaration, scope)));
+      } else if (statement.type === "ExportNamedDeclaration") {
+        const declaration = statement.declaration;
+        if (declaration?.type === "FunctionDeclaration") exports.set(declaration.id.name, () => scope.get(declaration.id.name));
+        if (declaration?.type === "VariableDeclaration") {
+          for (const item of declaration.declarations) if (item.id.type === "Identifier") exports.set(item.id.name, () => scope.get(item.id.name));
+        }
+        for (const specifier of statement.specifiers) {
+          const name = keyOf(specifier.exported), local = keyOf(specifier.local);
+          exports.set(name, this.lazy(() => statement.source ? this.imported(file, statement.source.value, local) : scope.get(local)));
+        }
+      }
+    }
+    return result;
+  }
+  imported(file, specifier, name) {
+    if (["typebox", "@sinclair/typebox"].includes(specifier) && name === "Type") return new Api("Type");
+    if (specifier === "@my-life-buddies/buddy-runtime" && name === "BuddyServer") return new Api("BuddyServer");
+    if (!specifier.startsWith("./") && !specifier.startsWith("../")) return new Unknown("\u914D\u7F6E\u6765\u81EA\u5916\u90E8\u4F9D\u8D56\uFF0C\u65E0\u6CD5\u9759\u6001\u786E\u5B9A\u3002");
+    const target = resolve(dirname(file), specifier);
+    for (const candidate of [target, `${target}.mjs`, `${target}.js`, join(target, "index.js")]) {
+      try {
+        const source = this.source(candidate);
+        return name === "*" ? new Fields([...source.exports].map(([key, value]) => ({ key, value }))) : source.exports.get(name)?.() ?? unknown();
+      } catch {
+      }
+    }
+    return new Unknown("\u5F15\u7528\u7684\u672C\u5730\u6E90\u6587\u4EF6\u65E0\u6CD5\u8BFB\u53D6\u6216\u4E0D\u652F\u6301\u9759\u6001\u5206\u6790\u3002");
+  }
+  bind(statements, scope) {
+    const aliases = /* @__PURE__ */ new Map();
+    const localValues = /* @__PURE__ */ new Set();
+    for (const item of statements) {
+      const statement = unwrap(item);
+      if (statement.type === "FunctionDeclaration" && statement.id) scope.bindings.set(statement.id.name, () => new Fn(statement, scope));
+      if (statement.type === "VariableDeclaration") for (const declaration of statement.declarations) {
+        this.pattern(declaration.id, this.lazy(() => this.expression(declaration.init, scope)), scope);
+        if (declaration.id.type === "Identifier") localValues.add(declaration.id.name);
+        let source = declaration.init;
+        while (source?.type === "MemberExpression") source = source.object;
+        if (declaration.id.type === "Identifier" && source?.type === "Identifier") aliases.set(declaration.id.name, source.name);
+        if (statement.kind !== "const") walk(declaration.id, (node) => {
+          if (node.type === "Identifier") scope.mutable.add(node.name);
+        });
+      }
+    }
+    for (const item of statements) walk(item, (node) => {
+      if (node.type === "ExpressionStatement" && node.expression.type === "CallExpression") {
+        for (const argument of node.expression.arguments) {
+          let root = argument;
+          while (root.type === "MemberExpression") root = root.object;
+          if (root.type === "Identifier" && localValues.has(root.name)) scope.mutable.add(root.name);
+        }
+      }
+      let target;
+      if (node.type === "AssignmentExpression") target = node.left;
+      if (node.type === "UpdateExpression") target = node.argument;
+      if (node.type === "CallExpression" && node.callee.type === "MemberExpression" && ["push", "pop", "shift", "unshift", "splice", "sort", "reverse", "fill", "copyWithin", "assign", "defineProperty"].includes(keyOf(node.callee.property, node.callee.computed) ?? "")) target = node.callee.object.name === "Object" ? node.arguments[0] : node.callee.object;
+      while (target?.type === "MemberExpression") target = target.object;
+      if (target?.type === "Identifier") scope.mutable.add(target.name);
+    });
+    for (let changed = true; changed; ) {
+      changed = false;
+      for (const [alias, original] of aliases) if (scope.mutable.has(alias) && !scope.mutable.has(original)) {
+        scope.mutable.add(original);
+        changed = true;
+      }
+    }
+  }
+  pattern(pattern, value, scope) {
+    if (pattern.type === "Identifier") scope.bindings.set(pattern.name, value);
+    else if (pattern.type === "ObjectPattern") for (const property of pattern.properties) {
+      if (property.type !== "Property") continue;
+      const key = keyOf(property.key, property.computed);
+      this.pattern(property.value, this.lazy(() => key === void 0 ? unknown() : this.member(value(), key)), scope);
+    }
+    else if (pattern.type === "ArrayPattern") pattern.elements.forEach((item, index) => {
+      if (item) this.pattern(item, this.lazy(() => this.member(value(), String(index))), scope);
+    });
+    else if (pattern.type === "AssignmentPattern") this.pattern(pattern.left, this.lazy(() => {
+      const item = value();
+      return item === void 0 ? this.expression(pattern.right, scope) : item;
+    }), scope);
+  }
+  functionScope(fn, args) {
+    const scope = new Scope(fn.scope.file, fn.scope);
+    fn.node.params.forEach((param, index) => this.pattern(param, () => args[index], scope));
+    if (fn.node.body.type === "BlockStatement") this.bind(fn.node.body.body, scope);
+    return scope;
+  }
+  call(fn, args) {
+    if (fn instanceof Api && fn.name.startsWith("Type.")) return this.schema(fn.name.slice(5), args);
+    if (!(fn instanceof Fn)) return new Unknown("\u51FD\u6570\u8C03\u7528\u7684\u7ED3\u679C\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\u3002");
+    if (++this.depth > 32) {
+      this.depth--;
+      return unknown();
+    }
+    try {
+      const scope = this.functionScope(fn, args), body = fn.node.body;
+      if (body.type !== "BlockStatement") return this.expression(body, scope);
+      for (const statement of body.body) {
+        if (statement.type === "ReturnStatement") return this.expression(statement.argument, scope);
+        let conditionalReturn = false;
+        walk(statement, (node) => {
+          if (node.type === "ReturnStatement") conditionalReturn = true;
+        });
+        if (conditionalReturn) return new Unknown("\u914D\u7F6E\u5DE5\u5382\u5305\u542B\u6761\u4EF6\u8FD4\u56DE\uFF0C\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\u3002");
+      }
+      return unknown();
+    } finally {
+      this.depth--;
+    }
+  }
+  member(object3, key) {
+    if (object3 instanceof Fields) return object3.get(key);
+    if (object3 instanceof Api) return object3.name === "conversation.tools" ? new PlatformTool(key) : new Api(`${object3.name}.${key}`);
+    if (Array.isArray(object3)) return key === "length" ? object3.length : /^\d+$/u.test(key) ? object3[Number(key)] : unknown();
+    return object3 instanceof Unknown ? object3 : unknown();
+  }
+  expression(node, scope) {
+    this.tick();
+    if (!node) return void 0;
+    switch (node.type) {
+      case "Literal":
+        return node.regex || node.bigint ? unknown() : node.value;
+      case "Identifier":
+        return node.name === "undefined" ? void 0 : scope.get(node.name);
+      case "FunctionDeclaration":
+      case "FunctionExpression":
+      case "ArrowFunctionExpression":
+        return new Fn(node, scope);
+      case "AwaitExpression":
+      case "ChainExpression":
+        return this.expression(node.argument ?? node.expression, scope);
+      case "ObjectExpression":
+        return new Fields(node.properties.map((property) => ({ key: property.type === "SpreadElement" ? void 0 : keyOf(property.key, property.computed), value: this.lazy(() => property.type === "SpreadElement" ? this.expression(property.argument, scope) : property.kind === "get" || property.kind === "set" ? unknown() : property.computed && keyOf(property.key, true) === void 0 ? unknown() : this.expression(property.value, scope)) })));
+      case "ArrayExpression": {
+        const values = [];
+        for (const element of node.elements) {
+          if (element?.type === "SpreadElement") {
+            const value = this.expression(element.argument, scope);
+            values.push(...Array.isArray(value) ? value : [value instanceof Unknown ? value : unknown()]);
+          } else values.push(this.expression(element, scope));
+        }
+        return values;
+      }
+      case "MemberExpression": {
+        const key = node.computed ? this.expression(node.property, scope) : node.property.name;
+        return typeof key === "string" || typeof key === "number" ? this.member(this.expression(node.object, scope), String(key)) : unknown();
+      }
+      case "CallExpression": {
+        if (node.callee.type === "MemberExpression" && keyOf(node.callee.property, node.callee.computed) === "map") {
+          const values = this.expression(node.callee.object, scope), fn = this.expression(node.arguments[0], scope);
+          return Array.isArray(values) ? values.map((value, index) => this.call(fn, [value, index])) : unknown();
+        }
+        return this.call(this.expression(node.callee, scope), node.arguments.map((arg) => this.expression(arg, scope)));
+      }
+      case "ConditionalExpression": {
+        const test = this.expression(node.test, scope);
+        return isPrimitive(test) ? this.expression(test ? node.consequent : node.alternate, scope) : new Unknown("\u914D\u7F6E\u6839\u636E\u73AF\u5883\u6216\u4F1A\u8BDD\u52A8\u6001\u9009\u62E9\uFF0C\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\u3002");
+      }
+      case "LogicalExpression": {
+        const left = this.expression(node.left, scope);
+        if (left instanceof Unknown) return left;
+        if (node.operator === "??") return left == null ? this.expression(node.right, scope) : left;
+        return (node.operator === "&&" ? Boolean(left) : !left) ? this.expression(node.right, scope) : left;
+      }
+      case "BinaryExpression": {
+        const left = this.expression(node.left, scope), right = this.expression(node.right, scope);
+        if (!isPrimitive(left) || !isPrimitive(right)) return node.operator === "+" && typeof left === "string" ? new Unknown("\u63CF\u8FF0\u5305\u542B\u52A8\u6001\u5185\u5BB9\uFF0C\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\u3002", left) : unknown();
+        if (node.operator === "+" && (typeof left === "string" || typeof right === "string")) return `${left}${right}`;
+        if (node.operator === "===") return left === right;
+        if (node.operator === "!==") return left !== right;
+        return unknown();
+      }
+      case "UnaryExpression": {
+        const value = this.expression(node.argument, scope);
+        if (!isPrimitive(value)) return unknown();
+        return node.operator === "!" ? !value : node.operator === "-" && typeof value === "number" ? -value : unknown();
+      }
+      case "TemplateLiteral": {
+        let result = "";
+        for (let i = 0; i < node.quasis.length; i++) {
+          result += node.quasis[i].value.cooked;
+          if (i < node.expressions.length) {
+            const value = this.expression(node.expressions[i], scope);
+            if (!isPrimitive(value)) return new Unknown("\u63CF\u8FF0\u5305\u542B\u52A8\u6001\u5185\u5BB9\uFF0C\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\u3002", result);
+            result += String(value);
+          }
+        }
+        return result;
+      }
+      default:
+        return unknown();
+    }
+  }
+  schema(name, args) {
+    const first = args[0];
+    if (name === "Optional") return first instanceof Fields ? new Fields(first.entries, true) : unknown();
+    const scalar = { String: "string", Number: "number", Integer: "integer", Boolean: "boolean", Null: "null" };
+    let schema, options;
+    if (scalar[name]) {
+      schema = fields({ type: scalar[name] });
+      options = first;
+    } else if (name === "Object" && first instanceof Fields) {
+      const keys = first.keys();
+      if (!keys) return unknown();
+      const required = [];
+      for (const key of keys) {
+        const value = first.get(key);
+        if (!(value instanceof Fields)) return unknown();
+        if (!value.optional) required.push(key);
+      }
+      schema = fields({ type: "object", properties: first, ...required.length ? { required } : {} });
+      options = args[1];
+    } else if (name === "Array") {
+      schema = fields({ type: "array", items: first });
+      options = args[1];
+    } else if (name === "Literal" && isPrimitive(first) && first !== void 0) {
+      schema = fields({ const: first, type: first === null ? "null" : typeof first });
+      options = args[1];
+    } else if (name === "Union" && Array.isArray(first)) {
+      schema = first.length === 1 && first[0] instanceof Fields ? first[0] : fields({ anyOf: first });
+      options = args[1];
+    } else if (name === "Any" || name === "Unknown") {
+      schema = fields({});
+      options = first;
+    } else return new Unknown("\u53C2\u6570\u4F7F\u7528\u6682\u4E0D\u652F\u6301\u7684 Schema \u6784\u9020\u65B9\u6CD5\u3002");
+    return options === void 0 ? schema : options instanceof Fields ? new Fields([...schema.entries, { value: () => options }]) : unknown();
+  }
+  json(value, depth = 0) {
+    this.tick();
+    if (depth > 30) throw new Error("schema depth");
+    if (isPrimitive(value)) return value;
+    if (Array.isArray(value)) return value.map((item) => this.json(item, depth + 1));
+    if (value instanceof Fields) {
+      const keys = value.keys();
+      if (!keys) throw new Error("dynamic schema");
+      return Object.fromEntries(keys.map((key) => [key, this.json(value.get(key), depth + 1)]));
+    }
+    throw new Error("dynamic schema");
+  }
+  runtime() {
+    try {
+      const path = createRequire(join(this.root, "package.json")).resolve("@my-life-buddies/buddy-runtime/package.json");
+      this.dependencies.set(path, fingerprint(path));
+      const manifest = JSON.parse(readFileSync(path, "utf8"));
+      if (manifest.name !== RUNTIME_PACKAGE_NAME) throw new Error("runtime package");
+      this.runtimeRoot = realpathSync(dirname(path));
+      const source = this.source(join(this.runtimeRoot, "dist/conversation/agent.js"));
+      const factory = source.exports.get("createAgent")?.();
+      const scope = factory instanceof Fn ? this.functionScope(factory, [unknown()]) : void 0;
+      return { tools: scope?.get("platformTools") ?? unknown(), builtin: source.exports.has("builtinTools") };
+    } catch {
+      return { tools: unknown(), builtin: true };
+    }
+  }
+  inspect() {
+    const source = this.source(join(this.root, "start.mjs"));
+    const starts = [];
+    walk(source.tree, (node) => {
+      if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") return;
+      if (keyOf(node.callee.property, node.callee.computed) !== "start") return;
+      const owner = this.expression(node.callee.object, source.scope);
+      if (owner instanceof Api && owner.name === "BuddyServer") starts.push(node);
+    });
+    const conversation = new Fields([{ value: () => new Unknown("\u914D\u7F6E\u4F9D\u8D56\u5F53\u524D\u4F1A\u8BDD\uFF0C\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\u3002") }, { key: "tools", value: () => new Api("conversation.tools") }]);
+    const options = starts.length === 1 ? this.call(this.expression(starts[0].arguments[0], source.scope), [conversation]) : new Unknown("\u672A\u8BC6\u522B\u5230\u552F\u4E00\u7684 BuddyServer.start \u5DE5\u5382\u5165\u53E3\u3002");
+    const initial = this.member(options, "initialState"), model = this.member(initial, "model");
+    const toolValues = this.member(initial, "tools"), runtime = this.runtime();
+    const tools = [], unresolved = [];
+    const list = toolValues === void 0 && initial instanceof Fields ? [] : Array.isArray(toolValues) ? toolValues : [toolValues];
+    let payloadSize = 0;
+    for (const item of list) {
+      if (tools.length + unresolved.length >= 128 || payloadSize > 25e4) {
+        unresolved.push({ reason: "\u914D\u7F6E\u6E05\u5355\u8D85\u51FA\u9759\u6001\u5C55\u793A\u4E0A\u9650\uFF0C\u5176\u4F59\u5DE5\u5177\u8BF7\u5728\u6A21\u578B\u8BF7\u6C42\u4E2D\u67E5\u770B\u3002" });
+        break;
+      }
+      const origin = item instanceof PlatformTool ? "platform" : "custom";
+      const value = item instanceof PlatformTool ? this.member(runtime.tools, item.name) : item;
+      if (item instanceof PlatformTool && value === void 0) {
+        unresolved.push({ name: item.name, reason: "\u5F53\u524D\u5B89\u88C5\u7684 Runtime \u672A\u63D0\u4F9B\u6B64\u5E73\u53F0\u5DE5\u5177\uFF0C\u8BF7\u68C0\u67E5\u6CE8\u518C\u914D\u7F6E\u3002" });
+        continue;
+      }
+      const name = item instanceof PlatformTool ? item.name : this.member(value, "name");
+      if (typeof name !== "string" || !/^[\w.-]{1,128}$/u.test(name)) {
+        unresolved.push({ reason: value instanceof Unknown ? value.reason : "\u5DE5\u5177\u540D\u79F0\u6216\u6CE8\u518C\u5173\u7CFB\u65E0\u6CD5\u9759\u6001\u786E\u5B9A\u3002" });
+        continue;
+      }
+      const description = this.member(value, "description"), parameters = this.member(value, "parameters");
+      let schema;
+      try {
+        const json2 = this.json(parameters);
+        if (json2 && typeof json2 === "object" && !Array.isArray(json2) && JSON.stringify(json2).length <= 32768) schema = json2;
+      } catch {
+      }
+      const reason = [typeof description !== "string" ? description instanceof Unknown && description.textPrefix ? "\u63CF\u8FF0\u542B\u52A8\u6001\u5185\u5BB9\uFF0C\u5F53\u524D\u4EC5\u5C55\u793A\u53EF\u8BFB\u53D6\u90E8\u5206\u3002" : "\u5DE5\u5177\u63CF\u8FF0\u5C1A\u672A\u9759\u6001\u8BFB\u53D6\u3002" : "", !schema ? "\u53C2\u6570\u5B9A\u4E49\u5C1A\u672A\u9759\u6001\u8BFB\u53D6\u3002" : ""].join("");
+      const descriptionText = typeof description === "string" ? description : description instanceof Unknown ? description.textPrefix : void 0;
+      const tool = { name, origin, ...descriptionText ? { description: descriptionText.slice(0, 4096) } : {}, ...schema ? { parameters: schema } : {}, ...reason ? { reason } : {} };
+      payloadSize += Buffer.byteLength(JSON.stringify(tool));
+      tools.push(tool);
+    }
+    if (runtime.builtin) unresolved.push({ name: "Runtime \u5185\u7F6E\u5DE5\u5177", reason: "Runtime \u53EF\u80FD\u6309\u6A21\u578B\u80FD\u529B\u8FFD\u52A0\u5DE5\u5177\uFF1B\u662F\u5426\u542F\u7528\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\uFF0C\u53EF\u5728\u6A21\u578B\u8BF7\u6C42\u4E2D\u67E5\u770B\u3002" });
+    const seen = /* @__PURE__ */ new Set();
+    for (const tool of tools) {
+      if (seen.has(tool.name)) unresolved.push({ name: tool.name, reason: "\u6CE8\u518C\u5217\u8868\u4E2D\u5B58\u5728\u540C\u540D\u5DE5\u5177\uFF0C\u8BF7\u68C0\u67E5\u5DE5\u7A0B\u914D\u7F6E\u3002" });
+      seen.add(tool.name);
+    }
+    return { status: unresolved.length || tools.some((tool) => tool.reason) ? "partial" : "complete", model: typeof model === "string" && model.length > 0 && model.length <= 128 ? { status: "known", value: model } : { status: "dynamic", reason: model instanceof Unknown ? model.reason : "\u6A21\u578B\u914D\u7F6E\u65E0\u6CD5\u9759\u6001\u786E\u5B9A\uFF0C\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\u3002" }, tools, unresolved };
+  }
+};
+var fingerprint = (path) => {
+  try {
+    const stat = statSync(path);
+    return `${realpathSync(path)}:${stat.size}:${stat.mtimeMs}:${stat.ctimeMs}`;
+  } catch {
+    return "missing";
+  }
+};
+function createProjectInspector(projectRoot) {
+  let cached;
+  let files = /* @__PURE__ */ new Map();
+  return async () => {
+    if (cached && [...files].every(([path, stamp]) => fingerprint(path) === stamp)) return cached;
+    let reader;
+    try {
+      reader = new Reader(projectRoot);
+      cached = reader.inspect();
+    } catch {
+      cached = { status: "partial", model: { status: "dynamic", reason: "\u5DE5\u7A0B\u5165\u53E3\u65E0\u6CD5\u9759\u6001\u8BFB\u53D6\uFF0C\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\u3002" }, tools: [], unresolved: [{ reason: "\u5DE5\u5177\u6CE8\u518C\u5173\u7CFB\u5C1A\u672A\u8BFB\u53D6\uFF1B\u8BF7\u786E\u8BA4\u5165\u53E3\u53CA\u5F15\u7528\u6587\u4EF6\u5B58\u5728\u4E14\u8BED\u6CD5\u6709\u6548\u3002" }] };
+    }
+    files = new Map([join(projectRoot, "start.mjs"), join(projectRoot, "node_modules/@my-life-buddies/buddy-runtime/package.json")].map((path) => [path, fingerprint(path)]));
+    for (const [path, stamp] of reader?.dependencies ?? []) files.set(path, stamp);
+    return cached;
+  };
+}
+
+// apps/preview/src/controller.ts
+var TERMINAL_RUN_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+function publicFailure(cause) {
+  const publicMessage = typeof cause === "object" && cause !== null && "publicMessage" in cause && typeof cause.publicMessage === "string" && cause.publicMessage.trim() && cause.publicMessage.length <= 512 && !/[\u0000-\u001f\u007f]/u.test(cause.publicMessage) ? cause.publicMessage : void 0;
+  if (typeof cause === "object" && cause !== null && "code" in cause && typeof cause.code === "string" && cause.code.trim()) {
+    return { code: cause.code, message: publicMessage ?? "DEV \u4F1A\u8BDD\u672A\u80FD\u5B8C\u6210" };
+  }
+  return { code: "DEV_START_FAILED", message: "DEV \u4F1A\u8BDD\u542F\u52A8\u5931\u8D25" };
+}
+var PreviewController = class {
+  #projectRoot;
+  #devStarter;
+  #readConfig;
+  #readBuddyDetails;
+  #now;
+  #readInspection;
+  #inspectionPromise;
+  #listeners = /* @__PURE__ */ new Set();
+  #simulatorListeners = /* @__PURE__ */ new Set();
+  #runs = /* @__PURE__ */ new Map();
+  #outputWatchers = /* @__PURE__ */ new Map();
+  #failedOutputRuns = /* @__PURE__ */ new Set();
+  #observedActiveRuns = /* @__PURE__ */ new Set();
+  #events = [];
+  #diagnostics = new RuntimeDiagnostics();
+  #runOrdinal = 0;
+  #conversationRevision = 0;
+  #simulatorRevision = 0;
+  #resetting = false;
+  #sendingMessage = false;
+  get resetting() {
+    return this.#resetting;
+  }
+  #state = Object.freeze({ phase: "idle", revision: 0 });
+  #handle;
+  #simulator;
+  #startController;
+  #startPromise;
+  #stopPromise;
+  #messages = [];
+  #simulatorState = Object.freeze({ messages: Object.freeze([]) });
+  #lastActiveRunId;
+  #eventSequence = 0;
+  constructor(options) {
+    this.#projectRoot = options.projectRoot;
+    this.#devStarter = options.devStarter;
+    this.#readConfig = options.readConfig ?? ((root) => readBuddyConfig(root));
+    this.#readBuddyDetails = options.readBuddyDetails;
+    this.#now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.#readInspection = options.readInspection ?? createProjectInspector(options.projectRoot);
+  }
+  get projectRoot() {
+    return this.#projectRoot;
+  }
+  state() {
+    return this.#state;
+  }
+  async refreshInspection() {
+    if (this.#closed) return;
+    if (this.#inspectionPromise) return this.#inspectionPromise;
+    this.#inspectionPromise = this.#readInspection().then((inspection) => {
+      if (!this.#closed && JSON.stringify(inspection) !== JSON.stringify(this.#state.inspection)) {
+        this.#setState({ ...this.#state, inspection });
+      }
+    }).finally(() => {
+      this.#inspectionPromise = void 0;
+    });
+    return this.#inspectionPromise;
+  }
+  async project() {
+    return this.#readConfig(this.#projectRoot);
+  }
+  async buddyDetails() {
+    if (!this.#readBuddyDetails) return this.#state.ready?.buddy ?? null;
+    const config = await this.project();
+    return this.#readBuddyDetails(config.buddyId);
+  }
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  subscribeSimulator(listener) {
+    this.#simulatorListeners.add(listener);
+    return () => this.#simulatorListeners.delete(listener);
+  }
+  simulatorSnapshot() {
+    return Object.freeze({ ...this.#simulatorState, conversationRevision: this.#conversationRevision, stateRevision: this.#simulatorRevision });
+  }
+  #closed = false;
+  start() {
+    if (this.#closed) return Promise.reject(Object.assign(new Error("\u672C\u5730\u8FDE\u63A5\u5DF2\u7ED3\u675F\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C\u8FDE\u63A5\u6307\u4EE4"), { code: "PREVIEW_CLOSED", status: 409 }));
+    if (this.#startPromise) return this.#startPromise;
+    if (this.#handle) return Promise.resolve(this.#state);
+    if (this.#state.phase === "stopping") {
+      return Promise.reject(Object.assign(new Error("DEV \u4F1A\u8BDD\u6B63\u5728\u505C\u6B62"), { code: "DEV_STOPPING" }));
+    }
+    const controller = new AbortController();
+    this.#diagnostics.boundary();
+    this.#startController = controller;
+    this.#record({ channel: "dev", type: "dev.start_requested", summary: "\u8BF7\u6C42\u542F\u52A8 DEV \u4F1A\u8BDD" });
+    this.#setState({ phase: "starting" });
+    const startPromise = this.#devStarter.start({
+      projectRoot: this.#projectRoot,
+      signal: controller.signal,
+      onLifecycle: ({ phase, error }) => {
+        if (controller.signal.aborted || !this.#handle || this.#state.phase === "stopping") return;
+        if (phase === "reloading") {
+          this.#stopOutputWatchers();
+          void this.#simulator?.resetWidgets?.();
+        }
+        this.#record({ channel: "dev", type: `dev.${phase}`, summary: phase === "reloading" ? "\u672C\u5730\u6587\u4EF6\u5DF2\u4FEE\u6539\uFF0C\u6B63\u5728\u91CD\u8F7D\uFF1B\u5F53\u524D\u56DE\u590D\u53EF\u80FD\u4E2D\u65AD" : phase === "reload_failed" ? error?.message ?? "\u91CD\u8F7D\u5931\u8D25\uFF0C\u4FEE\u6B63\u6587\u4EF6\u540E\u81EA\u52A8\u91CD\u8BD5" : "\u91CD\u8F7D\u5B8C\u6210\uFF0CDEV \u5DF2\u5C31\u7EEA" });
+        this.#setState({ phase, ready: this.#state.ready, ...error ? { error } : {} });
+        void this.refreshInspection();
+      },
+      onLog: ({ source, text: text2 }) => {
+        if (controller.signal.aborted) return;
+        this.#diagnostics.write(source, text2, this.#now().toISOString());
+        this.#record({ channel: "dev", type: source, summary: text2.slice(0, 512) });
+        this.#notifySimulator();
+      }
+    }).then(({ handle, ready, simulator }) => {
+      if (controller.signal.aborted) {
+        return handle.close().then(() => this.#setState({ phase: "idle" }));
+      }
+      this.#handle = handle;
+      this.#simulator = simulator;
+      this.#record({
+        channel: "dev",
+        type: "dev.ready",
+        summary: ready.agentId ? `Agent ${ready.agentId} \u5DF2\u5C31\u7EEA` : "Agent \u5DF2\u5C31\u7EEA"
+      });
+      void handle.closed.then(
+        () => {
+          if (this.#handle === handle) {
+            this.#handle = void 0;
+            void this.#simulator?.disposeWidgets?.();
+            this.#simulator = void 0;
+            this.#stopOutputWatchers();
+            this.#record({ channel: "dev", type: "dev.closed", summary: "DEV \u4F1A\u8BDD\u5DF2\u7ED3\u675F" });
+            this.#setState({ phase: "idle" });
+          }
+        },
+        (cause) => {
+          if (this.#handle === handle) {
+            this.#handle = void 0;
+            void this.#simulator?.disposeWidgets?.();
+            this.#simulator = void 0;
+            this.#stopOutputWatchers();
+            this.#record({ channel: "dev", type: "dev.failed", summary: "DEV \u4F1A\u8BDD\u5F02\u5E38\u7ED3\u675F" });
+            this.#setState({ phase: "failed", error: publicFailure(cause) });
+          }
+        }
+      );
+      return this.#setState({ phase: "ready", ready });
+    }).catch((cause) => {
+      if (controller.signal.aborted) return this.#setState({ phase: "idle" });
+      this.#record({ channel: "dev", type: "dev.start_failed", summary: "DEV \u4F1A\u8BDD\u542F\u52A8\u5931\u8D25" });
+      return this.#setState({ phase: "failed", error: publicFailure(cause) });
+    }).finally(() => {
+      if (this.#startController === controller) this.#startController = void 0;
+      if (this.#startPromise === startPromise) this.#startPromise = void 0;
+    });
+    this.#startPromise = startPromise;
+    return startPromise;
+  }
+  stop() {
+    if (this.#stopPromise) return this.#stopPromise;
+    const stopping = this.#stop();
+    this.#stopPromise = stopping;
+    const clear = () => {
+      if (this.#stopPromise === stopping) this.#stopPromise = void 0;
+    };
+    void stopping.then(clear, clear);
+    return stopping;
+  }
+  async #stop() {
+    if (this.#state.phase === "idle") return this.#state;
+    if (this.#state.phase === "stopping") return this.#state;
+    this.#setState({ phase: "stopping" });
+    this.#record({ channel: "dev", type: "dev.stop_requested", summary: "\u8BF7\u6C42\u505C\u6B62 DEV \u4F1A\u8BDD" });
+    this.#startController?.abort(new Error("Preview requested DEV stop"));
+    const handle = this.#handle;
+    this.#handle = void 0;
+    const widgetCleanup = this.#simulator?.disposeWidgets?.();
+    this.#simulator = void 0;
+    this.#stopOutputWatchers();
+    try {
+      if (handle) await handle.close();
+      await widgetCleanup;
+      if (this.#startPromise) await this.#startPromise.catch(() => void 0);
+      this.#record({ channel: "dev", type: "dev.stopped", summary: "DEV \u4F1A\u8BDD\u5DF2\u505C\u6B62" });
+      return this.#setState({ phase: "idle" });
+    } catch (cause) {
+      this.#setState({ phase: "failed", error: publicFailure(cause) });
+      throw cause;
+    }
+  }
+  async close() {
+    this.#closed = true;
+    await this.stop();
+    this.#listeners.clear();
+    this.#simulatorListeners.clear();
+  }
+  async simulatorState(signal) {
+    if (this.#resetting) return this.simulatorSnapshot();
+    const simulator = this.#requiredSimulator();
+    const revision = this.#conversationRevision;
+    const state = await simulator.state({ signal });
+    if (!this.#resetting && revision === this.#conversationRevision && simulator === this.#simulator) {
+      this.#observeSimulatorState(state);
+    }
+    return this.simulatorSnapshot();
+  }
+  /** Never allow an old conversation's delayed widget response to enter the new one. */
+  async simulatorWidgets(action, id = "", mediaId = "", messageId) {
+    if (this.#resetting) throw Object.assign(new Error("\u4F1A\u8BDD\u6B63\u5728\u91CD\u7F6E"), { status: 409 });
+    const client = this.#requiredSimulator();
+    const revision = this.#conversationRevision;
+    let result;
+    if (action === "list" && client.widgets) result = { widgets: await client.widgets(), conversationRevision: revision, capabilities: { documentLifecycle: true, widgetEditing: Boolean(client.widgetCommand) } };
+    else if (action === "html" && client.widgetHtml) {
+      let target;
+      if (messageId !== void 0) {
+        const state = await client.state();
+        const message2 = state.messages.find((item) => item.messageId === messageId && item.widget?.id === id);
+        if (!message2?.widget) throw Object.assign(new Error("\u8FD9\u6761\u5C0F\u6302\u4EF6\u6D88\u606F\u5DF2\u4E0D\u53EF\u7528\uFF0C\u8BF7\u5237\u65B0\u5BF9\u8BDD\u540E\u91CD\u8BD5"), { status: 404 });
+        target = message2.widget.openTarget;
+      }
+      if (this.#resetting || revision !== this.#conversationRevision || client !== this.#simulator) throw Object.assign(new Error("\u4F1A\u8BDD\u5DF2\u5207\u6362\uFF0C\u8BF7\u91CD\u65B0\u6253\u5F00\u5C0F\u6302\u4EF6"), { status: 409 });
+      result = await client.widgetHtml(id, target);
+    } else if (action === "image" && client.widgetImage) result = await client.widgetImage(id, mediaId);
+    else if ((action === "pin" || action === "unpin") && client.pinWidget) {
+      await client.pinWidget(id, action === "pin");
+      result = { ok: true };
+    } else throw Object.assign(new Error("\u5F53\u524D\u6A21\u62DF\u5668\u4E0D\u652F\u6301\u5C0F\u6302\u4EF6"), { status: 501 });
+    if (this.#resetting || revision !== this.#conversationRevision || client !== this.#simulator) throw Object.assign(new Error("\u4F1A\u8BDD\u5DF2\u5207\u6362\uFF0C\u8BF7\u91CD\u65B0\u6253\u5F00\u5C0F\u6302\u4EF6"), { status: 409 });
+    return result;
+  }
+  async simulatorWidgetCommand(id, body) {
+    if (this.#resetting) throw Object.assign(new Error("\u4F1A\u8BDD\u6B63\u5728\u91CD\u7F6E"), { status: 409 });
+    const client = this.#requiredSimulator(), revision = this.#conversationRevision;
+    if (!body || typeof body !== "object" || body.conversationRevision !== revision)
+      throw Object.assign(new Error("\u4F1A\u8BDD\u5DF2\u5207\u6362\uFF0C\u8BF7\u91CD\u65B0\u6253\u5F00\u5C0F\u6302\u4EF6"), { status: 409 });
+    if (!client.widgetCommand) throw Object.assign(new Error("\u5F53\u524D\u6A21\u62DF\u5668\u4E0D\u652F\u6301 Widget \u7F16\u8F91"), { status: 501 });
+    const result = await client.widgetCommand(id, body);
+    if (this.#resetting || client !== this.#simulator || revision !== this.#conversationRevision)
+      throw Object.assign(new Error("\u4F1A\u8BDD\u5DF2\u5207\u6362\uFF0C\u8BF7\u91CD\u65B0\u6253\u5F00\u5C0F\u6302\u4EF6"), { status: 409 });
+    return result;
+  }
+  #productOperationPending = false;
+  async simulatorProduct(offerId, input) {
+    if (this.#resetting || this.#productOperationPending) throw Object.assign(new Error("\u4F1A\u8BDD\u6B63\u5728\u5904\u7406\u5176\u4ED6\u64CD\u4F5C\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5"), { status: 409 });
+    const client = this.#requiredSimulator(), revision = this.#conversationRevision;
+    if (input && input.conversationRevision !== revision) throw Object.assign(new Error("\u4F1A\u8BDD\u5DF2\u5207\u6362\uFF0C\u8BF7\u91CD\u65B0\u6253\u5F00\u5546\u54C1\u5361"), { status: 409 });
+    if (!client.productOffer || input && !client.purchaseProduct) throw Object.assign(new Error("\u8BF7\u66F4\u65B0 CLI \u540E\u91CD\u8FDE\uFF0C\u4EE5\u9884\u89C8\u5546\u54C1\u5361"), { status: 501 });
+    const state = await client.state();
+    if (!state.messages.some((message2) => message2.product?.offerId === offerId)) throw Object.assign(new Error("\u5546\u54C1\u5361\u5DF2\u4E0D\u5728\u5F53\u524D\u5BF9\u8BDD\u4E2D\uFF0C\u8BF7\u91CD\u65B0\u6253\u5F00"), { status: 404 });
+    if (this.#resetting || this.#productOperationPending || client !== this.#simulator || revision !== this.#conversationRevision) throw Object.assign(new Error("\u4F1A\u8BDD\u5DF2\u5207\u6362\u6216\u6B63\u5728\u8D2D\u4E70\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5"), { status: 409 });
+    this.#productOperationPending = true;
+    try {
+      const result = input ? await client.purchaseProduct(offerId, input) : await client.productOffer(offerId);
+      if (this.#resetting || client !== this.#simulator || revision !== this.#conversationRevision) throw Object.assign(new Error("\u4F1A\u8BDD\u5DF2\u5207\u6362\uFF0C\u8BF7\u5237\u65B0\u72B6\u6001"), { status: 409 });
+      return result;
+    } finally {
+      this.#productOperationPending = false;
+    }
+  }
+  async resetSimulator() {
+    if (this.#resetting || this.#sendingMessage || this.#productOperationPending || this.#simulatorState.activeRun) {
+      throw Object.assign(new Error("\u8BF7\u7B49\u5F85\u5F53\u524D\u56DE\u590D\u6216\u64CD\u4F5C\u5B8C\u6210\u540E\u518D\u6E05\u7A7A"), { status: 409, code: "SIMULATOR_BUSY" });
+    }
+    const simulator = this.#requiredSimulator();
+    if (!simulator.reset) {
+      throw Object.assign(new Error("\u5F53\u524D\u5E73\u53F0\u6682\u4E0D\u652F\u6301\u6E05\u7A7A\u5BF9\u8BDD"), { status: 501, code: "RESET_UNSUPPORTED", publicMessage: "\u5F53\u524D\u5E73\u53F0\u6682\u4E0D\u652F\u6301\u6E05\u7A7A\u5BF9\u8BDD" });
+    }
+    this.#resetting = true;
+    try {
+      await simulator.reset();
+      this.#conversationRevision++;
+      this.#stopOutputWatchers();
+      this.#runs.clear();
+      this.#observedActiveRuns.clear();
+      this.#events.length = 0;
+      this.#diagnostics.clear();
+      this.#runOrdinal = 0;
+      this.#lastActiveRunId = void 0;
+      this.#messages = Object.freeze([]);
+      this.#simulatorState = Object.freeze({ messages: this.#messages });
+      this.#notifySimulator();
+      return this.simulatorSnapshot();
+    } finally {
+      this.#resetting = false;
+    }
+  }
+  async sendSimulatorMessage(input, signal) {
+    if (this.#resetting || this.#sendingMessage) throw Object.assign(new Error("\u6A21\u62DF\u5668\u6B63\u5728\u5904\u7406\u5176\u4ED6\u64CD\u4F5C"), { status: 409, code: "SIMULATOR_BUSY" });
+    this.#sendingMessage = true;
+    try {
+      const started = this.#now();
+      this.#record({ channel: "client", type: "message.send", summary: "\u53D1\u9001\u4E00\u6761\u79C1\u804A\u6D88\u606F" });
+      const accepted = await this.#requiredSimulator().send(input, { signal });
+      if (this.#runs.has(accepted.runId)) {
+        if (this.#simulatorState.activeRun?.runId === accepted.runId && !this.#simulatorState.messages.some((message2) => message2.messageId === accepted.messageId)) {
+          this.#record({
+            channel: "app_server",
+            type: "message.accepted",
+            summary: "\u8FFD\u52A0\u6D88\u606F\u5DF2\u63A5\u6536",
+            runId: accepted.runId,
+            durationMs: Math.max(0, this.#now().getTime() - started.getTime())
+          });
+          this.#simulatorState = Object.freeze({
+            ...this.#simulatorState,
+            messages: Object.freeze([...this.#simulatorState.messages, Object.freeze({
+              messageId: accepted.messageId,
+              role: "user",
+              text: input.text,
+              createdAt: this.#now().toISOString()
+            })])
+          });
+          this.#messages = this.#simulatorState.messages;
+          this.#notifySimulator();
+        }
+        return accepted;
+      }
+      const acceptedAt = this.#now();
+      const latency = Math.max(0, acceptedAt.getTime() - started.getTime());
+      this.#upsertRun({
+        runId: accepted.runId,
+        messageId: accepted.messageId,
+        status: "accepted",
+        startedAt: started.toISOString(),
+        updatedAt: acceptedAt.toISOString(),
+        acceptLatencyMs: latency
+      });
+      this.#lastActiveRunId = accepted.runId;
+      this.#record({
+        channel: "app_server",
+        type: "run.accepted",
+        summary: "App Server \u5DF2\u63A5\u53D7\u6D88\u606F\uFF0C\u5DF2\u8BB0\u5F55\u53D1\u9001\u56DE\u6267",
+        runId: accepted.runId,
+        durationMs: latency
+      });
+      this.#simulatorState = Object.freeze({
+        messages: Object.freeze([
+          ...this.#simulatorState.messages.filter((message2) => message2.messageId !== accepted.messageId),
+          Object.freeze({
+            messageId: accepted.messageId,
+            role: "user",
+            text: input.text,
+            createdAt: acceptedAt.toISOString()
+          })
+        ]),
+        latestRun: Object.freeze({ runId: accepted.runId, status: "pending" }),
+        activeRun: Object.freeze({ runId: accepted.runId, status: "pending" })
+      });
+      this.#messages = this.#simulatorState.messages;
+      this.#notifySimulator();
+      this.#startOutputWatcher(this.#requiredSimulator(), accepted.runId);
+      return accepted;
+    } finally {
+      this.#sendingMessage = false;
+    }
+  }
+  async cancelSimulatorRun(runId, signal) {
+    this.#record({
+      channel: "client",
+      type: "run.cancel_requested",
+      // Local debug event, not an MLB SSE event.
+      summary: "\u5F00\u53D1\u8005\u8BF7\u6C42\u505C\u6B62\u5F53\u524D\u56DE\u590D",
+      runId
+    });
+    const result = await this.#requiredSimulator().cancel(runId, { signal });
+    if (result.status === "cancel_requested") {
+      this.#updateRunStatus(runId, "cancel_requested");
+      if (this.#simulatorState.activeRun?.runId === runId) {
+        this.#simulatorState = Object.freeze({
+          messages: this.#simulatorState.messages,
+          latestRun: Object.freeze({ runId, status: "cancel_requested" }),
+          activeRun: Object.freeze({ runId, status: "cancel_requested" }),
+          ...this.#simulatorState.streaming?.runId === runId ? { streaming: this.#simulatorState.streaming } : {}
+        });
+      }
+    }
+    this.#record({
+      channel: "app_server",
+      type: `run.${result.status}`,
+      summary: result.status === "cancel_requested" ? "App Server \u5DF2\u63A5\u53D7\u505C\u6B62\u8BF7\u6C42" : "Run \u5DF2\u7ECF\u7ED3\u675F",
+      runId
+    });
+    if (result.status === "already_terminal") {
+      await this.simulatorState(signal).catch(() => this.#notifySimulator());
+    } else {
+      this.#notifySimulator();
+    }
+    return result;
+  }
+  debugSnapshot() {
+    return Object.freeze({
+      source: "observed",
+      generatedAt: this.#now().toISOString(),
+      runs: Object.freeze([...this.#runs.values()].reverse()),
+      events: Object.freeze([...this.#events].reverse()),
+      messages: Object.freeze([...this.#messages]),
+      diagnostics: this.#diagnostics.snapshot()
+    });
+  }
+  devicePairing() {
+    const pairing = this.#state.phase === "ready" ? this.#state.ready?.devicePairing : void 0;
+    if (pairing) {
+      try {
+        if (pairing.url === createBuddyPreviewUrl(this.#state.ready?.agentId ?? "") && pairing.url.length <= 2048 && (pairing.code === void 0 || /^[A-Z0-9-]{4,32}$/iu.test(pairing.code)) && (pairing.expiresAt === void 0 || Number.isFinite(Date.parse(pairing.expiresAt)))) {
+          return Object.freeze({
+            status: "ready",
+            url: pairing.url,
+            ...pairing.code === void 0 ? {} : { code: pairing.code },
+            ...pairing.expiresAt === void 0 ? {} : { expiresAt: pairing.expiresAt }
+          });
+        }
+      } catch {
+      }
+    }
+    return Object.freeze({
+      status: "unavailable",
+      reason: this.#state.phase !== "ready" ? "\u8BF7\u5148\u542F\u52A8 DEV \u4F1A\u8BDD" : pairing ? "\u5F53\u524D DEV \u73AF\u5883\u8FD4\u56DE\u4E86\u65E0\u6548\u7684\u771F\u673A\u5165\u53E3" : "\u5F53\u524D DEV \u4F1A\u8BDD\u5C1A\u672A\u63D0\u4F9B\u642D\u642D App \u9884\u89C8\u94FE\u63A5"
+    });
+  }
+  #requiredSimulator() {
+    if (this.#state.phase !== "ready" || !this.#simulator) {
+      throw Object.assign(new Error("\u6A21\u62DF\u5668\u9700\u8981\u5148\u542F\u52A8 DEV \u4F1A\u8BDD"), {
+        code: "SIMULATOR_NOT_READY",
+        status: 409,
+        publicMessage: "\u8BF7\u5148\u542F\u52A8 DEV \u4F1A\u8BDD"
+      });
+    }
+    return this.#simulator;
+  }
+  #observeSimulatorState(state) {
+    const previousStreaming = this.#simulatorState.streaming;
+    const incomingActiveRun = state.activeRun;
+    const existingActiveRun = incomingActiveRun ? this.#runs.get(incomingActiveRun.runId) : void 0;
+    if (existingActiveRun && TERMINAL_RUN_STATUSES.has(existingActiveRun.status)) {
+      this.#notifySimulator();
+      return this.#simulatorState;
+    }
+    let streaming = state.streaming ?? (incomingActiveRun?.runId === previousStreaming?.runId ? previousStreaming : void 0);
+    if (streaming && previousStreaming?.runId === streaming.runId) {
+      if (streaming.nextSequence < previousStreaming.nextSequence) {
+        streaming = previousStreaming;
+      } else if (streaming.nextSequence === previousStreaming.nextSequence && streaming.text !== previousStreaming.text) {
+        throw Object.assign(new Error("App Server \u6539\u5199\u4E86\u5DF2\u89C2\u5BDF\u5230\u7684\u6D41\u5F0F\u6587\u5B57"), {
+          code: "OUTPUT_STREAM_PROTOCOL_ERROR",
+          publicMessage: "App Server \u8FD4\u56DE\u4E86\u4E0D\u4E00\u81F4\u7684\u6D41\u5F0F\u72B6\u6001"
+        });
+      } else if (streaming.nextSequence > previousStreaming.nextSequence && !streaming.text.startsWith(previousStreaming.text)) {
+        throw Object.assign(new Error("App Server \u6539\u5199\u4E86\u5DF2\u89C2\u5BDF\u5230\u7684\u6D41\u5F0F\u6587\u5B57"), {
+          code: "OUTPUT_STREAM_PROTOCOL_ERROR",
+          publicMessage: "App Server \u8FD4\u56DE\u4E86\u4E0D\u4E00\u81F4\u7684\u6D41\u5F0F\u72B6\u6001"
+        });
+      }
+    }
+    this.#simulatorState = Object.freeze({
+      messages: Object.freeze([...state.messages]),
+      ...state.latestRun === void 0 ? {} : { latestRun: Object.freeze({ ...state.latestRun }) },
+      ...state.activeRun === void 0 ? {} : { activeRun: Object.freeze({ ...state.activeRun }) },
+      ...streaming === void 0 ? {} : { streaming: Object.freeze({ ...streaming }) }
+    });
+    this.#messages = this.#simulatorState.messages;
+    const now = this.#now();
+    const active = this.#simulatorState.activeRun;
+    if (active) {
+      this.#observedActiveRuns.add(active.runId);
+      const existing2 = this.#runs.get(active.runId);
+      const restoredFirstTextLatency = existing2?.firstTextLatencyMs ?? (this.#simulatorState.streaming?.runId === active.runId && this.#simulatorState.streaming.nextSequence > 0 && this.#simulatorState.streaming.text.length > 0 ? Math.max(0, now.getTime() - Date.parse(existing2?.startedAt ?? now.toISOString())) : void 0);
+      this.#upsertRun({
+        runId: active.runId,
+        ...existing2?.messageId ? { messageId: existing2.messageId } : {},
+        status: active.status,
+        startedAt: existing2?.startedAt ?? now.toISOString(),
+        updatedAt: now.toISOString(),
+        ...existing2?.acceptLatencyMs === void 0 ? {} : { acceptLatencyMs: existing2.acceptLatencyMs },
+        ...restoredFirstTextLatency === void 0 ? {} : { firstTextLatencyMs: restoredFirstTextLatency }
+      });
+      if (existing2?.firstTextLatencyMs === void 0 && restoredFirstTextLatency !== void 0) {
+        this.#record({
+          channel: "app_server",
+          type: "run.output.restored",
+          summary: "\u4ECE App Server \u72B6\u6001\u6062\u590D\u5F53\u524D\u6D41\u5F0F\u6587\u5B57",
+          runId: active.runId,
+          durationMs: restoredFirstTextLatency
+        });
+      }
+      if (this.#lastActiveRunId !== active.runId || existing2?.status !== active.status) {
+        this.#record({
+          channel: "app_server",
+          type: `run.${active.status}`,
+          summary: active.status === "pending" ? "Run \u6B63\u5728\u7B49\u5F85 Agent" : "Agent \u6B63\u5728\u5904\u7406 Run",
+          runId: active.runId
+        });
+      }
+      this.#lastActiveRunId = active.runId;
+      if (this.#simulator) this.#startOutputWatcher(this.#simulator, active.runId);
+      this.#notifySimulator();
+      return this.#simulatorState;
+    }
+    if (!this.#lastActiveRunId) {
+      this.#notifySimulator();
+      return this.#simulatorState;
+    }
+    const runId = this.#lastActiveRunId;
+    const existing = this.#runs.get(runId);
+    if (existing && !["completed", "failed", "cancelled"].includes(existing.status)) {
+      const assistant = [...this.#simulatorState.messages].reverse().find((message2) => message2.role === "assistant" && Date.parse(message2.createdAt) >= Date.parse(existing.startedAt));
+      const elapsed = Math.max(0, now.getTime() - Date.parse(existing.startedAt));
+      const terminalStatus = this.#simulatorState.latestRun?.runId === runId && (this.#simulatorState.latestRun.status === "completed" || this.#simulatorState.latestRun.status === "failed" || this.#simulatorState.latestRun.status === "cancelled") ? this.#simulatorState.latestRun.status : void 0;
+      if (!assistant && !terminalStatus && !this.#observedActiveRuns.has(runId) && elapsed < 5e3) {
+        this.#notifySimulator();
+        return this.#simulatorState;
+      }
+      const completedAt = assistant && Number.isFinite(Date.parse(assistant.createdAt)) ? new Date(assistant.createdAt) : now;
+      const status = terminalStatus ?? "completed";
+      this.#upsertRun({
+        ...existing,
+        status,
+        updatedAt: now.toISOString(),
+        completedAt: completedAt.toISOString(),
+        responseTimeMs: Math.max(0, completedAt.getTime() - Date.parse(existing.startedAt)),
+        completion: assistant ? "reply" : "no_reply"
+      });
+      this.#record({
+        channel: "app_server",
+        type: `run.${status}`,
+        summary: assistant ? "\u5B8C\u6574\u56DE\u590D\u5DF2\u8FD4\u56DE\uFF0C\u672C\u5730\u56DE\u5408\u7ED3\u675F" : status === "failed" ? "Agent \u672C\u5730\u56DE\u5408\u6267\u884C\u5931\u8D25\uFF0C\u672A\u4EA7\u751F\u7528\u6237\u56DE\u590D" : status === "cancelled" ? "Agent \u672C\u5730\u56DE\u5408\u5DF2\u53D6\u6D88\uFF0C\u672A\u5B8C\u6210\u56DE\u590D\u5DF2\u4F5C\u5E9F" : "\u672C\u5730\u56DE\u5408\u5DF2\u7ED3\u675F\uFF0C\u672A\u89C2\u5BDF\u5230\u65B0\u7684\u5B8C\u6574\u56DE\u590D",
+        runId,
+        durationMs: Math.max(0, completedAt.getTime() - Date.parse(existing.startedAt))
+      });
+      this.#stopOutputWatcher(runId);
+    }
+    this.#observedActiveRuns.delete(runId);
+    this.#lastActiveRunId = void 0;
+    this.#notifySimulator();
+    return this.#simulatorState;
+  }
+  #startOutputWatcher(simulator, runId) {
+    if (!simulator.watchOutput || this.#outputWatchers.has(runId) || this.#failedOutputRuns.has(runId)) return;
+    const controller = new AbortController();
+    this.#outputWatchers.set(runId, controller);
+    void simulator.watchOutput(runId, {
+      signal: controller.signal,
+      onEvent: (event) => {
+        if (controller.signal.aborted || this.#resetting || simulator !== this.#simulator) return;
+        return this.#observeOutputEvent(event);
+      }
+    }).catch((cause) => {
+      if (controller.signal.aborted) return;
+      this.#failedOutputRuns.add(runId);
+      this.#record({
+        channel: "app_server",
+        type: "run.output.disconnected",
+        summary: cause && typeof cause === "object" && "status" in cause && cause.status === 401 ? "MLB \u767B\u5F55\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55\u540E\u91CD\u542F DEV" : "\u6D41\u5F0F\u8FDE\u63A5\u4E2D\u65AD\uFF0C\u6A21\u62DF\u5668\u5C06\u4F7F\u7528 App Server \u72B6\u6001\u6062\u590D",
+        runId
+      });
+      this.#notifySimulator();
+      void this.simulatorState().catch(() => void 0);
+    }).finally(() => {
+      if (this.#outputWatchers.get(runId) === controller) this.#outputWatchers.delete(runId);
+    });
+  }
+  async #observeOutputEvent(event) {
+    if (event.type === "state") {
+      if (event.resetStreaming) {
+        const { streaming: _streaming, ...state } = this.#simulatorState;
+        this.#simulatorState = Object.freeze(state);
+      }
+      this.#observeSimulatorState(event.state);
+      return;
+    }
+    if (event.type === "reset") {
+      if (this.#simulatorState.streaming?.runId === event.runId) {
+        const { streaming: _streaming, ...state } = this.#simulatorState;
+        this.#simulatorState = Object.freeze(state);
+        this.#notifySimulator();
+      }
+      return;
+    }
+    const now = this.#now();
+    const existing = this.#runs.get(event.runId);
+    if (event.type === "delta") {
+      if (existing && TERMINAL_RUN_STATUSES.has(existing.status) || this.#simulatorState.latestRun?.runId === event.runId && TERMINAL_RUN_STATUSES.has(this.#simulatorState.latestRun.status)) {
+        return;
+      }
+      const previous = this.#simulatorState.streaming;
+      const expected = previous?.runId === event.runId ? previous.nextSequence : 0;
+      if (event.sequence < expected) return;
+      if (event.sequence > expected) {
+        throw Object.assign(new Error("App Server \u8FD4\u56DE\u7684\u6D41\u5F0F\u5E8F\u53F7\u4E0D\u8FDE\u7EED"), { code: "OUTPUT_SEQUENCE_MISMATCH" });
+      }
+      const text2 = `${previous?.runId === event.runId ? previous.text : ""}${event.text}`;
+      const firstTextLatencyMs = existing?.firstTextLatencyMs ?? (existing ? Math.max(0, now.getTime() - Date.parse(existing.startedAt)) : void 0);
+      if (existing) {
+        this.#upsertRun({
+          ...existing,
+          status: "running",
+          updatedAt: now.toISOString(),
+          ...firstTextLatencyMs === void 0 ? {} : { firstTextLatencyMs }
+        });
+      }
+      this.#simulatorState = Object.freeze({
+        messages: this.#simulatorState.messages,
+        latestRun: Object.freeze({ runId: event.runId, status: "running" }),
+        activeRun: Object.freeze({ runId: event.runId, status: "running" }),
+        streaming: Object.freeze({
+          runId: event.runId,
+          text: text2,
+          nextSequence: event.sequence + 1,
+          updatedAt: now.toISOString()
+        })
+      });
+      this.#record({
+        channel: "app_server",
+        type: event.sequence === 0 ? "run.output.started" : "run.output.delta",
+        summary: event.sequence === 0 ? "\u9996\u6BB5\u6D41\u5F0F\u6587\u5B57\u5DF2\u5230\u8FBE" : `\u6536\u5230\u7B2C ${event.sequence + 1} \u6BB5\u6D41\u5F0F\u6587\u5B57`,
+        runId: event.runId,
+        ...firstTextLatencyMs === void 0 || event.sequence !== 0 ? {} : { durationMs: firstTextLatencyMs }
+      });
+      this.#notifySimulator();
+      return;
+    }
+    this.#record({
+      channel: "app_server",
+      type: `run.output.${event.type}`,
+      summary: event.type === "completed" ? "\u6D41\u5F0F\u8F93\u51FA\u5B8C\u6210\uFF0C\u6B63\u5728\u786E\u8BA4\u6B63\u5F0F\u56DE\u590D" : event.type === "failed" ? "\u672C\u5730\u56DE\u5408\u5931\u8D25\uFF0C\u4E34\u65F6\u6D41\u5F0F\u6587\u5B57\u5DF2\u4F5C\u5E9F" : "\u672C\u5730\u56DE\u5408\u5DF2\u53D6\u6D88\uFF0C\u4E34\u65F6\u6D41\u5F0F\u6587\u5B57\u5DF2\u4F5C\u5E9F",
+      runId: event.runId
+    });
+    if (event.type !== "completed") {
+      this.#simulatorState = Object.freeze({
+        messages: this.#simulatorState.messages,
+        latestRun: Object.freeze({ runId: event.runId, status: event.status })
+      });
+      this.#notifySimulator();
+    }
+    await this.simulatorState().catch(() => void 0);
+  }
+  #stopOutputWatchers() {
+    for (const controller of this.#outputWatchers.values()) {
+      controller.abort(new Error("Preview DEV session closed"));
+    }
+    this.#outputWatchers.clear();
+    this.#failedOutputRuns.clear();
+  }
+  #stopOutputWatcher(runId) {
+    this.#failedOutputRuns.delete(runId);
+    const controller = this.#outputWatchers.get(runId);
+    if (!controller) return;
+    this.#outputWatchers.delete(runId);
+    controller.abort(new Error("Agent local turn reached a terminal state"));
+  }
+  #notifySimulator() {
+    this.#simulatorRevision++;
+    if (this.#simulatorListeners.size === 0) return;
+    const value = Object.freeze({ state: this.simulatorSnapshot(), debug: this.debugSnapshot() });
+    for (const listener of this.#simulatorListeners) {
+      try {
+        listener(value);
+      } catch {
+      }
+    }
+  }
+  #upsertRun(run) {
+    const ordinal = this.#runs.get(run.runId)?.ordinal ?? ++this.#runOrdinal;
+    this.#runs.set(run.runId, Object.freeze({ ...run, ordinal }));
+    while (this.#runs.size > 100) {
+      const oldest = this.#runs.keys().next().value;
+      if (!oldest) break;
+      this.#runs.delete(oldest);
+    }
+  }
+  #updateRunStatus(runId, status) {
+    const existing = this.#runs.get(runId);
+    if (!existing) return;
+    this.#upsertRun({ ...existing, status, updatedAt: this.#now().toISOString() });
+  }
+  #record(input) {
+    this.#eventSequence += 1;
+    this.#events.push(Object.freeze({
+      ...input,
+      eventId: `event-${this.#eventSequence}`,
+      timestamp: this.#now().toISOString()
+    }));
+    if (this.#events.length > 300) this.#events.splice(0, this.#events.length - 300);
+  }
+  #setState(next) {
+    this.#state = Object.freeze({ ...this.#state.inspection ? { inspection: this.#state.inspection } : {}, ...next, revision: this.#state.revision + 1 });
+    for (const listener of this.#listeners) {
+      try {
+        listener(this.#state);
+      } catch {
+      }
+    }
+    return this.#state;
+  }
+};
+
+// apps/preview/src/server.ts
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { createServer } from "node:http";
+import QRCode from "qrcode";
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "::1", "localhost"]);
+var SESSION_COOKIE_PREFIX = "buddy_preview_session";
+function closeServer(server) {
+  if (!server.listening) return Promise.resolve();
+  return new Promise((resolve2, reject) => {
+    server.close((error) => error ? reject(error) : resolve2());
+  });
+}
+function writeHeaders(response) {
+  response.setHeader("Cache-Control", "no-store");
+  response.setHeader("X-Content-Type-Options", "nosniff");
+  response.setHeader("Referrer-Policy", "no-referrer");
+  response.setHeader("Cross-Origin-Opener-Policy", "same-origin");
+  response.setHeader(
+    "Content-Security-Policy",
+    "default-src 'self'; connect-src 'self'; img-src 'self' data:; script-src 'self'; style-src 'self' 'unsafe-inline'; object-src 'none'; frame-ancestors 'none'; base-uri 'none'; form-action 'self'"
+  );
+}
+function json(response, status, body) {
+  const encoded = JSON.stringify(body);
+  response.statusCode = status;
+  writeHeaders(response);
+  response.setHeader("Content-Type", "application/json; charset=utf-8");
+  response.setHeader("Content-Length", Buffer.byteLength(encoded));
+  response.end(encoded);
+}
+function safeEqual(left, right) {
+  const a = Buffer.from(left);
+  const b = Buffer.from(right);
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+function cookieValue(request, name) {
+  for (const part2 of request.headers.cookie?.split(";") ?? []) {
+    const separator = part2.indexOf("=");
+    if (separator < 0) continue;
+    if (part2.slice(0, separator).trim() === name) return part2.slice(separator + 1).trim();
+  }
+  return void 0;
+}
+function requestUrl(request, origin) {
+  try {
+    return new URL(request.url ?? "/", origin);
+  } catch {
+    return null;
+  }
+}
+function allowedHost(request, port) {
+  const value = request.headers.host;
+  if (!value) return false;
+  try {
+    const parsed = new URL(`http://${value}`);
+    return LOOPBACK_HOSTS.has(parsed.hostname.replace(/^\[|\]$/gu, "")) && Number(parsed.port || 80) === port;
+  } catch {
+    return false;
+  }
+}
+function allowedOrigin(request, origin) {
+  const value = request.headers.origin;
+  return value === void 0 || value === origin.origin;
+}
+function validWidgetRender(value) {
+  return value !== null && /^[a-zA-Z0-9-]{16,64}$/u.test(value);
+}
+function widgetDocument(response, html, render, state = "ready", status = 200) {
+  writeHeaders(response);
+  response.statusCode = status;
+  response.setHeader("Content-Security-Policy", "sandbox allow-scripts; default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src data:; connect-src 'none'; frame-src 'none'; base-uri 'none'; form-action 'none'; frame-ancestors 'self'");
+  response.setHeader("Content-Type", "text/html; charset=utf-8");
+  if (validWidgetRender(render)) {
+    const script = state === "ready" ? readFileSync2(new URL("./resources/widget-document.js", import.meta.url), "utf8").replace("__WIDGET_RENDER__", JSON.stringify(render)) : `window.addEventListener('load',()=>parent.postMessage({channel:'buddy-widget-document',render:${JSON.stringify(render)},state:'error'},'*'),{once:true})`;
+    const signal = `<script>${script}</script>`;
+    if (/<!doctype[^>]*>/iu.test(html)) html = html.replace(/<!doctype[^>]*>/iu, (match) => match + signal);
+    else html = signal + html;
+  }
+  response.end(html);
+}
+function apiError(response, status, code, message2) {
+  json(response, status, { error: { code, message: message2 } });
+}
+async function readJsonBody(request, maximumBytes = 64 * 1024) {
+  const contentType = request.headers["content-type"]?.split(";", 1)[0]?.trim().toLowerCase();
+  if (contentType !== "application/json") {
+    throw Object.assign(new Error("\u9700\u8981 application/json"), { code: "JSON_REQUIRED", status: 415 });
+  }
+  const declared = Number(request.headers["content-length"] ?? 0);
+  if (!Number.isFinite(declared) || declared < 0 || declared > maximumBytes) {
+    throw Object.assign(new Error("\u8BF7\u6C42\u6B63\u6587\u8FC7\u5927"), { code: "BODY_TOO_LARGE", status: 413 });
+  }
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of request) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += buffer.length;
+    if (size > maximumBytes) {
+      throw Object.assign(new Error("\u8BF7\u6C42\u6B63\u6587\u8FC7\u5927"), { code: "BODY_TOO_LARGE", status: 413 });
+    }
+    chunks.push(buffer);
+  }
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    throw Object.assign(new Error("\u8BF7\u6C42\u6B63\u6587\u4E0D\u662F\u6709\u6548 JSON"), { code: "INVALID_JSON", status: 400 });
+  }
+}
+function exactObject(value, keys) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const object3 = value;
+  const expected = new Set(keys);
+  return Object.keys(object3).length === keys.length && Object.keys(object3).every((key) => expected.has(key)) ? object3 : null;
+}
+function safeIdentifier(value, maximumLength = 200) {
+  return typeof value === "string" && value.length > 0 && value.length <= maximumLength && !/[\u0000-\u001f\u007f]/u.test(value);
+}
+function requestFailure(cause) {
+  if (typeof cause === "object" && cause !== null) {
+    const status = "status" in cause && typeof cause.status === "number" && Number.isInteger(cause.status) && cause.status >= 400 && cause.status <= 599 ? cause.status : 502;
+    const code = "code" in cause && safeIdentifier(cause.code, 80) ? cause.code : "SIMULATOR_REQUEST_FAILED";
+    const message2 = "publicMessage" in cause && typeof cause.publicMessage === "string" && cause.publicMessage.length <= 512 && !/[\u0000-\u001f\u007f]/u.test(cause.publicMessage) ? cause.publicMessage : status < 500 && cause instanceof Error ? cause.message : "\u6A21\u62DF\u5668\u8BF7\u6C42\u672A\u80FD\u5B8C\u6210";
+    return { status, code, message: message2 };
+  }
+  return { status: 502, code: "SIMULATOR_REQUEST_FAILED", message: "\u6A21\u62DF\u5668\u8BF7\u6C42\u672A\u80FD\u5B8C\u6210" };
+}
+function publicProject(config) {
+  return {
+    buddyId: config.buddyId
+  };
+}
+async function startPreviewControlServer(options) {
+  const host = options.host ?? "127.0.0.1";
+  const port = options.port ?? 0;
+  if (!LOOPBACK_HOSTS.has(host)) throw new TypeError("Preview control server must bind to loopback");
+  if (!Number.isSafeInteger(port) || port < 0 || port > 65535) throw new TypeError("Preview port must be 0\u201365535");
+  const sessionToken = randomBytes(32).toString("base64url");
+  let bootstrapAvailable = true;
+  let origin;
+  const listeners = /* @__PURE__ */ new Set();
+  let eventRevision = 0;
+  const publish = (event, value) => {
+    eventRevision += 1;
+    const payload = `id: ${eventRevision}
+event: ${event}
+data: ${JSON.stringify(value)}
+
+`;
+    for (const response of listeners) {
+      try {
+        response.write(payload);
+      } catch {
+        listeners.delete(response);
+      }
+    }
+  };
+  const unsubscribeDev = options.controller.subscribe((state) => publish("dev.state", state));
+  const unsubscribeSimulator = options.controller.subscribeSimulator((value) => publish("simulator.state", value));
+  const server = createServer(async (request, response) => {
+    if (!origin) return apiError(response, 503, "PREVIEW_STARTING", "Preview \u6B63\u5728\u542F\u52A8");
+    if (!allowedHost(request, Number(origin.port)) || !allowedOrigin(request, origin)) {
+      return apiError(response, 403, "PREVIEW_ORIGIN_FORBIDDEN", "\u8BF7\u6C42\u6765\u6E90\u4E0D\u53D7\u4FE1\u4EFB");
+    }
+    const sessionCookie = `${SESSION_COOKIE_PREFIX}_${origin.port}`;
+    const url = requestUrl(request, origin);
+    if (!url) return apiError(response, 400, "INVALID_URL", "\u8BF7\u6C42\u5730\u5740\u65E0\u6548");
+    if (request.method === "GET" && bootstrapAvailable && url.pathname === `/bootstrap/${sessionToken}`) {
+      bootstrapAvailable = false;
+      response.statusCode = 303;
+      writeHeaders(response);
+      response.setHeader(
+        "Set-Cookie",
+        `${sessionCookie}=${sessionToken}; HttpOnly; SameSite=Strict; Path=/; Max-Age=43200`
+      );
+      response.setHeader("Location", "/");
+      response.end();
+      return;
+    }
+    const suppliedToken = cookieValue(request, sessionCookie);
+    if (!suppliedToken || !safeEqual(suppliedToken, sessionToken)) {
+      return apiError(response, 401, "PREVIEW_UNAUTHORIZED", "\u672C\u5730\u8C03\u8BD5\u63A5\u53E3\u9700\u8981 CLI \u5185\u90E8\u4F1A\u8BDD");
+    }
+    if (request.method === "GET" && url.pathname === "/api/project") {
+      try {
+        await options.controller.refreshInspection();
+        return json(response, 200, { project: { ...publicProject(await options.controller.project()), inspection: options.controller.state().inspection } });
+      } catch {
+        return apiError(response, 422, "PROJECT_CONFIG_INVALID", "\u9879\u76EE\u914D\u7F6E\u65E0\u6CD5\u8BFB\u53D6\u6216\u6821\u9A8C\u5931\u8D25");
+      }
+    }
+    if (request.method === "GET" && url.pathname === "/api/dev") {
+      await options.controller.refreshInspection();
+      return json(response, 200, { state: options.controller.state() });
+    }
+    if (request.method === "GET" && url.pathname === "/api/buddy") {
+      try {
+        return json(response, 200, { buddy: await options.controller.buddyDetails() });
+      } catch (cause) {
+        const failure = requestFailure(cause);
+        return apiError(response, failure.status, failure.code, failure.message);
+      }
+    }
+    if (request.method === "GET" && url.pathname === "/api/debug") {
+      return json(response, 200, { debug: options.controller.debugSnapshot() });
+    }
+    if (request.method === "GET" && url.pathname === "/api/device/pairing") {
+      const pairing = options.controller.devicePairing();
+      if (pairing.status !== "ready") return json(response, 200, { pairing });
+      const qrCodeDataUrl = await QRCode.toDataURL(pairing.url, {
+        errorCorrectionLevel: "M",
+        margin: 4,
+        width: 256
+      });
+      const current = options.controller.devicePairing();
+      return json(response, 200, { pairing: current.status === "ready" && current.url === pairing.url ? { ...current, qrCodeDataUrl } : current });
+    }
+    if (request.method === "GET" && url.pathname === "/api/simulator/state") {
+      try {
+        return json(response, 200, { state: await options.controller.simulatorState() });
+      } catch (cause) {
+        const failure = requestFailure(cause);
+        return apiError(response, failure.status, failure.code, failure.message);
+      }
+    }
+    const productRoute = /^\/api\/simulator\/products\/([A-Za-z0-9_-]{1,120})(\/mock-purchase)?$/u.exec(url.pathname);
+    if (productRoute) {
+      try {
+        if (request.method === "GET" && !productRoute[2]) return json(response, 200, await options.controller.simulatorProduct(productRoute[1]));
+        if (request.method === "POST" && productRoute[2]) {
+          const body = exactObject(await readJsonBody(request), ["expectedVersion", "idempotencyKey", "conversationRevision"]);
+          if (!body || !Number.isSafeInteger(body.expectedVersion) || Number(body.expectedVersion) < 1 || !Number.isSafeInteger(body.conversationRevision) || !safeIdentifier(body.idempotencyKey, 128))
+            return apiError(response, 400, "INVALID_PURCHASE", "\u8BF7\u91CD\u65B0\u6253\u5F00\u5546\u54C1\u5361\u5E76\u786E\u8BA4\u7248\u672C");
+          return json(response, 200, await options.controller.simulatorProduct(productRoute[1], body));
+        }
+        return apiError(response, 405, "METHOD_NOT_ALLOWED", "\u4E0D\u652F\u6301\u8FD9\u4E2A\u5546\u54C1\u64CD\u4F5C");
+      } catch (cause) {
+        const failure = requestFailure(cause);
+        return apiError(response, failure.status, failure.code, failure.message);
+      }
+    }
+    const widgetRoute = /^\/api\/simulator\/widgets(?:\/([^/]+)(?:\/(image|pin|bridge))?)?$/u.exec(url.pathname);
+    if (widgetRoute) {
+      try {
+        const id = widgetRoute[1] ? decodeURIComponent(widgetRoute[1]) : "";
+        const suffix = widgetRoute[2];
+        if (id && suffix === "bridge" && request.method === "POST") {
+          const body = await readJsonBody(request, 7 * 1024 * 1024);
+          return json(response, 200, await options.controller.simulatorWidgetCommand(id, body));
+        }
+        if (request.method === "GET" && !id) return json(response, 200, await options.controller.simulatorWidgets("list"));
+        if (id && suffix === "pin" && (request.method === "PUT" || request.method === "DELETE")) return json(response, 200, await options.controller.simulatorWidgets(request.method === "PUT" ? "pin" : "unpin", id));
+        if (id && request.method === "GET" && suffix === "image") {
+          const image = await options.controller.simulatorWidgets("image", id, url.searchParams.get("mediaId") ?? "");
+          if (!/^image\/(png|jpeg|webp|gif)(;|$)/u.test(image.contentType)) throw new Error("\u56FE\u7247\u683C\u5F0F\u4E0D\u652F\u6301");
+          writeHeaders(response);
+          response.setHeader("Content-Type", image.contentType);
+          response.end(image.body);
+          return;
+        }
+        if (id && request.method === "GET" && !suffix) {
+          const html = await options.controller.simulatorWidgets("html", id, "", url.searchParams.get("messageId") ?? void 0);
+          widgetDocument(response, html, url.searchParams.get("render"));
+          return;
+        }
+        return apiError(response, 405, "METHOD_NOT_ALLOWED", "\u4E0D\u652F\u6301\u8FD9\u4E2A\u5C0F\u6302\u4EF6\u64CD\u4F5C");
+      } catch (cause) {
+        const failure = requestFailure(cause);
+        const render = url.searchParams.get("render");
+        if (request.method === "GET" && widgetRoute[1] && !widgetRoute[2] && validWidgetRender(render)) {
+          widgetDocument(response, '<!doctype html><html><head><meta charset="utf-8"></head><body>\u5C0F\u6302\u4EF6\u6682\u65F6\u65E0\u6CD5\u6253\u5F00</body></html>', render, "error", failure.status);
+          return;
+        }
+        return apiError(response, failure.status, failure.code, failure.message);
+      }
+    }
+    if (request.method === "GET" && url.pathname === "/api/events") {
+      response.statusCode = 200;
+      writeHeaders(response);
+      response.setHeader("Content-Type", "text/event-stream; charset=utf-8");
+      response.setHeader("Connection", "keep-alive");
+      eventRevision += 1;
+      response.write(`id: ${eventRevision}
+event: dev.state
+data: ${JSON.stringify(options.controller.state())}
+
+`);
+      eventRevision += 1;
+      response.write(`id: ${eventRevision}
+event: simulator.state
+data: ${JSON.stringify({
+        state: options.controller.simulatorSnapshot(),
+        debug: options.controller.debugSnapshot()
+      })}
+
+`);
+      listeners.add(response);
+      request.once("close", () => listeners.delete(response));
+      return;
+    }
+    if (request.method === "POST" && options.controller.resetting) {
+      return apiError(response, 409, "SIMULATOR_BUSY", "\u6B63\u5728\u6E05\u7A7A\u5BF9\u8BDD\u5E76\u91CD\u542F DEV\uFF0C\u8BF7\u7A0D\u5019");
+    }
+    if (request.method === "POST" && url.pathname === "/api/simulator/reset") {
+      try {
+        const body = exactObject(await readJsonBody(request), ["confirm"]);
+        if (body?.confirm !== true) return apiError(response, 400, "RESET_CONFIRMATION_REQUIRED", "\u8BF7\u786E\u8BA4\u6E05\u7A7A\u5F53\u524D\u5F00\u53D1\u7248\u5BF9\u8BDD");
+        const state = await options.controller.resetSimulator();
+        return json(response, 200, { state, dev: options.controller.state(), debug: options.controller.debugSnapshot() });
+      } catch (cause) {
+        const failure = requestFailure(cause);
+        return apiError(response, failure.status, failure.code, failure.message);
+      }
+    }
+    if (request.method === "POST" && url.pathname === "/api/dev/start") {
+      if (Number(request.headers["content-length"] ?? 0) > 0) {
+        return apiError(response, 400, "BODY_NOT_ALLOWED", "\u8BE5\u64CD\u4F5C\u4E0D\u63A5\u53D7\u8BF7\u6C42\u6B63\u6587");
+      }
+      void options.controller.start();
+      return json(response, 202, { state: options.controller.state() });
+    }
+    if (request.method === "POST" && url.pathname === "/api/dev/stop") {
+      if (Number(request.headers["content-length"] ?? 0) > 0) {
+        return apiError(response, 400, "BODY_NOT_ALLOWED", "\u8BE5\u64CD\u4F5C\u4E0D\u63A5\u53D7\u8BF7\u6C42\u6B63\u6587");
+      }
+      try {
+        return json(response, 200, { state: await options.controller.stop() });
+      } catch {
+        return apiError(response, 500, "DEV_STOP_FAILED", "DEV \u4F1A\u8BDD\u672A\u80FD\u5B89\u5168\u505C\u6B62\uFF0C\u8BF7\u68C0\u67E5\u672C\u5730\u8FDB\u7A0B");
+      }
+    }
+    if (request.method === "POST" && url.pathname === "/api/simulator/messages") {
+      try {
+        const body = exactObject(await readJsonBody(request), ["text", "idempotencyKey"]);
+        if (!body || typeof body.text !== "string" || !body.text.trim() || Buffer.byteLength(body.text, "utf8") > 32 * 1024 || !safeIdentifier(body.idempotencyKey, 128)) {
+          return apiError(response, 400, "INVALID_MESSAGE", "\u6D88\u606F\u6216\u5E42\u7B49\u6807\u8BC6\u4E0D\u7B26\u5408\u8981\u6C42");
+        }
+        const accepted = await options.controller.sendSimulatorMessage({
+          text: body.text,
+          idempotencyKey: body.idempotencyKey
+        });
+        return json(response, 202, accepted);
+      } catch (cause) {
+        const failure = requestFailure(cause);
+        return apiError(response, failure.status, failure.code, failure.message);
+      }
+    }
+    const cancelMatch = /^\/api\/simulator\/runs\/([^/]+)\/cancel$/u.exec(url.pathname);
+    if (request.method === "POST" && cancelMatch) {
+      if (Number(request.headers["content-length"] ?? 0) > 0) {
+        return apiError(response, 400, "BODY_NOT_ALLOWED", "\u8BE5\u64CD\u4F5C\u4E0D\u63A5\u53D7\u8BF7\u6C42\u6B63\u6587");
+      }
+      let runId;
+      try {
+        runId = decodeURIComponent(cancelMatch[1]);
+      } catch {
+        return apiError(response, 400, "INVALID_RUN_ID", "Run ID \u4E0D\u7B26\u5408\u8981\u6C42");
+      }
+      if (!safeIdentifier(runId)) return apiError(response, 400, "INVALID_RUN_ID", "Run ID \u4E0D\u7B26\u5408\u8981\u6C42");
+      try {
+        return json(response, 200, await options.controller.cancelSimulatorRun(runId));
+      } catch (cause) {
+        const failure = requestFailure(cause);
+        return apiError(response, failure.status, failure.code, failure.message);
+      }
+    }
+    return apiError(response, 404, "NOT_FOUND", "\u63A5\u53E3\u4E0D\u5B58\u5728");
+  });
+  try {
+    await new Promise((resolve2, reject) => {
+      server.once("error", reject);
+      server.listen(port, host, () => {
+        server.off("error", reject);
+        resolve2();
+      });
+    });
+    const address = server.address();
+    if (!address) throw new Error("Preview server has no address");
+    const urlHost = address.address.includes(":") ? `[${address.address}]` : address.address;
+    origin = new URL(`http://${urlHost}:${address.port}`);
+  } catch (cause) {
+    unsubscribeDev();
+    unsubscribeSimulator();
+    await closeServer(server).catch(() => void 0);
+    throw cause;
+  }
+  const bootstrapUrl = new URL(`/bootstrap/${sessionToken}`, origin);
+  return Object.freeze({
+    origin,
+    bootstrapUrl,
+    async close() {
+      unsubscribeDev();
+      unsubscribeSimulator();
+      for (const response of listeners) response.end();
+      listeners.clear();
+      let controllerFailure;
+      try {
+        await options.controller.close();
+      } catch (cause) {
+        controllerFailure = cause;
+      }
+      await closeServer(server);
+      if (controllerFailure !== void 0) throw controllerFailure;
+    }
+  });
+}
+
+// apps/preview/src/mlb-simulator.ts
+import { createHash as createHash2 } from "node:crypto";
+
+// apps/preview/src/widget-bridge.ts
+import { createHash, randomUUID } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
+function widgetBridgeError(status, message2) {
+  return Object.assign(new Error(message2), { status, publicMessage: message2, code: "WIDGET_BRIDGE_FAILED" });
+}
+function object(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw widgetBridgeError(400, "\u9700\u8981\u6709\u6548\u7684\u64CD\u4F5C\u53C2\u6570");
+  return value;
+}
+function part(value) {
+  if (typeof value !== "string" || !value.trim() || value.length > 64 || /[\s/\\\u0000-\u001f\u007f]/u.test(value) || value === "." || value === "..") throw widgetBridgeError(400, "\u6A21\u5757\u6216\u8BB0\u5F55\u6807\u8BC6\u65E0\u6548");
+  return encodeURIComponent(value);
+}
+function retryable(error) {
+  const status = error?.status;
+  return status === void 0 || status >= 500 || status === 429;
+}
+async function retry(run) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await run();
+    } catch (error) {
+      if (attempt >= 2 || !retryable(error)) throw error;
+      await delay(100 * (attempt + 1));
+    }
+  }
+}
+var WidgetBridge = class {
+  #sessions = /* @__PURE__ */ new Map();
+  #transport;
+  #timer;
+  #disposed = false;
+  constructor(transport) {
+    this.#transport = transport;
+    this.#timer = setInterval(() => {
+      for (const [key, session] of this.#sessions) if (Date.now() - session.touched > 9e4) {
+        this.#sessions.delete(key);
+        void this.#close(session, "page_lost").catch(() => {
+        });
+      }
+    }, 15e3);
+    this.#timer.unref();
+  }
+  async call(widgetId2, conversationId, value) {
+    if (this.#disposed) throw widgetBridgeError(409, "\u8C03\u8BD5\u5DF2\u7ED3\u675F\uFF0C\u8BF7\u91CD\u65B0\u6253\u5F00\u5C0F\u6302\u4EF6");
+    const body = object(value), render = body.render, method = body.method, requestId = body.requestId;
+    if (typeof render !== "string" || !/^[a-zA-Z0-9-]{16,64}$/u.test(render) || typeof requestId !== "string" || !/^[a-zA-Z0-9-]{16,64}$/u.test(requestId) || typeof method !== "string") throw widgetBridgeError(400, "\u5C0F\u6302\u4EF6\u4EA4\u4E92\u6807\u8BC6\u65E0\u6548");
+    part(widgetId2);
+    let session = this.#sessions.get(render);
+    if (session && (session.widgetId !== widgetId2 || session.conversationId !== conversationId)) throw widgetBridgeError(409, "\u5C0F\u6302\u4EF6\u4F1A\u8BDD\u5DF2\u5207\u6362\uFF0C\u8BF7\u91CD\u65B0\u6253\u5F00");
+    if (method === "open") {
+      if (session?.closed) throw widgetBridgeError(409, "\u5C0F\u6302\u4EF6\u5DF2\u5173\u95ED\uFF0C\u8BF7\u91CD\u65B0\u6253\u5F00");
+      if (!session) {
+        if (this.#sessions.size >= 32) throw widgetBridgeError(429, "\u6253\u5F00\u7684\u5C0F\u6302\u4EF6\u8FC7\u591A\uFF0C\u8BF7\u5173\u95ED\u540E\u91CD\u8BD5");
+        session = {
+          widgetId: widgetId2,
+          conversationId,
+          interactionId: `wi_${randomUUID()}`,
+          deviceId: `preview_${randomUUID()}`,
+          sequence: 0,
+          touched: Date.now(),
+          closed: false,
+          pending: 0,
+          tail: Promise.resolve(),
+          calls: /* @__PURE__ */ new Map()
+        };
+        this.#sessions.set(render, session);
+        session.tail = this.#transport.request("GET", `/app/widgets/${encodeURIComponent(widgetId2)}/metadata?conversationId=${encodeURIComponent(conversationId)}`).catch((error) => {
+          session.closed = true;
+          throw error;
+        });
+        void session.tail.catch(() => {
+        });
+      }
+      await session.tail;
+      if (this.#disposed || session.closed) throw widgetBridgeError(409, "\u8C03\u8BD5\u5DF2\u7ED3\u675F\uFF0C\u8BF7\u91CD\u65B0\u6253\u5F00\u5C0F\u6302\u4EF6");
+      return { ready: true };
+    }
+    if (!session) throw widgetBridgeError(409, "\u5C0F\u6302\u4EF6\u8FDE\u63A5\u5DF2\u5931\u6548\uFF0C\u8BF7\u5173\u95ED\u540E\u91CD\u65B0\u6253\u5F00");
+    session.touched = Date.now();
+    const serialized = JSON.stringify([method, body.params ?? {}]);
+    if (method !== "media.upload" && Buffer.byteLength(serialized) > 300 * 1024) throw widgetBridgeError(413, "\u64CD\u4F5C\u53C2\u6570\u8FC7\u5927");
+    const signature = createHash("sha256").update(serialized).digest("hex");
+    const previous = session.calls.get(requestId);
+    if (previous) {
+      if (previous.signature !== signature) throw widgetBridgeError(409, "\u4E0D\u80FD\u4F7F\u7528\u540C\u4E00\u8BF7\u6C42\u6807\u8BC6\u6267\u884C\u4E0D\u540C\u64CD\u4F5C");
+      return previous.result;
+    }
+    if (method === "close") return this.#close(session, "user_closed");
+    if (session.closed) throw widgetBridgeError(409, "\u5C0F\u6302\u4EF6\u5DF2\u5173\u95ED\uFF0C\u8BF7\u91CD\u65B0\u6253\u5F00");
+    if (session.calls.size >= 256) throw widgetBridgeError(429, "\u672C\u6B21\u7F16\u8F91\u64CD\u4F5C\u8F83\u591A\uFF0C\u8BF7\u5173\u95ED\u540E\u91CD\u65B0\u6253\u5F00");
+    if (session.pending >= 16) throw widgetBridgeError(429, "\u64CD\u4F5C\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7\u7B49\u5F85\u5F53\u524D\u4FDD\u5B58\u5B8C\u6210");
+    const current = session;
+    current.pending++;
+    const result = current.tail.then(() => {
+      if (current.closed || this.#disposed) throw widgetBridgeError(409, "\u5C0F\u6302\u4EF6\u5DF2\u5173\u95ED\uFF0C\u8BF7\u91CD\u65B0\u6253\u5F00");
+      return this.#perform(current, method, object(body.params ?? {}), requestId);
+    });
+    current.tail = result.then(() => {
+      current.pending--;
+    }, () => {
+      current.pending--;
+    });
+    if (["records.create", "records.update", "records.delete", "media.upload"].includes(method)) current.calls.set(requestId, { signature, result });
+    return result;
+  }
+  async #perform(s, method, p, requestId) {
+    const base = `/app/widgets/${encodeURIComponent(s.widgetId)}`;
+    if (method === "heartbeat" || method === "resume") {
+      if (!s.sequence) return { active: true };
+      return this.#transport.command(`widget.interaction.${method}`, { interactionId: s.interactionId, widgetId: s.widgetId, lastAckedSequence: s.sequence });
+    }
+    if (method === "media.url") {
+      if (typeof p.mediaId !== "string" || !/^media_[A-Za-z0-9_-]+$/u.test(p.mediaId)) throw widgetBridgeError(400, "\u56FE\u7247\u6807\u8BC6\u65E0\u6548");
+      const image = await this.#transport.image(s.widgetId, p.mediaId);
+      if (!/^image\/(png|jpeg|webp|gif)(?:;|$)/u.test(image.contentType)) throw widgetBridgeError(415, "\u56FE\u7247\u683C\u5F0F\u4E0D\u652F\u6301");
+      return { url: `data:${image.contentType.split(";")[0]};base64,${Buffer.from(image.body).toString("base64")}` };
+    }
+    if (method === "media.upload") {
+      if (typeof p.mimeType !== "string" || !["image/png", "image/jpeg", "image/webp"].includes(p.mimeType) || typeof p.base64 !== "string" || p.base64.length > 7 * 1024 * 1024 || !/^[A-Za-z0-9+/]+={0,2}$/u.test(p.base64)) throw widgetBridgeError(400, "\u8BF7\u9009\u62E9 JPEG\u3001PNG \u6216 WebP \u56FE\u7247");
+      const bytes = Buffer.from(p.base64, "base64");
+      if (bytes.length > 5 * 1024 * 1024 || !bytes.length) throw widgetBridgeError(413, "\u56FE\u7247\u4E0D\u80FD\u8D85\u8FC7 5 MiB");
+      const result = object(await this.#transport.upload(s.conversationId, p.mimeType, bytes));
+      return { mediaId: result.mediaId, width: result.width, height: result.height, mimeType: result.mimeType, size: result.size };
+    }
+    if (!/^records\.(list|get|create|update|delete)$/u.test(method)) throw widgetBridgeError(400, "\u9875\u9762\u8BF7\u6C42\u4E86\u672A\u5F00\u653E\u7684\u80FD\u529B");
+    const path = `${base}/modules/${part(p.module)}/records`;
+    if (method === "records.list" || method === "records.get") {
+      return this.#transport.request("GET", `${path}${method === "records.get" ? `/${part(p.recordId)}` : ""}?conversationId=${encodeURIComponent(s.conversationId)}`);
+    }
+    if (s.uncertain) throw widgetBridgeError(409, "\u4E0A\u6B21\u4FDD\u5B58\u7ED3\u679C\u5C1A\u672A\u786E\u8BA4\uFF0C\u8BF7\u5173\u95ED\u540E\u91CD\u65B0\u6253\u5F00\u5E76\u6838\u5BF9\u6570\u636E");
+    const action = method.slice(8);
+    const mutation = { conversationId: s.conversationId };
+    if (action !== "delete") mutation.data = object(p.data);
+    if (p.expectedRevision !== void 0) {
+      if (!Number.isSafeInteger(p.expectedRevision) || p.expectedRevision < 0) throw widgetBridgeError(400, "\u8BB0\u5F55\u7248\u672C\u53F7\u65E0\u6548");
+      mutation.expectedRevision = p.expectedRevision;
+    }
+    if (Buffer.byteLength(JSON.stringify(mutation)) > 290 * 1024) throw widgetBridgeError(413, "\u8BB0\u5F55\u5185\u5BB9\u8FC7\u5927");
+    const target = action === "create" ? path : `${path}/${part(p.recordId)}`;
+    const sequence = s.sequence + 1;
+    const headers = {
+      "X-Widget-Interaction-Id": s.interactionId,
+      "X-Widget-Operation-Id": `op_${requestId}`,
+      "X-Widget-Sequence": String(sequence),
+      "X-Widget-Entry-Point": "conversation_detail",
+      "X-Device-Id": s.deviceId
+    };
+    try {
+      const result = await retry(() => this.#transport.request(action === "create" ? "POST" : action === "update" ? "PUT" : "DELETE", target, mutation, headers));
+      s.sequence = sequence;
+      return result;
+    } catch (error) {
+      if (retryable(error)) s.uncertain = requestId;
+      throw error;
+    }
+  }
+  async #close(s, reason) {
+    if (s.closed) return s.tail;
+    s.closed = true;
+    const pending = s.tail;
+    const closing = pending.catch(() => {
+    }).then(() => retry(() => this.#transport.request(
+      "POST",
+      `/app/widgets/${encodeURIComponent(s.widgetId)}/interactions/${s.interactionId}/close`,
+      { conversationId: s.conversationId, lastIssuedSequence: s.sequence + (s.uncertain ? 1 : 0), closeReason: reason }
+    )));
+    s.tail = closing;
+    void closing.catch(() => {
+    });
+    return closing;
+  }
+  async closeAll() {
+    const sessions = [...this.#sessions.values()];
+    this.#sessions.clear();
+    await Promise.allSettled(sessions.map((s) => this.#close(s, "preview_stopped")));
+  }
+  async dispose() {
+    this.#disposed = true;
+    clearInterval(this.#timer);
+    await this.closeAll();
+  }
+};
+
+// apps/preview/src/mlb-simulator.ts
+import { normalizePlatformUrl } from "./core.js";
+
+// apps/preview/src/mlb-events.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { WebSocket } from "ws";
+var MlbEventStreamError = class extends Error {
+  constructor(message2, status = 502, retryable2 = true) {
+    super(message2);
+    this.status = status;
+    this.retryable = retryable2;
+    this.publicMessage = message2;
+  }
+  status;
+  retryable;
+  code = "MLB_EVENT_STREAM_FAILED";
+  publicMessage;
+};
+var MlbAppCommandError = class extends Error {
+  constructor(message2, status = 502) {
+    super(message2);
+    this.status = status;
+    this.publicMessage = message2;
+  }
+  status;
+  code = "MLB_REQUEST_FAILED";
+  publicMessage;
+};
+function appSocket(url, token) {
+  return new WebSocket(url, {
+    headers: { Authorization: `Bearer ${token}` },
+    followRedirects: false,
+    handshakeTimeout: 1e4,
+    maxPayload: 64 * 1024,
+    perMessageDeflate: false
+  });
+}
+async function mlbAppCommand(url, token, method, params, options = {}) {
+  if (options.signal?.aborted) throw options.signal.reason;
+  const requestId = randomUUID2();
+  const socket = appSocket(url, token);
+  return await new Promise((resolve2, reject) => {
+    let settled = false;
+    let ready = false;
+    let sent = false;
+    const cleanup = () => {
+      clearTimeout(timer);
+      options.signal?.removeEventListener("abort", abort);
+      if (socket.readyState !== WebSocket.CLOSED) socket.terminate();
+    };
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve2(value);
+    };
+    const fail = (cause) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(cause);
+    };
+    const abort = () => fail(options.signal?.reason);
+    const timer = setTimeout(() => fail(new MlbAppCommandError("MLB WebSocket \u547D\u4EE4\u7B49\u5F85\u8D85\u65F6")), 3e4);
+    timer.unref();
+    options.signal?.addEventListener("abort", abort, { once: true });
+    socket.on("error", () => fail(new MlbAppCommandError("\u65E0\u6CD5\u8FDE\u63A5 MLB WebSocket")));
+    socket.on("unexpected-response", (_request, response) => {
+      const status = response.statusCode ?? 502;
+      fail(new MlbAppCommandError(
+        status === 401 ? "MLB \u767B\u5F55\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55\u540E\u91CD\u542F DEV" : `MLB WebSocket \u63E1\u624B\u5931\u8D25\uFF08HTTP ${status}\uFF09`,
+        status
+      ));
+      response.destroy();
+    });
+    socket.on("close", (code) => fail(code === 4401 ? new MlbAppCommandError("MLB \u767B\u5F55\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55\u540E\u91CD\u542F DEV", 401) : new MlbAppCommandError("MLB WebSocket \u8FDE\u63A5\u4E2D\u65AD")));
+    socket.on("message", (raw, binary) => {
+      if (settled) return;
+      try {
+        if (binary) throw new Error("binary");
+        const bytes = Array.isArray(raw) ? Buffer.concat(raw) : Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
+        const frame = JSON.parse(bytes.toString("utf8"));
+        const data = frame.data;
+        if (!frame || frame.v !== 1 || !data || typeof data !== "object" || Array.isArray(data)) {
+          throw new Error("envelope");
+        }
+        if (frame.type === "event") {
+          if (!ready) {
+            if (frame.event !== "ready" || data.resync !== true || typeof data.connectionId !== "string" || !data.connectionId) throw new Error("ready required");
+            ready = true;
+            if (!sent) {
+              sent = true;
+              socket.send(JSON.stringify({ v: 1, type: "request", requestId, method, params }));
+            }
+          }
+          return;
+        }
+        if (frame.type !== "response" || !ready || frame.requestId !== requestId || !Number.isSafeInteger(frame.status) || frame.status < 100 || frame.status > 599) {
+          throw new Error("response");
+        }
+        const status = frame.status;
+        if (status >= 200 && status < 300) {
+          finish(data);
+          return;
+        }
+        const serverMessage = data.error;
+        fail(new MlbAppCommandError(
+          typeof serverMessage === "string" && serverMessage.trim() ? serverMessage.slice(0, 512) : status >= 500 ? "MLB Server \u6682\u65F6\u4E0D\u53EF\u7528" : "\u6A21\u62DF\u5668\u8BF7\u6C42\u672A\u80FD\u5B8C\u6210",
+          status
+        ));
+      } catch {
+        fail(new MlbAppCommandError("MLB WebSocket \u8FD4\u56DE\u4E86\u65E0\u6548\u547D\u4EE4\u56DE\u6267"));
+      }
+    });
+    if (options.signal?.aborted) abort();
+  });
+}
+async function* mlbAppEvents(url, token, options = {}) {
+  if (options.signal?.aborted) return;
+  const socket = appSocket(url, token);
+  const queue = [];
+  let queuedBytes = 0;
+  let ready = false;
+  let ended = false;
+  let failure;
+  let wake;
+  const finish = (cause) => {
+    if (ended) return;
+    ended = true;
+    failure = cause;
+    wake?.();
+  };
+  let timer = setTimeout(() => finish(new MlbEventStreamError("MLB WebSocket \u672A\u5B8C\u6210\u521D\u59CB\u5316")), 1e4);
+  timer.unref();
+  const heartbeat = () => {
+    if (!ready || ended) return;
+    clearTimeout(timer);
+    timer = setTimeout(() => finish(new MlbEventStreamError("MLB WebSocket \u5FC3\u8DF3\u4E2D\u65AD")), 6e4);
+    timer.unref();
+  };
+  const abort = () => finish();
+  socket.on("ping", heartbeat);
+  socket.on("error", () => finish(new MlbEventStreamError("\u65E0\u6CD5\u8FDE\u63A5 MLB WebSocket")));
+  socket.on("unexpected-response", (_request, response) => {
+    const status = response.statusCode ?? 502;
+    finish(new MlbEventStreamError(
+      status === 401 ? "MLB \u767B\u5F55\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55\u540E\u91CD\u542F DEV" : `MLB WebSocket \u63E1\u624B\u5931\u8D25\uFF08HTTP ${status}\uFF09`,
+      status,
+      status >= 500 || status === 429
+    ));
+    response.destroy();
+  });
+  socket.on("close", (code) => finish(code === 4401 ? new MlbEventStreamError("MLB \u767B\u5F55\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55\u540E\u91CD\u542F DEV", 401, false) : new MlbEventStreamError("MLB WebSocket \u8FDE\u63A5\u4E2D\u65AD", 502, ![1002, 1003, 1007, 1008, 1009].includes(code))));
+  socket.on("message", (raw, binary) => {
+    if (ended) return;
+    try {
+      if (binary) throw new Error("binary");
+      const bytes = Array.isArray(raw) ? Buffer.concat(raw) : Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
+      const frame = JSON.parse(bytes.toString("utf8"));
+      if (!frame || frame.v !== 1 || frame.type !== "event" || typeof frame.event !== "string" || !frame.data || typeof frame.data !== "object" || Array.isArray(frame.data)) throw new Error("envelope");
+      if (!ready && frame.event !== "ready") throw new Error("ready required");
+      if (frame.event === "ready" && (frame.data.resync !== true || typeof frame.data.connectionId !== "string" || !frame.data.connectionId)) throw new Error("invalid ready");
+      ready = true;
+      heartbeat();
+      queuedBytes += bytes.byteLength;
+      if (queuedBytes > 1024 * 1024 || queue.length >= 1024) {
+        finish(new MlbEventStreamError("MLB \u4E8B\u4EF6\u63A5\u6536\u79EF\u538B\uFF0C\u6B63\u5728\u91CD\u65B0\u540C\u6B65"));
+        return;
+      }
+      queue.push({ frame: { event: frame.event, data: frame.data }, bytes: bytes.byteLength });
+      wake?.();
+    } catch {
+      finish(new MlbEventStreamError("MLB WebSocket \u8FD4\u56DE\u4E86\u65E0\u6548\u4E8B\u4EF6", 502, false));
+    }
+  });
+  options.signal?.addEventListener("abort", abort, { once: true });
+  if (options.signal?.aborted) abort();
+  try {
+    while (!ended) {
+      const item = queue.shift();
+      if (item) {
+        queuedBytes -= item.bytes;
+        yield item.frame;
+      } else {
+        await new Promise((resolve2) => {
+          wake = resolve2;
+        });
+        wake = void 0;
+      }
+    }
+    if (failure && !options.signal?.aborted) throw failure;
+  } finally {
+    ended = true;
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", abort);
+    if (socket.readyState !== WebSocket.CLOSED) socket.terminate();
+  }
+}
+
+// apps/preview/src/buddy-details.ts
+function invalid() {
+  throw Object.assign(new Error("MLB \u8FD4\u56DE\u7684\u5F00\u53D1\u7248\u642D\u5B50\u8BE6\u60C5\u4E0D\u7B26\u5408\u63A5\u53E3\u7EA6\u5B9A"), {
+    code: "BUDDY_DETAILS_INVALID",
+    status: 502,
+    publicMessage: "MLB \u8FD4\u56DE\u7684\u5F00\u53D1\u7248\u642D\u5B50\u8BE6\u60C5\u4E0D\u7B26\u5408\u63A5\u53E3\u7EA6\u5B9A"
+  });
+}
+function record(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return invalid();
+  return value;
+}
+function text(value, multiline = false) {
+  if (typeof value !== "string" || Buffer.byteLength(value) > 32 * 1024 || (multiline ? /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u : /[\u0000-\u001f\u007f]/u).test(value)) return invalid();
+  return value;
+}
+function nullableText(value, multiline = false) {
+  return value === null ? null : text(value, multiline);
+}
+function parsePreviewBuddyDetails(value, expectedId) {
+  const source = record(value);
+  if (source.id !== expectedId || source.isDev !== true || typeof source.name !== "string" || !source.name.trim() || source.privateId !== null && (typeof source.privateId !== "string" || !/^p_[a-zA-Z0-9_-]{1,253}$/u.test(source.privateId)) || !Number.isSafeInteger(source.addedCount) || source.addedCount < 0) return invalid();
+  return Object.freeze({
+    id: expectedId,
+    isDev: true,
+    name: text(source.name),
+    avatar: nullableText(source.avatar),
+    tagline: nullableText(source.tagline),
+    intro: nullableText(source.intro, true),
+    creatorUserId: nullableText(source.creatorUserId),
+    creatorUserName: nullableText(source.creatorUserName),
+    creatorUserAvatar: nullableText(source.creatorUserAvatar),
+    privateId: source.privateId,
+    addedCount: source.addedCount
+  });
+}
+
+// apps/preview/src/mlb-simulator.ts
+function safeText(value, name, maximum = 4096) {
+  if (typeof value !== "string" || !value.trim() || value.length > maximum || /[\u0000-\u001f\u007f]/u.test(value)) {
+    throw new TypeError(`${name} is invalid`);
+  }
+  return value;
+}
+function endpoint(base, path) {
+  return new URL(path.replace(/^\//u, ""), base);
+}
+function object2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function httpError(status, value) {
+  const serverMessage = object2(object2(value)?.error)?.message ?? object2(value)?.error;
+  const message2 = typeof serverMessage === "string" && serverMessage.trim() ? serverMessage.slice(0, 512) : status >= 500 ? "MLB Server \u6682\u65F6\u4E0D\u53EF\u7528" : "\u6A21\u62DF\u5668\u8BF7\u6C42\u672A\u80FD\u5B8C\u6210";
+  return Object.assign(new Error(message2), {
+    code: typeof object2(object2(value)?.error)?.code === "string" ? object2(object2(value)?.error).code : "MLB_REQUEST_FAILED",
+    status,
+    publicMessage: message2
+  });
+}
+function message(value, index) {
+  const input = object2(value);
+  if (!input || typeof input.author !== "string") return null;
+  const role = input.author === "buddy" ? "assistant" : input.author === "user" || input.author === "owner" ? "user" : void 0;
+  if (!role) return null;
+  const messageId = safeText(input.id, `messages[${index}].id`, 256);
+  let text2 = ["widget", "product"].includes(String(input.type)) && input.text === void 0 ? "" : input.text;
+  if (typeof text2 !== "string" || Buffer.byteLength(text2, "utf8") > 48 * 1024) {
+    throw new Error(`messages[${index}].text is invalid`);
+  }
+  if (input.type === "tool" && !text2.trim()) return null;
+  if (typeof input.timestamp !== "number" || !Number.isFinite(input.timestamp)) {
+    throw new Error(`messages[${index}].timestamp is invalid`);
+  }
+  if (role === "assistant" && input.type === "question") {
+    const options = object2(input.question)?.options;
+    if (!Array.isArray(options) || options.length < 2 || options.length > 4 || options.some((option) => typeof option !== "string" || !option.trim() || option.length > 30)) {
+      throw new Error(`messages[${index}].question is invalid`);
+    }
+    text2 += `
+
+${options.map((option, i) => `${i + 1}. ${option}`).join("\n")}
+
+\u8BF7\u76F4\u63A5\u56DE\u590D\u4F60\u7684\u9009\u62E9\uFF0C\u4E5F\u53EF\u4EE5\u8865\u5145\u8BF4\u660E\u3002`;
+  }
+  if (role === "assistant" && input.type === "permissionRequest") {
+    const request = object2(input.permissionRequest);
+    text2 += request?.status === "pending" ? "\n\n\u8BF7\u5728\u642D\u642D App \u4E2D\u5904\u7406\u8FD9\u5F20\u6388\u6743\u5361\uFF1B\u6D4F\u89C8\u5668\u9884\u89C8\u4E0D\u4EE3\u66FF\u7CFB\u7EDF\u6388\u6743\u3002" : "\n\n\u6388\u6743\u5361\u7684\u5904\u7406\u7ED3\u679C\u8BF7\u4EE5\u642D\u642D App \u4E2D\u7684\u72B6\u6001\u4E3A\u51C6\u3002";
+  }
+  return Object.freeze({
+    messageId,
+    role,
+    text: text2,
+    createdAt: new Date(input.timestamp).toISOString(),
+    ...input.type === "widget" && object2(input.widget) ? { widget: parseWidget(input.widget) } : {},
+    ...input.type === "product" && role === "assistant" ? { product: parseProduct(input.product) } : {}
+  });
+}
+function parseProduct(value) {
+  const product = object2(value);
+  if (!product || !Number.isSafeInteger(product.version) || Number(product.version) < 1) throw new TypeError("\u5546\u54C1\u5361\u7248\u672C\u65E0\u6548");
+  return Object.freeze({
+    offerId: safeText(product.offerId, "offerId", 120),
+    productId: safeText(product.productId, "productId", 120),
+    version: Number(product.version),
+    title: safeText(product.title, "\u5546\u54C1\u540D\u79F0", 512),
+    summary: typeof product.summary === "string" ? product.summary.slice(0, 4096) : "",
+    buttonText: typeof product.buttonText === "string" && product.buttonText.trim() ? product.buttonText.slice(0, 100) : "\u67E5\u770B\u65B9\u6848"
+  });
+}
+function widgetId(value) {
+  const id = safeText(value, "widgetId", 64);
+  if (/[\s/\\]/u.test(id) || id === "." || id === "..") throw new TypeError("widgetId is invalid");
+  return id;
+}
+function parseWidget(value) {
+  const item = object2(value);
+  const openTarget = parseOpenTarget(item?.openTarget);
+  return Object.freeze({
+    id: widgetId(item?.id),
+    title: typeof item?.title === "string" && item.title.trim() ? item.title : "\u5C0F\u6302\u4EF6",
+    ...typeof item?.type === "string" ? { type: item.type } : {},
+    ...typeof item?.summary === "string" ? { summary: item.summary } : {},
+    ...typeof item?.imageMediaId === "string" && /^media_[a-zA-Z0-9_-]+$/u.test(item.imageMediaId) ? { imageMediaId: item.imageMediaId } : {},
+    ...typeof item?.isPinned === "boolean" ? { isPinned: item.isPinned } : {},
+    ...typeof item?.creatorName === "string" ? { creatorName: item.creatorName } : {},
+    ...item?.role === "owner" || item?.role === "editor" || item?.role === "viewer" ? { role: item.role } : {},
+    ...openTarget ? { openTarget } : {}
+  });
+}
+function parseOpenTarget(value) {
+  if (value === void 0) return void 0;
+  const target = object2(value), resource = object2(target?.resource);
+  const name = (input) => typeof input === "string" && /^[^\s/\u0000-\u001f\u007f]{1,64}$/u.test(input);
+  if (!target || target.version !== 1 || !name(target.entry) || target.resource !== void 0 && (!resource || !name(resource.module) || !name(resource.recordId)) || target.state !== void 0 && !object2(target.state)) throw new TypeError("Widget \u6253\u5F00\u76EE\u6807\u683C\u5F0F\u65E0\u6548");
+  const normalized = {
+    version: 1,
+    entry: target.entry,
+    ...resource ? { resource: { module: resource.module, recordId: resource.recordId } } : {},
+    ...target.state !== void 0 ? { state: object2(target.state) } : {}
+  };
+  if (Buffer.byteLength(JSON.stringify(normalized), "utf8") > 8 * 1024) throw new TypeError("Widget \u6253\u5F00\u76EE\u6807\u8D85\u8FC7 8 KiB");
+  return Object.freeze(normalized);
+}
+function localReceipt(prefix, value) {
+  return `${prefix}-${createHash2("sha256").update(value).digest("hex").slice(0, 20)}`;
+}
+function waitForRetry(milliseconds, signal) {
+  if (signal?.aborted) return Promise.reject(signal.reason);
+  return new Promise((resolve2, reject) => {
+    const abort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason);
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", abort);
+      resolve2();
+    }, milliseconds);
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+var MlbSimulatorClient = class {
+  #baseUrl;
+  #buddyId;
+  #accessToken;
+  #fetch;
+  #widgetBridge;
+  #sending = false;
+  #resetTarget;
+  #resetArchived = false;
+  #lastSend;
+  #privateId;
+  #privatePromise;
+  #active;
+  #latest;
+  #streaming;
+  #messages = Object.freeze([]);
+  constructor(options) {
+    this.#baseUrl = normalizePlatformUrl(options.baseUrl);
+    this.#buddyId = safeText(options.buddyId, "buddyId", 256);
+    if (!this.#buddyId.endsWith("-dev")) {
+      throw new TypeError("MLB simulator buddyId must use the -dev identity");
+    }
+    this.#accessToken = safeText(options.auth.developerAccessToken, "developerAccessToken", 16384);
+    this.#fetch = options.fetch ?? globalThis.fetch;
+    if (typeof this.#fetch !== "function") throw new TypeError("A Fetch API implementation is required");
+    this.#widgetBridge = new WidgetBridge({
+      request: (method, path, body, headers) => this.#request(method, path, { body, headers }),
+      command: (method, params) => {
+        const url = endpoint(this.#baseUrl, "/app/ws");
+        url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+        return mlbAppCommand(url, this.#accessToken, method, params);
+      },
+      image: (id, mediaId) => this.widgetImage(id, mediaId),
+      upload: async (conversationId, mime, bytes) => {
+        const response = await this.#fetch(endpoint(this.#baseUrl, `/app/media/uploads?conversationId=${encodeURIComponent(conversationId)}`), {
+          method: "POST",
+          headers: { Authorization: `Bearer ${this.#accessToken}`, "Content-Type": mime },
+          body: new Uint8Array(bytes),
+          redirect: "error",
+          credentials: "omit",
+          signal: AbortSignal.timeout(25e3)
+        });
+        const value = await response.json().catch(() => void 0);
+        if (!response.ok) throw httpError(response.status, value);
+        return value;
+      }
+    });
+  }
+  /** Reading a profile must not add the Buddy or trigger a welcome message. */
+  async details(options = {}) {
+    const signal = AbortSignal.any([AbortSignal.timeout(3e4), ...options.signal ? [options.signal] : []]);
+    const details = parsePreviewBuddyDetails(await this.#request("GET", `/app/buddies/${encodeURIComponent(this.#buddyId)}`, { signal }), this.#buddyId);
+    this.#privateId = details.privateId ?? void 0;
+    if (!details.avatar) return details;
+    let avatarPreview = null;
+    try {
+      const url = new URL(details.avatar, this.#baseUrl);
+      if (url.origin !== this.#baseUrl.origin || url.username || url.password || !url.pathname.startsWith("/media/")) throw new Error("Unsupported avatar URL");
+      const image = await this.#widgetResource(url.href, false);
+      const contentType = image.contentType.split(";", 1)[0].trim().toLowerCase();
+      if (!["image/png", "image/jpeg", "image/webp"].includes(contentType)) throw new Error("Unsupported avatar type");
+      avatarPreview = `data:${contentType};base64,${Buffer.from(image.body).toString("base64")}`;
+    } catch {
+    }
+    return Object.freeze({ ...details, avatarPreview });
+  }
+  async productOffer(offerId) {
+    this.#assertResetComplete();
+    const detail = object2(await this.#request("GET", `/app/product-offers/${encodeURIComponent(safeText(offerId, "offerId", 120))}`, {}));
+    if (detail?.buddyId !== this.#buddyId || detail?.offerId !== offerId || detail.paymentChannel !== "mock" || detail.chargedAmountMinor !== 0)
+      throw httpError(409, { error: "\u4EC5\u652F\u6301\u5F53\u524D DEV \u642D\u5B50\u7684\u96F6\u6263\u8D39\u6A21\u62DF\u8D2D\u4E70" });
+    return detail;
+  }
+  async purchaseProduct(offerId, input) {
+    await this.productOffer(offerId);
+    return this.#request("POST", `/app/product-offers/${encodeURIComponent(offerId)}/mock-purchase`, { body: { expectedVersion: input.expectedVersion, idempotencyKey: safeText(input.idempotencyKey, "\u5E42\u7B49\u952E", 128) } });
+  }
+  async widgets() {
+    this.#assertResetComplete();
+    const id = await this.#ensurePrivate();
+    const body = object2(await this.#request("GET", `/app/privates/${encodeURIComponent(id)}/widgets`, {}));
+    if (!Array.isArray(body?.widgets)) throw httpError(502, { error: "\u65E0\u6CD5\u8BFB\u53D6\u4F1A\u8BDD\u5C0F\u6302\u4EF6" });
+    return body.widgets.map(parseWidget).filter((item) => item.type !== void 0);
+  }
+  async widgetHtml(id, openTarget) {
+    this.#assertResetComplete();
+    const target = parseOpenTarget(openTarget);
+    const privateId = await this.#ensurePrivate();
+    const result = await this.#widgetResource(`/app/widgets/${encodeURIComponent(widgetId(id))}/presentation`, true, {
+      method: "POST",
+      body: JSON.stringify({ conversationId: privateId, ...target ? { openTarget: target } : {} })
+    });
+    return new TextDecoder("utf-8", { fatal: true }).decode(result.body);
+  }
+  async pinWidget(id, pinned) {
+    this.#assertResetComplete();
+    const privateId = await this.#ensurePrivate();
+    await this.#request(pinned ? "PUT" : "DELETE", `/app/widgets/${encodeURIComponent(widgetId(id))}/pin`, { ...pinned ? { body: { sourceConversationId: privateId } } : {} });
+  }
+  async widgetCommand(id, body) {
+    this.#assertResetComplete();
+    return this.#widgetBridge.call(widgetId(id), await this.#ensurePrivate(), body);
+  }
+  async disposeWidgets() {
+    await this.#widgetBridge.dispose();
+  }
+  async resetWidgets() {
+    await this.#widgetBridge.closeAll();
+  }
+  async widgetImage(id, mediaId) {
+    this.#assertResetComplete();
+    if (!/^media_[a-zA-Z0-9_-]+$/u.test(mediaId)) throw new TypeError("Invalid media ID");
+    const access = object2(await this.#request("GET", `/app/media/${encodeURIComponent(mediaId)}?widgetId=${encodeURIComponent(widgetId(id))}`, {}));
+    const url = new URL(String(access?.url));
+    if (url.protocol !== "https:" || url.username || url.password || access?.mediaId !== mediaId || typeof access.expiresAt !== "number" || access.expiresAt <= Date.now()) throw new Error("\u56FE\u7247\u94FE\u63A5\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u8BD5");
+    return this.#widgetResource(url.href, false);
+  }
+  async #widgetResource(path, authenticated = true, init = {}) {
+    const response = await this.#fetch(authenticated ? endpoint(this.#baseUrl, path) : new URL(path), { ...init, headers: {
+      ...authenticated ? { Authorization: `Bearer ${this.#accessToken}` } : {},
+      ...init.body ? { "Content-Type": "application/json" } : {}
+    }, credentials: "omit", redirect: "error", signal: AbortSignal.timeout(15e3) });
+    if (!response.ok) throw httpError(response.status, { error: response.status === 403 || response.status === 404 ? "\u5C0F\u6302\u4EF6\u5DF2\u5220\u9664\u3001\u9875\u9762\u672A\u4E0A\u4F20\uFF0C\u6216\u4F60\u5DF2\u4E0D\u5728\u8FD9\u4E2A\u4F1A\u8BDD\u4E2D\u3002" : "\u5C0F\u6302\u4EF6\u6682\u65F6\u65E0\u6CD5\u6253\u5F00\uFF0C\u8BF7\u91CD\u65B0\u52A0\u8F7D\u3002" });
+    const reader = response.body?.getReader();
+    if (!reader) throw new Error("\u5C0F\u6302\u4EF6\u5185\u5BB9\u4E3A\u7A7A");
+    const chunks = [];
+    let size = 0;
+    try {
+      while (true) {
+        const part2 = await reader.read();
+        if (part2.done) break;
+        size += part2.value.byteLength;
+        if (size > 4 * 1024 * 1024) throw new Error("\u5C0F\u6302\u4EF6\u5185\u5BB9\u8FC7\u5927\uFF0C\u6682\u65F6\u65E0\u6CD5\u6253\u5F00");
+        chunks.push(part2.value);
+      }
+    } finally {
+      await reader.cancel();
+    }
+    return { body: Buffer.concat(chunks), contentType: response.headers.get("content-type") ?? "text/html" };
+  }
+  async state(options = {}) {
+    this.#assertResetComplete();
+    const privateId = await this.#ensurePrivate(options.signal);
+    const value = await this.#request("GET", `/app/privates/${encodeURIComponent(privateId)}`, {
+      signal: options.signal
+    });
+    const body = object2(value);
+    const conversation = object2(body?.private);
+    if (!body || conversation?.id !== privateId || conversation?.buddyId !== this.#buddyId || !Array.isArray(body.messages) || typeof body.replying !== "boolean") {
+      throw httpError(502, { error: "MLB Server \u8FD4\u56DE\u4E86\u65E0\u6CD5\u8BC6\u522B\u7684\u79C1\u804A\u72B6\u6001" });
+    }
+    this.#messages = Object.freeze(body.messages.map((item, index) => message(item, index)).filter((item) => item !== null));
+    if (this.#active) {
+      const replied = this.#messages.some((item) => item.role === "assistant" && Date.parse(item.createdAt) > this.#active.messageTimestamp);
+      if (body.replying) {
+        this.#active = Object.freeze({ ...this.#active, observedReplying: true });
+        this.#latest = Object.freeze({ runId: this.#active.runId, status: "running" });
+      } else if (replied) {
+        this.#latest = Object.freeze({ runId: this.#active.runId, status: "completed" });
+        this.#active = void 0;
+        this.#streaming = void 0;
+      } else if (this.#active.observedReplying) {
+        this.#latest = Object.freeze({ runId: this.#active.runId, status: "completed" });
+        this.#active = void 0;
+        this.#streaming = void 0;
+      }
+    }
+    return Object.freeze({
+      messages: this.#messages,
+      ...this.#latest === void 0 ? {} : { latestRun: this.#latest },
+      ...this.#active === void 0 ? {} : {
+        activeRun: Object.freeze({
+          runId: this.#active.runId,
+          status: body.replying ? "running" : "pending"
+        })
+      },
+      ...this.#streaming === void 0 ? {} : { streaming: this.#streaming }
+    });
+  }
+  async send(input, options = {}) {
+    if (typeof input.text !== "string" || !input.text.trim() || Buffer.byteLength(input.text, "utf8") > 32 * 1024) {
+      throw new TypeError("message text is invalid");
+    }
+    this.#assertResetComplete();
+    const idempotencyKey = safeText(input.idempotencyKey, "idempotencyKey", 128);
+    if (this.#lastSend?.key === idempotencyKey) {
+      if (this.#lastSend.text !== input.text.trim()) throw httpError(409, { error: "\u540C\u4E00\u6761\u6D88\u606F\u4E0D\u80FD\u6539\u5199\u5185\u5BB9" });
+      return this.#lastSend.receipt;
+    }
+    if (this.#sending) {
+      throw Object.assign(new Error("\u6D88\u606F\u6B63\u5728\u53D1\u9001"), {
+        code: "SEND_IN_PROGRESS",
+        status: 409,
+        publicMessage: "\u6D88\u606F\u6B63\u5728\u53D1\u9001\uFF0C\u8BF7\u7A0D\u5019"
+      });
+    }
+    this.#sending = true;
+    try {
+      const privateId = await this.#ensurePrivate(options.signal);
+      const clientMessageId = localReceipt("client", idempotencyKey);
+      let value;
+      try {
+        const url = endpoint(this.#baseUrl, "/app/ws");
+        url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+        value = await mlbAppCommand(url, this.#accessToken, "message.send", {
+          kind: "private",
+          id: privateId,
+          messages: [{ type: "text", text: input.text }],
+          clientMessageId
+        }, { signal: options.signal });
+        const receipt2 = object2(value);
+        const items = Array.isArray(receipt2?.items) ? receipt2.items : [];
+        const item2 = object2(items[0]);
+        if (receipt2?.ok !== true || receipt2.clientMessageId !== clientMessageId || items.length !== 1 || item2?.index !== 0 || typeof item2.messageId !== "string" || !item2.messageId.trim() || !Number.isSafeInteger(item2.timestamp) || item2.timestamp < 0 || typeof receipt2.shouldReply !== "boolean") {
+          throw httpError(502, { error: "MLB \u6D88\u606F\u56DE\u6267\u65E0\u6548" });
+        }
+        safeText(item2.messageId, "receipt.items[0].messageId", 256);
+      } catch (cause) {
+        if (cause && typeof cause === "object" && "status" in cause && typeof cause.status === "number" && cause.status >= 400 && cause.status < 500) throw cause;
+        throw Object.assign(new Error("\u53D1\u9001\u7ED3\u679C\u5C1A\u672A\u786E\u8BA4\uFF0C\u8BF7\u5237\u65B0\u804A\u5929\u8BB0\u5F55\u540E\u518D\u91CD\u8BD5"), {
+          code: "MLB_SEND_OUTCOME_UNKNOWN",
+          status: 502,
+          publicMessage: "\u53D1\u9001\u7ED3\u679C\u5C1A\u672A\u786E\u8BA4\uFF0C\u8BF7\u5237\u65B0\u804A\u5929\u8BB0\u5F55\u540E\u518D\u91CD\u8BD5"
+        });
+      }
+      const receipt = object2(value);
+      const item = object2(receipt.items[0]);
+      const runId = this.#active?.runId ?? localReceipt("turn", idempotencyKey);
+      const messageId = safeText(item.messageId, "receipt.items[0].messageId", 256);
+      if (!this.#active) {
+        this.#active = receipt.shouldReply ? Object.freeze({
+          runId,
+          messageTimestamp: item.timestamp,
+          observedReplying: false
+        }) : void 0;
+        this.#latest = Object.freeze({ runId, status: receipt.shouldReply ? "pending" : "completed" });
+        this.#streaming = void 0;
+      }
+      const accepted = Object.freeze({ messageId, runId });
+      this.#lastSend = { key: idempotencyKey, text: input.text.trim(), receipt: accepted };
+      return accepted;
+    } finally {
+      this.#sending = false;
+    }
+  }
+  #assertResetComplete() {
+    if (this.#resetTarget) throw Object.assign(new Error("\u8BF7\u518D\u6B21\u70B9\u51FB\u6E05\u7A7A\u5BF9\u8BDD\uFF0C\u5B8C\u6210\u65B0\u4F1A\u8BDD\u521B\u5EFA"), {
+      code: "RESET_INCOMPLETE",
+      status: 409,
+      publicMessage: "\u4F1A\u8BDD\u91CD\u7F6E\u5C1A\u672A\u5B8C\u6210\uFF0C\u8BF7\u518D\u6B21\u70B9\u51FB\u300C\u6E05\u7A7A\u5BF9\u8BDD\u300D\u91CD\u8BD5"
+    });
+  }
+  async reset(options = {}) {
+    if (this.#sending) throw httpError(409, { error: "\u6D88\u606F\u6B63\u5728\u53D1\u9001\uFF0C\u8BF7\u7A0D\u540E\u6E05\u7A7A" });
+    if (!this.#resetTarget) {
+      const privateId = await this.#ensurePrivate(options.signal);
+      const current = object2(await this.#request("GET", `/app/privates/${encodeURIComponent(privateId)}`, options));
+      const conversation = object2(current?.private);
+      if (conversation?.id !== privateId || conversation?.buddyId !== this.#buddyId || typeof current?.replying !== "boolean") {
+        throw httpError(502, { error: "\u65E0\u6CD5\u786E\u8BA4\u5F53\u524D\u79C1\u804A\u72B6\u6001\uFF0C\u672A\u6E05\u7A7A\u5BF9\u8BDD" });
+      }
+      if (current.replying) throw httpError(409, { error: "\u8BF7\u7B49\u5F85\u5F53\u524D\u56DE\u590D\u5B8C\u6210\u540E\u518D\u6E05\u7A7A" });
+      this.#resetTarget = privateId;
+      await this.#widgetBridge.closeAll();
+    }
+    try {
+      if (!this.#resetArchived) {
+        const receipt = object2(await this.#request("DELETE", `/app/privates/${encodeURIComponent(this.#resetTarget)}`, options));
+        if (receipt?.ok !== true) throw httpError(502, { error: "\u65E0\u6CD5\u786E\u8BA4\u65E7\u4F1A\u8BDD\u5DF2\u7ED3\u675F" });
+        this.#resetArchived = true;
+        this.#privateId = void 0;
+      }
+      const nextId = await this.#ensurePrivate(options.signal);
+      if (nextId === this.#resetTarget) {
+        this.#privateId = void 0;
+        throw httpError(502, { error: "MLB \u672A\u8FD4\u56DE\u65B0\u7684\u4F1A\u8BDD\u8EAB\u4EFD" });
+      }
+    } catch (cause) {
+      const detail = object2(cause)?.publicMessage;
+      throw Object.assign(new Error("\u4F1A\u8BDD\u91CD\u7F6E\u5C1A\u672A\u5B8C\u6210", { cause }), {
+        code: "RESET_INCOMPLETE",
+        status: 502,
+        publicMessage: `${this.#resetArchived ? "\u65E7\u4F1A\u8BDD\u5DF2\u7ED3\u675F\uFF0C\u65B0\u4F1A\u8BDD\u521B\u5EFA\u672A\u5B8C\u6210" : "\u5C1A\u672A\u786E\u8BA4\u65E7\u4F1A\u8BDD\u5DF2\u7ED3\u675F"}\uFF0C\u8BF7\u518D\u6B21\u70B9\u51FB\u300C\u6E05\u7A7A\u5BF9\u8BDD\u300D\u91CD\u8BD5\u3002${typeof detail === "string" ? `\uFF08${detail}\uFF09` : ""}`
+      });
+    }
+    this.#active = void 0;
+    this.#latest = void 0;
+    this.#streaming = void 0;
+    this.#lastSend = void 0;
+    this.#messages = Object.freeze([]);
+    this.#resetTarget = void 0;
+    this.#resetArchived = false;
+  }
+  async cancel(_runId, _options = {}) {
+    throw Object.assign(new Error("\u5F53\u524D MLB \u534F\u8BAE\u5C1A\u672A\u63D0\u4F9B\u7EC8\u6B62\u56DE\u590D\u63A5\u53E3"), {
+      code: "TURN_CANCEL_UNSUPPORTED",
+      status: 501,
+      publicMessage: "\u5F53\u524D\u7248\u672C\u6682\u4E0D\u652F\u6301\u7EC8\u6B62\u56DE\u590D"
+    });
+  }
+  async watchOutput(runId, options) {
+    const safeRunId = safeText(runId, "runId", 256);
+    const privateId = await this.#ensurePrivate(options.signal);
+    const url = endpoint(this.#baseUrl, "/app/ws");
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    let sequence = 0;
+    let assistantIds = new Set(this.#messages.filter((message2) => message2.role === "assistant").map((message2) => message2.messageId));
+    const reset = async () => {
+      sequence = 0;
+      this.#streaming = void 0;
+      await options.onEvent({ type: "reset", runId: safeRunId });
+    };
+    for (let reconnects = 0; !options.signal?.aborted; reconnects++) {
+      try {
+        for await (const frame of mlbAppEvents(url, this.#accessToken, {
+          signal: options.signal
+        })) {
+          const { data } = frame;
+          if (frame.event === "ready") {
+            await reset();
+          } else if (data.kind !== "private" || data.id !== privateId || data.buddyId !== this.#buddyId) {
+            continue;
+          }
+          if (frame.event === "delta" && typeof data.text === "string" && data.text.length > 0) {
+            const text2 = `${this.#streaming?.runId === safeRunId ? this.#streaming.text : ""}${data.text}`;
+            if (Buffer.byteLength(text2, "utf8") > 48 * 1024) throw new MlbEventStreamError("MLB \u6D41\u5F0F\u56DE\u590D\u8D85\u8FC7\u5927\u5C0F\u9650\u5236", 502, false);
+            this.#streaming = Object.freeze({ runId: safeRunId, text: text2, nextSequence: sequence + 1, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+            await options.onEvent({ type: "delta", runId: safeRunId, sequence, text: data.text });
+            sequence++;
+            continue;
+          }
+          if (frame.event !== "chat" && frame.event !== "ready") continue;
+          let state = await this.state({ signal: options.signal });
+          const nextAssistantIds = new Set(state.messages.filter((message2) => message2.role === "assistant").map((message2) => message2.messageId));
+          const committedReply = [...nextAssistantIds].some((id) => !assistantIds.has(id));
+          assistantIds = nextAssistantIds;
+          if (committedReply && state.activeRun) {
+            sequence = 0;
+            this.#streaming = void 0;
+            const { streaming: _streaming, ...snapshot } = state;
+            state = snapshot;
+          }
+          if (state.latestRun?.runId === safeRunId && (state.latestRun.status === "completed" || state.latestRun.status === "failed")) {
+            await options.onEvent({ type: state.latestRun.status, runId: safeRunId, status: state.latestRun.status });
+            return;
+          }
+          await options.onEvent({ type: "state", runId: safeRunId, state, resetStreaming: committedReply });
+        }
+        if (options.signal?.aborted) return;
+      } catch (cause) {
+        if (options.signal?.aborted) return;
+        await reset();
+        const status = object2(cause)?.status;
+        if (cause instanceof MlbEventStreamError && !cause.retryable || typeof status === "number" && status >= 400 && status < 500 && status !== 429 || reconnects >= 4) throw cause;
+      }
+      await waitForRetry(Math.min(1e3, (reconnects + 1) * 150), options.signal);
+    }
+  }
+  async #ensurePrivate(signal) {
+    if (this.#privateId) return this.#privateId;
+    if (!this.#privatePromise) {
+      const pending = this.#request(
+        "POST",
+        "/app/privates",
+        { signal, body: { buddyId: this.#buddyId } }
+      ).then((value) => {
+        const body = object2(value);
+        if (body?.ok !== true || typeof body.id !== "string" || !/^p_[a-zA-Z0-9_-]{1,253}$/u.test(body.id)) {
+          throw httpError(502, { error: "MLB \u521B\u5EFA\u79C1\u804A\u54CD\u5E94\u7F3A\u5C11\u6709\u6548\u7684 privateId" });
+        }
+        this.#privateId = body.id;
+        return body.id;
+      }).finally(() => {
+        if (this.#privatePromise === pending) this.#privatePromise = void 0;
+      });
+      this.#privatePromise = pending;
+    }
+    return this.#privatePromise;
+  }
+  async #request(method, path, options) {
+    const headers = new Headers({
+      Accept: "application/json",
+      Authorization: `Bearer ${this.#accessToken}`,
+      ...options.headers
+    });
+    if (options.body !== void 0) headers.set("Content-Type", "application/json");
+    const response = await this.#fetch(endpoint(this.#baseUrl, path), {
+      method,
+      headers,
+      ...options.body === void 0 ? {} : { body: JSON.stringify(options.body) },
+      signal: AbortSignal.any([AbortSignal.timeout(3e4), ...options.signal ? [options.signal] : []]),
+      redirect: "error"
+    });
+    const value = await response.json().catch(() => void 0);
+    if (!response.ok) throw httpError(response.status, value);
+    return value;
+  }
+};
+
+// apps/preview/src/bridge.ts
+import { hostname } from "node:os";
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { setTimeout as delay2 } from "node:timers/promises";
+async function connectPreviewBridge(options) {
+  const connectionId = randomBytes2(32).toString("base64url");
+  const shutdown = new AbortController();
+  const signal = AbortSignal.any([options.signal, shutdown.signal]);
+  const running = /* @__PURE__ */ new Map();
+  const replies = /* @__PURE__ */ new Map();
+  const completed = /* @__PURE__ */ new Set();
+  let lastContact = Date.now();
+  let stopping;
+  let interrupted = false;
+  let disconnecting = false;
+  async function call(path, token, payload, requestSignal = signal) {
+    const response = await fetch(new URL(path, options.platformOrigin), {
+      method: "POST",
+      redirect: "error",
+      signal: AbortSignal.any([requestSignal, AbortSignal.timeout(4e3)]),
+      headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+      body: JSON.stringify(payload ?? {})
+    });
+    const value = await response.json();
+    if (!response.ok) throw Object.assign(new Error(value.error || "\u540E\u53F0\u8FDE\u63A5\u5931\u8D25"), { status: response.status });
+    return value;
+  }
+  const attach = async () => {
+    const result = await call("/cli/preview/connect", await options.token(), {
+      connectionId,
+      forceDisconnect: true,
+      buddyId: options.buddyId,
+      projectRoot: options.controller.projectRoot,
+      machineName: hostname(),
+      platformOrigin: options.platformOrigin
+    });
+    lastContact = Date.now();
+    return result;
+  };
+  const bootstrap = await fetch(options.localServer.bootstrapUrl, { redirect: "manual", signal });
+  const cookie = bootstrap.headers.get("set-cookie")?.split(";", 1)[0];
+  if (bootstrap.status !== 303 || !cookie) throw new Error("\u672C\u5730\u8C03\u8BD5\u670D\u52A1\u521D\u59CB\u5316\u5931\u8D25");
+  const initial = await attach();
+  if (initial.reused) return { reused: true, completion: Promise.resolve(), async close() {
+  } };
+  const pendingEvents = /* @__PURE__ */ new Map();
+  let eventSequence = 0;
+  let publishing;
+  let retryEvents;
+  const flushEvents = () => {
+    if (!initial.liveEvents || signal.aborted || publishing || retryEvents || !pendingEvents.size) return;
+    publishing = (async () => {
+      while (!signal.aborted && pendingEvents.size) {
+        const events = [...pendingEvents.values()].sort((a, b) => a.sequence - b.sequence);
+        try {
+          await call("/cli/preview/events", connectionId, { events });
+          for (const event of events) if (pendingEvents.get(event.type) === event) pendingEvents.delete(event.type);
+        } catch {
+          if (!signal.aborted) retryEvents = setTimeout(() => {
+            retryEvents = void 0;
+            flushEvents();
+          }, 500);
+          break;
+        }
+      }
+    })().finally(() => {
+      publishing = void 0;
+    });
+  };
+  const queueEvent = (type, value) => {
+    if (!initial.liveEvents || signal.aborted) return;
+    pendingEvents.set(type, { sequence: eventSequence++, type, value });
+    flushEvents();
+  };
+  const snapshotEvents = () => {
+    queueEvent("dev.state", options.controller.state());
+    queueEvent("simulator.state", { state: options.controller.simulatorSnapshot() });
+  };
+  const unsubscribeDev = options.controller.subscribe((state) => queueEvent("dev.state", state));
+  const unsubscribeSimulator = options.controller.subscribeSimulator(({ state }) => queueEvent("simulator.state", { state }));
+  snapshotEvents();
+  const watchdog = setInterval(() => {
+    if (Date.now() - lastContact < 1e4 || stopping || interrupted) return;
+    interrupted = true;
+    stopping = options.controller.stop();
+    void stopping.catch(() => shutdown.abort());
+    options.onStatus?.("\u540E\u53F0\u8FDE\u63A5\u5DF2\u65AD\u5F00\uFF0C\u6B63\u5728\u505C\u6B62 DEV\uFF1B\u8FDE\u63A5\u6062\u590D\u540E\u53EF\u5728\u540E\u53F0\u91CD\u65B0\u542F\u52A8\u3002");
+  }, 500);
+  watchdog.unref();
+  async function execute(command) {
+    try {
+      if (command.path === "/api/connection/disconnect" && command.method === "POST") {
+        disconnecting = true;
+        await options.controller.close();
+        await options.stopLocalDev?.();
+        replies.set(command.id, { id: command.id, status: 200, contentType: "application/json", body: Buffer.from(JSON.stringify({ localStopped: Boolean(options.stopLocalDev) })).toString("base64") });
+        options.onStatus?.("\u540E\u53F0\u5DF2\u8BF7\u6C42\u5F3A\u5236\u65AD\u8FDE\uFF0C\u5F53\u524D\u5DE5\u7A0B DEV \u5DF2\u505C\u6B62\u3002\u9700\u8981\u8C03\u8BD5\u65F6\u91CD\u65B0\u6267\u884C\u8FDE\u63A5\u6307\u4EE4\u3002");
+        return;
+      }
+      if (disconnecting) throw new Error("\u6B63\u5728\u65AD\u5F00\u8FDE\u63A5");
+      if (!command.path.startsWith("/api/") || command.path === "/api/events" || command.path.includes("..")) throw new Error("\u8C03\u8BD5\u8DEF\u5F84\u65E0\u6548");
+      const target = new URL(command.path, options.localServer.origin);
+      if (target.origin !== options.localServer.origin.origin) throw new Error("\u8C03\u8BD5\u8DEF\u5F84\u65E0\u6548");
+      if ((await options.controller.project()).buddyId !== options.buddyId) throw new Error("\u5DE5\u7A0B buddyId \u5DF2\u6539\u53D8\uFF0C\u8BF7\u9000\u51FA CLI \u540E\u91CD\u65B0\u8FDE\u63A5\u5BF9\u5E94\u642D\u5B50");
+      signal.throwIfAborted();
+      if (interrupted || disconnecting) throw new Error("\u672C\u5730\u8FDE\u63A5\u5DF2\u4E2D\u65AD");
+      const response = await fetch(target, {
+        method: command.method,
+        redirect: "error",
+        signal: AbortSignal.any([signal, AbortSignal.timeout(28e3)]),
+        headers: { Cookie: cookie, ...command.body ? { "Content-Type": "application/json" } : {} },
+        ...command.body ? { body: command.body } : {}
+      });
+      const chunks = [];
+      let size = 0;
+      for await (const chunk of response.body ?? []) {
+        size += chunk.length;
+        if (size > 8 * 1024 * 1024) throw new Error("\u8C03\u8BD5\u54CD\u5E94\u8FC7\u5927");
+        chunks.push(Buffer.from(chunk));
+      }
+      replies.set(command.id, { id: command.id, status: response.status, contentType: response.headers.get("content-type") ?? "application/json", body: Buffer.concat(chunks).toString("base64") });
+    } catch {
+      replies.set(command.id, { id: command.id, status: 502, contentType: "application/json", body: Buffer.from(JSON.stringify({ error: { code: "PREVIEW_LOCAL_FAILED", message: "\u672C\u5730\u8C03\u8BD5\u8BF7\u6C42\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u7EC8\u7AEF\u53CA\u5DE5\u7A0B buddyId" } })).toString("base64") });
+    } finally {
+      running.delete(command.id);
+    }
+  }
+  const completion = (async () => {
+    try {
+      while (!signal.aborted) {
+        try {
+          if (stopping) {
+            await stopping;
+            stopping = void 0;
+          }
+          const result = await call("/cli/preview/poll", connectionId, { replies: [...replies.values()].slice(0, 1) });
+          lastContact = Date.now();
+          const recovered = interrupted;
+          if (stopping) {
+            await stopping;
+            stopping = void 0;
+          }
+          if (recovered) {
+            interrupted = false;
+            options.onStatus?.("\u5DF2\u91CD\u65B0\u8FDE\u63A5\u540E\u53F0\uFF0C\u8BF7\u5728\u5F00\u53D1\u8C03\u8BD5\u9875\u542F\u52A8 DEV\u3002");
+          }
+          for (const id of result.acknowledged ?? []) {
+            replies.delete(id);
+            completed.add(id);
+          }
+          while (completed.size > 256) completed.delete(completed.values().next().value);
+          for (const command of result.commands ?? []) {
+            if (recovered && !running.has(command.id) && !replies.has(command.id) && !completed.has(command.id)) {
+              replies.set(command.id, { id: command.id, status: 409, contentType: "application/json", body: Buffer.from(JSON.stringify({ error: { code: "PREVIEW_RECONNECTED", message: "\u672C\u5730\u8FDE\u63A5\u5DF2\u6062\u590D\uFF0C\u8BF7\u91CD\u65B0\u64CD\u4F5C" } })).toString("base64") });
+            }
+            if (!running.has(command.id) && !replies.has(command.id) && !completed.has(command.id) && running.size < 32) running.set(command.id, execute(command));
+          }
+        } catch (cause) {
+          if (signal.aborted) break;
+          const status = cause.status;
+          if (status === 410) {
+            await options.controller.stop();
+            options.onStatus?.("\u540E\u53F0\u8FDE\u63A5\u5DF2\u7ED3\u675F\uFF1B\u8BF7\u91CD\u65B0\u6267\u884C\u8FDE\u63A5\u6307\u4EE4\u3002\u672A\u81EA\u52A8\u91CD\u65B0\u8FDE\u63A5\u6216\u542F\u52A8 DEV\u3002");
+            break;
+          } else if (status && status >= 400 && status < 500 && status !== 429) throw cause;
+        }
+        await delay2(replies.size ? 20 : 500, void 0, { signal }).catch(() => void 0);
+      }
+    } finally {
+      clearInterval(watchdog);
+      unsubscribeDev();
+      unsubscribeSimulator();
+      if (retryEvents) clearTimeout(retryEvents);
+      shutdown.abort();
+      await publishing;
+    }
+  })();
+  void completion.catch(() => void 0);
+  return {
+    reused: false,
+    completion,
+    async close() {
+      shutdown.abort();
+      await completion.catch(() => void 0);
+      await Promise.allSettled(running.values());
+      await stopping;
+      await options.controller.stop();
+      await call("/cli/preview/disconnect", connectionId, {}, AbortSignal.timeout(2e3)).catch(() => void 0);
+    }
+  };
+}
+export {
+  MlbSimulatorClient,
+  PreviewController,
+  connectPreviewBridge,
+  createBuddyPreviewUrl,
+  startPreviewControlServer
+};
+//# sourceMappingURL=preview.js.map