@adep/cli 0.0.9 → 0.1.1

package/dist/vite.js

@@ -0,0 +1,2719 @@
+// packages/cli/src/vite.ts
+import { adepPlugin } from "@adep/vite-plugin";
+
+// packages/cli/src/dev.ts
+import { createServer } from "node:http";
+import { watch } from "node:fs";
+import { mkdir as mkdir3, readdir as readdir2, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
+import { basename, join as join7, resolve as resolve2 } from "node:path";
+
+// packages/runtime/src/shared/capability-keys.ts
+var RPC_CAPABILITY_KEY = "__adepRpc";
+var CHAIN_CAPABILITY_KEY = "__adepChain";
+var DB_RPC = {
+  /** 直通方法（如 query）：`(method=query, args=[sql, params])`。 */
+  query: "query",
+  /** 读取 owned 表变更流（DB-006）：`(method=changes, args=[table, query])`。 */
+  changes: "changes",
+  /** 开启事务：`begin → txId`。 */
+  begin: "begin",
+  /** 提交事务：`commit, args=[txId]`。 */
+  commit: "commit",
+  /** 回滚事务：`rollback, args=[txId]`。 */
+  rollback: "rollback",
+  /** 执行一条链：`chain, args=[ChainRequest]`。 */
+  chain: "chain"
+};
+var REALTIME_CAPABILITY_CODES = {
+  invalidMethod: "REALTIME_INVALID_METHOD",
+  unsupportedArg: "REALTIME_UNSUPPORTED_ARG",
+  subscriptionNotFound: "REALTIME_SUBSCRIPTION_NOT_FOUND",
+  tooManySubscriptions: "REALTIME_TOO_MANY_SUBSCRIPTIONS",
+  /** 线上独有：订阅授权策略（RT-002 `SubscriptionPolicy`）拒绝该 channel。 */
+  channelDenied: "REALTIME_CHANNEL_DENIED"
+};
+var REALTIME_CAPABILITY_METHODS = [
+  "publish",
+  "subscribe",
+  "receive",
+  "unsubscribe"
+];
+
+// packages/runtime/src/shared/executor-runtime.ts
+var ExecutorError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "ExecutorError";
+  }
+};
+var TIMEOUT_CODE = "FN_EXEC_TIMEOUT";
+var OOM_CODE = "FN_EXEC_OOM";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_MEMORY_LIMIT_MB = 128;
+function isHttpStatus(status) {
+  return typeof status === "number" && Number.isInteger(status) && status >= 400 && status <= 599;
+}
+function normalizeHttpStatus(status) {
+  return isHttpStatus(status) ? status : 500;
+}
+
+// packages/runtime/src/functions/runtime/worker-executor.ts
+import { readFileSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { dirname, join } from "node:path";
+import { Worker } from "node:worker_threads";
+
+// packages/runtime/src/functions/deps/resolve.ts
+import { resolve } from "node:path";
+
+// packages/runtime/src/functions/deps/manifest.ts
+import { createHash } from "node:crypto";
+
+// packages/runtime/src/functions/domain.ts
+var MAX_TOTAL_SOURCE_BYTES = 256 * 1024;
+var FnError = class extends Error {
+  status;
+  code;
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "FnError";
+  }
+};
+
+// packages/runtime/src/functions/deps/manifest.ts
+var PACKAGE_NAME_PATTERN = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-._~]+$/;
+var COMPARATOR_PATTERN = /^(?:\^|~|>=|<=|>|<|=)?\d+(?:\.(?:\d+|x|X|\*)){0,2}(?:-[\w.-]+)?(?:\+[\w.-]+)?$/;
+var MANIFEST_MAX_DEPS = 100;
+function isVersionRangeSpec(spec) {
+  if (spec === "*" || spec === "latest") return true;
+  const unions = spec.split("||");
+  return unions.every((union) => {
+    const trimmed = union.trim();
+    if (trimmed.length === 0) return false;
+    const hyphen = trimmed.split(" - ");
+    if (hyphen.length === 2) {
+      return COMPARATOR_PATTERN.test(hyphen[0].trim()) && COMPARATOR_PATTERN.test(hyphen[1].trim());
+    }
+    return trimmed.split(/\s+/).every((part) => COMPARATOR_PATTERN.test(part));
+  });
+}
+function parseManifestDependencies(content) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    throw new FnError(400, "DEP_INVALID_MANIFEST", "package.json \u4E0D\u662F\u5408\u6CD5 JSON");
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new FnError(400, "DEP_INVALID_MANIFEST", "package.json \u9876\u5C42\u5FC5\u987B\u662F\u5BF9\u8C61");
+  }
+  const raw = parsed["dependencies"];
+  if (raw === void 0) return {};
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new FnError(400, "DEP_INVALID_MANIFEST", "dependencies \u5FC5\u987B\u662F { \u5305\u540D: \u7248\u672C\u8303\u56F4 } \u5BF9\u8C61");
+  }
+  const entries = Object.entries(raw);
+  if (entries.length > MANIFEST_MAX_DEPS) {
+    throw new FnError(
+      400,
+      "DEP_INVALID_MANIFEST",
+      `\u4F9D\u8D56\u6761\u76EE\u8D85\u8FC7\u4E0A\u9650\uFF08${MANIFEST_MAX_DEPS} \u4E2A\uFF0C\u5F53\u524D ${entries.length} \u4E2A\uFF09`
+    );
+  }
+  const dependencies = {};
+  for (const [name, spec] of entries) {
+    if (!PACKAGE_NAME_PATTERN.test(name)) {
+      throw new FnError(
+        400,
+        "DEP_INVALID_MANIFEST",
+        `\u975E\u6CD5\u4F9D\u8D56\u540D "${name}"\uFF1A\u987B\u4E3A npm \u5305\u540D\uFF08scoped \u5F62\u5982 @scope/name\uFF09`
+      );
+    }
+    if (typeof spec !== "string" || !isVersionRangeSpec(spec)) {
+      throw new FnError(
+        400,
+        "DEP_SPEC_REJECTED",
+        `\u4F9D\u8D56 "${name}" \u7684\u7248\u672C\u58F0\u660E "${String(spec)}" \u4E0D\u88AB\u63A5\u53D7\uFF1A\u53EA\u652F\u6301\u8BED\u4E49\u5316\u7248\u672C\u8303\u56F4\uFF08^/~/>=/\u7CBE\u786E\uFF09\uFF0CURL\u3001git\u3001file\u3001workspace \u53D6\u5305\u88AB registry \u767D\u540D\u5355\u62D2\u7EDD`
+      );
+    }
+    dependencies[name] = spec;
+  }
+  return dependencies;
+}
+function tryParseManifestDependencies(content) {
+  if (content === void 0) return {};
+  try {
+    return parseManifestDependencies(content);
+  } catch {
+    return {};
+  }
+}
+function classifyDependencies(dependencies, builtin) {
+  const builtinDeps = {};
+  const customDeps = {};
+  for (const [name, spec] of Object.entries(dependencies)) {
+    if (builtin.includes(name)) builtinDeps[name] = spec;
+    else customDeps[name] = spec;
+  }
+  return { builtinDeps, customDeps };
+}
+function depsKeyOf(dependencies) {
+  const canonical = Object.entries(dependencies).map(([name, version]) => `${name}@${version}`).toSorted().join("\n");
+  return createHash("sha256").update(canonical).digest("hex").slice(0, 16);
+}
+
+// packages/runtime/src/functions/deps/resolve.ts
+function resolveExecutionDeps(config, projectId, manifestContent) {
+  const manifest = tryParseManifestDependencies(manifestContent);
+  const { customDeps } = classifyDependencies(manifest, config.builtin);
+  const custom = Object.keys(customDeps);
+  return {
+    // 绝对化（相对进程 cwd，与 installer 侧 resolve(rootDir) 同基准）：worker 的 createRequire 需要确定路径
+    dir: custom.length === 0 ? null : resolve(config.rootDir, projectId, depsKeyOf(customDeps)),
+    builtin: [...config.builtin],
+    custom
+  };
+}
+
+// packages/runtime/src/functions/runtime/worker-executor.ts
+function resolveWorkerEntry(baseDir = fileURLToPath(new URL(".", import.meta.url))) {
+  const candidates = [
+    join(baseDir, "worker-entry.js"),
+    join(baseDir, "worker-entry.ts"),
+    join(baseDir, "domains/functions/runtime/worker-entry.js"),
+    join(baseDir, "domains/functions/runtime/worker-entry.ts")
+  ];
+  let current = baseDir;
+  for (let depth = 0; depth < 8; depth += 1) {
+    candidates.push(
+      join(current, "packages/runtime/src/functions/runtime/worker-entry.js"),
+      join(current, "packages/runtime/src/functions/runtime/worker-entry.ts")
+    );
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  for (const candidate of candidates) {
+    try {
+      readFileSync(candidate);
+      return pathToFileURL(candidate);
+    } catch {
+      continue;
+    }
+  }
+  throw new Error("\u65E0\u6CD5\u5B9A\u4F4D worker \u5165\u53E3\uFF08worker-entry.ts / worker-entry.js\uFF09");
+}
+function rpcReply(worker, id, ok, payload) {
+  worker.postMessage({
+    type: "rpc-response",
+    id,
+    ok,
+    ...payload?.result === void 0 ? {} : { result: payload.result },
+    ...payload?.error === void 0 ? {} : { error: payload.error }
+  });
+}
+var WorkerFunctionExecutor = class {
+  depsConfig;
+  fetchConfig;
+  constructor(options = {}) {
+    this.depsConfig = options.deps;
+    this.fetchConfig = options.fetch;
+  }
+  async execute(input) {
+    const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const memoryLimitMb = input.memoryLimitMb ?? DEFAULT_MEMORY_LIMIT_MB;
+    const entry = input.entry ?? "index.ts";
+    const deps = this.depsConfig === void 0 ? void 0 : resolveExecutionDeps(this.depsConfig, input.project.id, input.files["package.json"]);
+    const logs = [];
+    return new Promise((resolve3, reject) => {
+      let worker;
+      try {
+        worker = new Worker(resolveWorkerEntry(), {
+          workerData: {
+            files: input.files,
+            entry,
+            request: input.request,
+            capabilities: input.capabilities ?? [],
+            ...input.env === void 0 ? {} : { env: input.env },
+            ...deps === void 0 ? {} : { deps },
+            ...this.fetchConfig === void 0 ? {} : { fetch: this.fetchConfig }
+          },
+          resourceLimits: { maxOldGenerationSizeMb: memoryLimitMb }
+        });
+      } catch (error) {
+        reject(
+          new ExecutorError(
+            500,
+            "FN_EXEC_ERROR",
+            error instanceof Error ? error.message : "worker \u6784\u9020\u5931\u8D25"
+          )
+        );
+        return;
+      }
+      const timer = setTimeout(() => {
+        void worker.terminate();
+        reject(
+          new ExecutorError(504, TIMEOUT_CODE, `\u51FD\u6570\u6267\u884C\u8D85\u8FC7 ${timeoutMs}ms \u9650\u5236\uFF0Cworker \u5DF2\u88AB\u56DE\u6536`)
+        );
+      }, timeoutMs);
+      worker.on(
+        "message",
+        (message) => {
+          if (message.type === "rpc") {
+            const handler = input.rpcHandlers?.[message.capability ?? ""];
+            if (handler === void 0) {
+              rpcReply(worker, message.id, false, {
+                error: `RPC \u80FD\u529B "${message.capability ?? ""}" \u672A\u6CE8\u518C`
+              });
+              return;
+            }
+            const rpcArgs = Array.isArray(message.args) ? message.args : [];
+            void (async () => {
+              try {
+                const result = await handler(message.method ?? "", rpcArgs);
+                rpcReply(worker, message.id, true, { result });
+              } catch (error) {
+                rpcReply(worker, message.id, false, {
+                  error: error instanceof Error ? error.message : String(error)
+                });
+              }
+            })();
+            return;
+          }
+          if (message.type === "log") {
+            logs.push(`[${message.level ?? "log"}] ${message.message ?? ""}`);
+            return;
+          }
+          if (message.type === "result") {
+            clearTimeout(timer);
+            void worker.terminate();
+            resolve3({ body: message.body, logs });
+            return;
+          }
+          if (message.type === "error") {
+            clearTimeout(timer);
+            void worker.terminate();
+            const isOom = typeof message.message === "string" && /allocation\s+(failed|error)|out\s+of\s+memory|\bOOM\b/i.test(message.message);
+            reject(
+              isOom ? new ExecutorError(500, OOM_CODE, "\u51FD\u6570\u5185\u5B58\u8D85\u9650\uFF0C\u6267\u884C\u5DF2\u4E2D\u6B62") : (
+                // FN-011：函数抛错携带的 status 透传落 ExecutorError.status（非法/缺失 → 500 兼容旧形态）。
+                new ExecutorError(
+                  normalizeHttpStatus(message.status),
+                  message.code ?? "FN_EXEC_ERROR",
+                  message.message ?? "\u51FD\u6570\u6267\u884C\u5931\u8D25"
+                )
+              )
+            );
+          }
+        }
+      );
+      worker.on("error", (error) => {
+        clearTimeout(timer);
+        const isOom = /allocation\s+(failed|error)|out\s+of\s+memory|\bOOM\b/i.test(error.message);
+        reject(
+          isOom ? new ExecutorError(500, OOM_CODE, "\u51FD\u6570\u5185\u5B58\u8D85\u9650\uFF0C\u6267\u884C\u5DF2\u4E2D\u6B62") : new ExecutorError(500, "FN_EXEC_ERROR", error.message)
+        );
+      });
+    });
+  }
+  async dispose() {
+  }
+};
+
+// packages/cli/src/sim/runtime.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname3, join as join4 } from "node:path";
+
+// packages/runtime/src/database/builder/dialect.ts
+var sqliteDialect = {
+  name: "sqlite",
+  placeholder: () => "?",
+  quote: (identifier) => `"${identifier.replace(/"/g, '""')}"`,
+  lastInsertIdClause: () => "",
+  upsertConflictClause: (columns) => ` ON CONFLICT (${columns.map((column) => `"${column.replace(/"/g, '""')}"`).join(", ")}) DO NOTHING`
+};
+var postgresDialect = {
+  name: "postgres",
+  placeholder: (index) => `$${index + 1}`,
+  quote: (identifier) => `"${identifier.replace(/"/g, '""')}"`,
+  lastInsertIdClause: () => " RETURNING id",
+  upsertConflictClause: (columns) => ` ON CONFLICT (${columns.map((column) => `"${column.replace(/"/g, '""')}"`).join(", ")}) DO NOTHING`
+};
+function dialectFor(driver) {
+  return driver.engine === "pg" ? postgresDialect : sqliteDialect;
+}
+
+// packages/runtime/src/database/provision/identifier.ts
+var DbError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "DbError";
+  }
+};
+var IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]{0,62}$/;
+function assertIdentifier(name) {
+  if (!IDENTIFIER_PATTERN.test(name)) {
+    throw new DbError(
+      400,
+      "DB_UNSAFE_OP",
+      `\u975E\u6CD5\u6807\u8BC6\u7B26 "${name.slice(0, 32)}"\uFF1A\u4EC5\u5141\u8BB8\u5B57\u6BCD / \u4E0B\u5212\u7EBF\u5F00\u5934\u7684\u5B57\u6BCD\u6570\u5B57\u4E0B\u5212\u7EBF\u7EC4\u5408`
+    );
+  }
+}
+function quoteIdentifier(name) {
+  assertIdentifier(name);
+  return `"${name.replace(/"/g, '""')}"`;
+}
+
+// packages/runtime/src/database/builder/guards.ts
+function unsafeOperation(message) {
+  return new DbError(400, "DB_UNSAFE_OP", message);
+}
+function stripLiterals(sql) {
+  return sql.replace(/'[^']*(?:''[^']*)*'/g, "").replace(/"[^"]*(?:""[^"]*)*"/g, "").replace(/--[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+}
+function assertReadOnlyQuery(sql) {
+  const stripped = stripLiterals(sql);
+  if (stripped.includes(";")) {
+    throw unsafeOperation("\u4EC5\u5141\u8BB8\u5355\u6761\u8BED\u53E5\uFF0C\u7981\u6B62\u591A\u8BED\u53E5\u5806\u53E0");
+  }
+  const head = stripped.trim().replace(/^\(+/, "").trim().toUpperCase();
+  if (!head.startsWith("SELECT") && !head.startsWith("WITH")) {
+    throw unsafeOperation("cloud.db.query \u4EC5\u5141\u8BB8\u53EA\u8BFB\u67E5\u8BE2\uFF08SELECT / WITH\uFF09");
+  }
+  if (/ATTACH|DETACH/.test(stripped.toUpperCase())) {
+    throw unsafeOperation("\u7981\u6B62\u8DE8\u5E93\u64CD\u4F5C\uFF08ATTACH / DETACH\uFF09");
+  }
+  if (/SQLITE_\w+/i.test(stripped)) {
+    throw unsafeOperation("\u7981\u6B62\u8BBF\u95EE\u7CFB\u7EDF\u8868\uFF08sqlite_*\uFF09");
+  }
+}
+
+// packages/runtime/src/database/builder/owned.ts
+var OWNED_PK = "id";
+var OWNED_OWNER_KEY = "__owner_key";
+var CHANGE_LOG_PREFIX = "_adep_changes_";
+function changeLogTable(table) {
+  const name = `${CHANGE_LOG_PREFIX}${table}`;
+  assertIdentifier(name);
+  return name;
+}
+function assertUserColumn(name) {
+  assertIdentifier(name);
+  if (name.startsWith("__") && name !== OWNED_OWNER_KEY) {
+    throw new DbError(400, "DB_UNSAFE_OP", `\u4FDD\u7559\u524D\u7F00 "__" \u7684\u5217\u540D\u4E0D\u88AB\u5141\u8BB8\uFF1A${name.slice(0, 32)}`);
+  }
+  if (name.startsWith("_adep_")) {
+    throw new DbError(
+      400,
+      "DB_UNSAFE_OP",
+      `\u5E73\u53F0\u4FDD\u7559\u6BB5 "_adep_" \u7684\u5217\u540D\u4E0D\u88AB\u5141\u8BB8\uFF1A${name.slice(0, 32)}`
+    );
+  }
+}
+async function hasChangeLog(driver, table) {
+  if (driver.engine === "pg") {
+    return await driver.get(
+      "SELECT 1 FROM information_schema.tables WHERE table_schema = current_schema() AND table_name = $1",
+      [changeLogTable(table)]
+    ) !== null;
+  }
+  return await driver.get("SELECT 1 AS x FROM sqlite_master WHERE type = ? AND name = ?", [
+    "table",
+    changeLogTable(table)
+  ]) !== null;
+}
+async function assertOwned(driver, table) {
+  if (!await hasChangeLog(driver, table)) {
+    throw unsafeOperation(`\u8868 "${table}" \u4E0D\u662F owned \u8868\uFF08\u7F3A\u5C11\u53D8\u66F4\u6D41\u8868 ${changeLogTable(table)}\uFF09`);
+  }
+}
+async function appendChange(driver, table, op, id, ownerKey, before, after) {
+  const ph = dialectFor(driver).placeholder;
+  await driver.run(
+    `INSERT INTO ${quoteIdentifier(changeLogTable(table))} ("ts","op","id","__owner_key","before","after") VALUES (${ph(0)},${ph(1)},${ph(2)},${ph(3)},${ph(4)},${ph(5)})`,
+    [
+      (/* @__PURE__ */ new Date()).toISOString(),
+      op,
+      id,
+      ownerKey,
+      before === null ? null : JSON.stringify(before),
+      after === null ? null : JSON.stringify(after)
+    ]
+  );
+}
+async function runOwnedWrite(driver, fn) {
+  await driver.run("SAVEPOINT _adep_change");
+  try {
+    await fn(driver);
+    await driver.run("RELEASE SAVEPOINT _adep_change");
+  } catch (error) {
+    await driver.run("ROLLBACK TO SAVEPOINT _adep_change");
+    await driver.run("RELEASE SAVEPOINT _adep_change");
+    throw error;
+  }
+}
+function parseChange(row) {
+  const before = row["before"];
+  const after = row["after"];
+  return {
+    seq: Number(row["seq"]),
+    ts: String(row["ts"]),
+    op: row["op"],
+    id: String(row["id"]),
+    ownerKey: row["__owner_key"] === null || row["__owner_key"] === void 0 ? null : String(row["__owner_key"]),
+    before: before === null || before === void 0 ? null : JSON.parse(String(before)),
+    after: after === null || after === void 0 ? null : JSON.parse(String(after))
+  };
+}
+async function readChanges(driver, table, query = {}) {
+  await assertOwned(driver, table);
+  const ph = dialectFor(driver).placeholder;
+  const params = [];
+  const conditions = [];
+  if (query.afterSeq !== void 0) {
+    if (!Number.isInteger(query.afterSeq) || query.afterSeq < 0) {
+      throw unsafeOperation("afterSeq \u5FC5\u987B\u662F\u975E\u8D1F\u6574\u6570");
+    }
+    conditions.push(`"seq" > ${ph(params.length)}`);
+    params.push(query.afterSeq);
+  }
+  if (query.ownerKey !== void 0) {
+    if (query.ownerKey === null) {
+      conditions.push('"__owner_key" IS NULL');
+    } else {
+      conditions.push(`"__owner_key" = ${ph(params.length)}`);
+      params.push(query.ownerKey);
+    }
+  }
+  if (query.limit !== void 0) {
+    if (!Number.isInteger(query.limit) || query.limit < 0) {
+      throw unsafeOperation("limit \u5FC5\u987B\u662F\u975E\u8D1F\u6574\u6570");
+    }
+  }
+  let sql = `SELECT "seq","ts","op","id","__owner_key","before","after" FROM ` + quoteIdentifier(changeLogTable(table));
+  if (conditions.length > 0) sql += ` WHERE ${conditions.join(" AND ")}`;
+  sql += ' ORDER BY "seq" ASC';
+  if (query.limit !== void 0) {
+    sql += ` LIMIT ${ph(params.length)}`;
+    params.push(query.limit);
+  }
+  const rows = await driver.all(sql, params);
+  return rows.map(parseChange);
+}
+
+// packages/runtime/src/database/builder/ulid.ts
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var TIME_LEN = 10;
+var RANDOM_LEN = 16;
+var lastTime = 0;
+var lastRandom = "";
+function encodeTime(now) {
+  let ts = Math.trunc(now);
+  let out = "";
+  for (let i = 0; i < TIME_LEN; i++) {
+    out = ENCODING[ts % 32] + out;
+    ts = Math.floor(ts / 32);
+  }
+  return out;
+}
+function encodeRandom(bytes) {
+  let out = "";
+  let buffer = 0;
+  let bits = 0;
+  for (const byte of bytes) {
+    buffer = buffer << 8 | byte;
+    bits += 8;
+    while (bits >= 5) {
+      out += ENCODING[buffer >>> bits - 5 & 31];
+      bits -= 5;
+    }
+  }
+  return out.slice(0, RANDOM_LEN);
+}
+function incrBase32(prev) {
+  const chars = prev.split("");
+  for (let i = chars.length - 1; i >= 0; i--) {
+    const idx = ENCODING.indexOf(chars[i]);
+    if (idx < 31) {
+      chars[i] = ENCODING[idx + 1];
+      return chars.join("");
+    }
+    chars[i] = ENCODING[0];
+  }
+  return chars.join("");
+}
+function randomFill(bytes) {
+  const source = globalThis.crypto;
+  if (source !== void 0 && typeof source.getRandomValues === "function") {
+    return source.getRandomValues(bytes);
+  }
+  for (let i = 0; i < bytes.length; i += 1) {
+    bytes[i] = Math.floor(Math.random() * 256);
+  }
+  return bytes;
+}
+function ulid(now = Date.now()) {
+  const time = encodeTime(now);
+  let random;
+  if (now === lastTime) {
+    random = incrBase32(lastRandom);
+  } else {
+    lastTime = now;
+    const bytes = new Uint8Array(10);
+    randomFill(bytes);
+    random = encodeRandom(bytes);
+  }
+  lastRandom = random;
+  return time + random;
+}
+
+// packages/runtime/src/database/builder/table.ts
+var OPERATORS = /* @__PURE__ */ new Set([
+  "=",
+  "!=",
+  ">",
+  ">=",
+  "<",
+  "<=",
+  "like",
+  "in",
+  "not in"
+]);
+var LIST_OPERATORS = /* @__PURE__ */ new Set(["in", "not in"]);
+function pushParam(params, dialect, value) {
+  params.push(value);
+  return dialect.placeholder(params.length - 1);
+}
+function assertHasWhere(state) {
+  if (state.wheres.length === 0) {
+    throw unsafeOperation("update / delete \u5FC5\u987B\u5148\u6307\u5B9A where\uFF08\u9632\u6B62\u5168\u8868\u8BEF\u6539 / \u8BEF\u5220\uFF09");
+  }
+}
+async function resolveOwned(state, driver) {
+  if (state.owned === true) {
+    await assertOwned(driver, state.table);
+    return true;
+  }
+  return state.owned ?? await hasChangeLog(driver, state.table);
+}
+function toOwnerKey(row) {
+  const value = row[OWNED_OWNER_KEY];
+  return value === null || value === void 0 ? null : String(value);
+}
+function ownedInsertRow(row) {
+  const effective = { ...row };
+  if (effective[OWNED_PK] === void 0) {
+    effective[OWNED_PK] = ulid();
+  }
+  return effective;
+}
+async function captureBeforeRows(state, dialect, driver) {
+  const select = compileSelect({ ...state, columns: [] }, dialect);
+  return driver.all(select.sql, select.params);
+}
+function compileWhere(wheres, dialect, params) {
+  return wheres.map((where) => {
+    const quoted = dialect.quote(where.column);
+    if (LIST_OPERATORS.has(where.operator)) {
+      const values = where.value;
+      if (values.length === 0) {
+        throw unsafeOperation(`${where.operator.toUpperCase()} \u81F3\u5C11\u9700\u8981\u4E00\u4E2A\u503C`);
+      }
+      const marks = values.map((value2) => pushParam(params, dialect, value2));
+      return `${quoted} ${where.operator.toUpperCase()} (${marks.join(", ")})`;
+    }
+    const value = where.value;
+    if (value === null) {
+      if (where.operator === "=") return `${quoted} IS NULL`;
+      if (where.operator === "!=") return `${quoted} IS NOT NULL`;
+    }
+    const mark = pushParam(params, dialect, value);
+    return `${quoted} ${where.operator} ${mark}`;
+  }).join(" AND ");
+}
+function compileSelect(state, dialect) {
+  const params = [];
+  const columns = state.columns.length > 0 ? state.columns.map((column) => dialect.quote(column)).join(", ") : "*";
+  let sql = `SELECT ${columns} FROM ${dialect.quote(state.table)}`;
+  if (state.wheres.length > 0) {
+    sql += ` WHERE ${compileWhere(state.wheres, dialect, params)}`;
+  }
+  if (state.orderBys.length > 0) {
+    sql += ` ORDER BY ${state.orderBys.map((order) => `${dialect.quote(order.column)} ${order.direction.toUpperCase()}`).join(", ")}`;
+  }
+  if (state.limit !== void 0) sql += ` LIMIT ${pushParam(params, dialect, state.limit)}`;
+  if (state.offset !== void 0) sql += ` OFFSET ${pushParam(params, dialect, state.offset)}`;
+  return { sql, params };
+}
+function compileCount(state, dialect) {
+  const params = [];
+  let sql = `SELECT count(*) AS n FROM ${dialect.quote(state.table)}`;
+  if (state.wheres.length > 0) {
+    sql += ` WHERE ${compileWhere(state.wheres, dialect, params)}`;
+  }
+  return { sql, params };
+}
+function compileInsert(table, row, dialect) {
+  const entries = Object.entries(row);
+  if (entries.length === 0) {
+    throw unsafeOperation("insert \u81F3\u5C11\u9700\u8981\u4E00\u4E2A\u5B57\u6BB5");
+  }
+  const params = [];
+  const columns = entries.map(([name]) => {
+    assertUserColumn(name);
+    return dialect.quote(name);
+  }).join(", ");
+  const marks = entries.map(([, value]) => pushParam(params, dialect, value));
+  return {
+    sql: `INSERT INTO ${dialect.quote(table)} (${columns}) VALUES (${marks.join(", ")})`,
+    params
+  };
+}
+function compileInsertMany(table, rows, dialect) {
+  if (rows.length === 0) {
+    throw unsafeOperation("insertMany \u81F3\u5C11\u9700\u8981\u4E00\u884C");
+  }
+  const columns = [...new Set(rows.flatMap((row) => Object.keys(row)))];
+  if (columns.length === 0) {
+    throw unsafeOperation("insertMany \u81F3\u5C11\u9700\u8981\u4E00\u4E2A\u5B57\u6BB5");
+  }
+  columns.forEach(assertUserColumn);
+  const params = [];
+  const quoted = columns.map((column) => dialect.quote(column)).join(", ");
+  const valueGroups = rows.map((row) => {
+    const marks = columns.map((column) => pushParam(params, dialect, row[column] ?? null));
+    return `(${marks.join(", ")})`;
+  });
+  return {
+    sql: `INSERT INTO ${dialect.quote(table)} (${quoted}) VALUES ${valueGroups.join(", ")}`,
+    params
+  };
+}
+function compileUpdate(table, wheres, values, dialect) {
+  const entries = Object.entries(values);
+  if (entries.length === 0) {
+    throw unsafeOperation("update \u81F3\u5C11\u9700\u8981\u4E00\u4E2A\u5B57\u6BB5");
+  }
+  const params = [];
+  const sets = entries.map(([name, value]) => {
+    assertUserColumn(name);
+    return `${dialect.quote(name)} = ${pushParam(params, dialect, value)}`;
+  }).join(", ");
+  const where = compileWhere(wheres, dialect, params);
+  return { sql: `UPDATE ${dialect.quote(table)} SET ${sets} WHERE ${where}`, params };
+}
+function compileDelete(table, wheres, dialect) {
+  const params = [];
+  const where = compileWhere(wheres, dialect, params);
+  return { sql: `DELETE FROM ${dialect.quote(table)} WHERE ${where}`, params };
+}
+function createTableBuilder(table, driver, dialect, options = {}) {
+  assertIdentifier(table);
+  const guardWrite = options.guardWrite ?? (() => void 0);
+  const initialState = {
+    table,
+    columns: [],
+    wheres: [],
+    orderBys: [],
+    limit: void 0,
+    offset: void 0
+  };
+  const build = (state) => {
+    const derived = (patch) => build({ ...state, ...patch });
+    return {
+      select(...columns) {
+        columns.forEach(assertUserColumn);
+        return derived({ columns });
+      },
+      owned() {
+        return derived({ owned: true });
+      },
+      where(column, operatorOrValue, maybeValue) {
+        assertUserColumn(column);
+        let operator;
+        let value;
+        if (maybeValue !== void 0) {
+          operator = operatorOrValue;
+          if (!OPERATORS.has(operator)) {
+            throw unsafeOperation(`\u4E0D\u652F\u6301\u7684\u64CD\u4F5C\u7B26 "${operator}"`);
+          }
+          if (LIST_OPERATORS.has(operator) && !Array.isArray(maybeValue)) {
+            throw unsafeOperation(`${operator.toUpperCase()} \u9700\u8981\u6570\u7EC4\u503C`);
+          }
+          value = maybeValue;
+        } else {
+          operator = "=";
+          value = operatorOrValue;
+        }
+        return derived({ wheres: [...state.wheres, { column, operator, value }] });
+      },
+      orderBy(column, direction = "asc") {
+        assertUserColumn(column);
+        if (direction !== "asc" && direction !== "desc") {
+          throw unsafeOperation("orderBy \u65B9\u5411\u4EC5\u652F\u6301 asc / desc");
+        }
+        return derived({ orderBys: [...state.orderBys, { column, direction }] });
+      },
+      limit(n) {
+        if (!Number.isInteger(n) || n < 0) {
+          throw unsafeOperation("limit \u5FC5\u987B\u662F\u975E\u8D1F\u6574\u6570");
+        }
+        return derived({ limit: n });
+      },
+      offset(n) {
+        if (!Number.isInteger(n) || n < 0) {
+          throw unsafeOperation("offset \u5FC5\u987B\u662F\u975E\u8D1F\u6574\u6570");
+        }
+        return derived({ offset: n });
+      },
+      async get() {
+        const compiled = compileSelect(state, dialect);
+        return driver.all(compiled.sql, compiled.params);
+      },
+      async first() {
+        const compiled = compileSelect({ ...state, limit: 1 }, dialect);
+        return driver.get(compiled.sql, compiled.params);
+      },
+      async count() {
+        const compiled = compileCount(state, dialect);
+        const row = await driver.get(compiled.sql, compiled.params);
+        return row === null ? 0 : Number(row["n"]);
+      },
+      async insert(row) {
+        guardWrite();
+        Object.keys(row).forEach(assertUserColumn);
+        if (await resolveOwned(state, driver)) {
+          const effective = ownedInsertRow(row);
+          const ownerKey = toOwnerKey(effective);
+          const compiled2 = compileInsert(state.table, effective, dialect);
+          await runOwnedWrite(driver, async (d) => {
+            await d.run(compiled2.sql, compiled2.params);
+            await appendChange(
+              d,
+              state.table,
+              "insert",
+              String(effective[OWNED_PK]),
+              ownerKey,
+              null,
+              effective
+            );
+          });
+          return;
+        }
+        const compiled = compileInsert(state.table, row, dialect);
+        await driver.run(compiled.sql, compiled.params);
+      },
+      async insertMany(rows) {
+        guardWrite();
+        const insertColumns = [...new Set(rows.flatMap((row) => Object.keys(row)))];
+        insertColumns.forEach(assertUserColumn);
+        if (await resolveOwned(state, driver)) {
+          const effectiveRows = rows.map(ownedInsertRow);
+          const compiled2 = compileInsertMany(state.table, effectiveRows, dialect);
+          await runOwnedWrite(driver, async (d) => {
+            await d.run(compiled2.sql, compiled2.params);
+            for (const effective of effectiveRows) {
+              await appendChange(
+                d,
+                state.table,
+                "insert",
+                String(effective[OWNED_PK]),
+                toOwnerKey(effective),
+                null,
+                effective
+              );
+            }
+          });
+          return;
+        }
+        const compiled = compileInsertMany(state.table, rows, dialect);
+        await driver.run(compiled.sql, compiled.params);
+      },
+      async update(values) {
+        guardWrite();
+        assertHasWhere(state);
+        Object.keys(values).forEach(assertUserColumn);
+        if (await resolveOwned(state, driver)) {
+          const before = await captureBeforeRows(state, dialect, driver);
+          const compiled2 = compileUpdate(state.table, state.wheres, values, dialect);
+          await runOwnedWrite(driver, async (d) => {
+            await d.run(compiled2.sql, compiled2.params);
+            for (const row of before) {
+              const after = { ...row, ...values };
+              await appendChange(
+                d,
+                state.table,
+                "update",
+                String(row[OWNED_PK]),
+                toOwnerKey(row),
+                row,
+                after
+              );
+            }
+          });
+          return before.length;
+        }
+        const compiled = compileUpdate(state.table, state.wheres, values, dialect);
+        return (await driver.run(compiled.sql, compiled.params)).changes;
+      },
+      async delete() {
+        guardWrite();
+        assertHasWhere(state);
+        if (await resolveOwned(state, driver)) {
+          const before = await captureBeforeRows(state, dialect, driver);
+          const compiled2 = compileDelete(state.table, state.wheres, dialect);
+          await runOwnedWrite(driver, async (d) => {
+            await d.run(compiled2.sql, compiled2.params);
+            for (const row of before) {
+              await appendChange(
+                d,
+                state.table,
+                "delete",
+                String(row[OWNED_PK]),
+                toOwnerKey(row),
+                row,
+                null
+              );
+            }
+          });
+          return before.length;
+        }
+        const compiled = compileDelete(state.table, state.wheres, dialect);
+        return (await driver.run(compiled.sql, compiled.params)).changes;
+      }
+    };
+  };
+  return build(initialState);
+}
+
+// packages/runtime/src/database/builder/index.ts
+var TX_STATES = /* @__PURE__ */ new WeakMap();
+function createCloudDb(driver, options = {}) {
+  const dialect = options.dialect ?? dialectFor(driver);
+  let txState = TX_STATES.get(driver);
+  if (txState === void 0) {
+    txState = { inTransaction: false };
+    TX_STATES.set(driver, txState);
+  }
+  const makeHandle = (handleOptions) => {
+    const guardWrite = () => {
+      if (txState !== void 0 && txState.inTransaction && !handleOptions.allowWriteDuringTx) {
+        throw unsafeOperation("\u4E8B\u52A1\u8FDB\u884C\u4E2D\uFF1A\u7981\u6B62\u5728\u4E8B\u52A1\u5916\u5BF9\u540C\u4E00\u9879\u76EE\u5E93\u6267\u884C\u5199\u64CD\u4F5C");
+      }
+    };
+    const handle = {
+      table(name) {
+        return createTableBuilder(name, driver, dialect, { guardWrite });
+      },
+      async transaction(fn) {
+        if (txState !== void 0 && txState.inTransaction) {
+          throw unsafeOperation("\u4E0D\u5141\u8BB8\u5D4C\u5957\u4E8B\u52A1\uFF1A\u4E8B\u52A1\u5185\u7981\u6B62\u518D\u6B21\u8C03\u7528 transaction()");
+        }
+        txState.inTransaction = true;
+        await driver.run("BEGIN");
+        const txHandle = makeHandle({ allowWriteDuringTx: true });
+        try {
+          const result = await fn(txHandle);
+          await driver.run("COMMIT");
+          return result;
+        } catch (error) {
+          await driver.run("ROLLBACK");
+          throw error;
+        } finally {
+          txState.inTransaction = false;
+        }
+      },
+      async query(sql, params) {
+        if (!Array.isArray(params)) {
+          throw unsafeOperation("query \u7684 params \u5FC5\u987B\u63D0\u4F9B\uFF08\u65E0\u53C2\u4F20 []\uFF09");
+        }
+        guardWrite();
+        assertReadOnlyQuery(sql);
+        return driver.all(sql, params);
+      },
+      async changes(table, query = {}) {
+        return readChanges(driver, table, query);
+      }
+    };
+    return handle;
+  };
+  return makeHandle({ allowWriteDuringTx: false });
+}
+
+// packages/runtime/src/database/sdk/cloud.ts
+var CLOUD_DB_SPEC = {
+  kind: "cloud-db",
+  rootMethod: "table",
+  stepMethods: ["select", "where", "orderBy", "limit", "offset"],
+  terminalMethods: ["get", "first", "count", "insert", "insertMany", "update", "delete"],
+  directMethods: ["query", "changes"],
+  transactionMethod: "transaction"
+};
+var WRITE_TERMINALS = /* @__PURE__ */ new Set(["insert", "insertMany", "update", "delete"]);
+function errorWithCode(error) {
+  const code = typeof error === "object" && error !== null && typeof error.code === "string" ? error.code : void 0;
+  if (code !== void 0 && error instanceof Error) {
+    return new Error(`[${code}] ${error.message}`);
+  }
+  return error;
+}
+function createDbCapability(driver, options = {}) {
+  const db = createCloudDb(driver);
+  const activeTxs = /* @__PURE__ */ new Map();
+  const guardTxWrite = (txId, terminal) => {
+    if (txId === void 0) {
+      if (activeTxs.size > 0 && WRITE_TERMINALS.has(terminal)) {
+        throw unsafeOperation("\u4E8B\u52A1\u8FDB\u884C\u4E2D\uFF1A\u7981\u6B62\u5728\u4E8B\u52A1\u5916\u5BF9\u540C\u4E00\u9879\u76EE\u5E93\u6267\u884C\u5199\u64CD\u4F5C");
+      }
+      return;
+    }
+    if (!activeTxs.has(txId)) {
+      throw unsafeOperation("\u5F15\u7528\u7684\u4E8B\u52A1\u5DF2\u7ED3\u675F\u6216\u4E0D\u5B58\u5728");
+    }
+  };
+  const runChain = async (request) => {
+    const tableName = request.rootArgs[0];
+    if (typeof tableName !== "string" && typeof tableName !== "number") {
+      throw unsafeOperation("table \u9700\u8981\u8868\u540D\u5B57\u7B26\u4E32");
+    }
+    let builder = db.table(String(tableName));
+    for (const step of request.steps) {
+      const invoke = builder[step.method];
+      if (typeof invoke !== "function") {
+        throw unsafeOperation(`\u4E91\u6570\u636E\u5E93\u4E0D\u652F\u6301\u94FE\u5F0F\u65B9\u6CD5 "${String(step.method)}"`);
+      }
+      builder = invoke(...step.args);
+    }
+    guardTxWrite(request.txId, request.terminal);
+    if (WRITE_TERMINALS.has(request.terminal) && options.beforeWrite !== void 0) {
+      await options.beforeWrite(driver);
+    }
+    const terminal = builder[request.terminal];
+    if (typeof terminal !== "function") {
+      throw unsafeOperation(`\u4E91\u6570\u636E\u5E93\u4E0D\u652F\u6301\u7EC8\u503C\u65B9\u6CD5 "${request.terminal}"`);
+    }
+    return terminal(...request.terminalArgs);
+  };
+  const handler = async (method, args) => {
+    try {
+      switch (method) {
+        case DB_RPC.query: {
+          const [sql, params] = args;
+          return await db.query(sql, params);
+        }
+        case DB_RPC.changes: {
+          const [table, query] = args;
+          return await db.changes(table, query);
+        }
+        case DB_RPC.begin: {
+          if (activeTxs.size > 0) throw unsafeOperation("\u4E0D\u5141\u8BB8\u5D4C\u5957\u4E8B\u52A1");
+          await driver.run("BEGIN");
+          const txId = crypto.randomUUID();
+          activeTxs.set(txId, true);
+          return txId;
+        }
+        case DB_RPC.commit: {
+          const [txId] = args;
+          if (!activeTxs.has(txId)) throw unsafeOperation("\u5F15\u7528\u7684\u4E8B\u52A1\u5DF2\u7ED3\u675F\u6216\u4E0D\u5B58\u5728");
+          activeTxs.delete(txId);
+          await driver.run("COMMIT");
+          return void 0;
+        }
+        case DB_RPC.rollback: {
+          const [txId] = args;
+          if (activeTxs.has(txId)) {
+            activeTxs.delete(txId);
+            await driver.run("ROLLBACK");
+          }
+          return void 0;
+        }
+        case DB_RPC.chain: {
+          const request = args[0];
+          return await runChain(request);
+        }
+        default:
+          throw new Error(`\u672A\u77E5\u7684 cloud.db \u65B9\u6CD5 "${String(method)}"`);
+      }
+    } catch (error) {
+      throw errorWithCode(error);
+    }
+  };
+  return {
+    capabilities: [{ name: "db", value: { [CHAIN_CAPABILITY_KEY]: CLOUD_DB_SPEC } }],
+    rpcHandlers: { db: handler }
+  };
+}
+
+// packages/cli/src/sim/sql-engine.ts
+var SimDbError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "SimDbError";
+  }
+};
+var ParamCursor = class {
+  constructor(params) {
+    this.params = params;
+  }
+  index = 0;
+  take() {
+    const v = this.params[this.index];
+    this.index += 1;
+    return v ?? null;
+  }
+};
+function ident(raw) {
+  return raw.trim().replace(/^"|"$/g, "").trim();
+}
+function toNumber(raw) {
+  const t = raw.trim();
+  if (t === "?") return null;
+  const n = Number(t);
+  return Number.isNaN(n) ? null : n;
+}
+function stripQuotes(raw) {
+  const t = raw.trim();
+  if (/^'.*'$/.test(t)) return t.slice(1, -1);
+  if (/^".*"$/.test(t)) return t.slice(1, -1);
+  return t;
+}
+function parseCreateTable(ddl) {
+  const m = /^CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?((?:"[^"]+")|([A-Za-z_][A-Za-z0-9_]*))\s*\(([\s\S]*)\)$/i.exec(
+    ddl.trim()
+  );
+  if (m === null) return null;
+  const name = ident(m[1]);
+  const body = m[2];
+  const columns = [];
+  for (const part of body.split(",")) {
+    const tokens = part.trim().split(/\s+/);
+    const colName = ident(tokens[0] ?? "");
+    const type = (tokens[1] ?? "TEXT").toUpperCase();
+    const primaryKey = tokens.includes("PRIMARY") && tokens.includes("KEY");
+    const autoincrement = primaryKey && tokens.includes("AUTOINCREMENT");
+    columns.push({ name: colName, type, primaryKey, autoincrement });
+  }
+  return { name, columns };
+}
+function parseWhereClauses(whereRaw, cursor) {
+  const clauses = [];
+  for (const part of whereRaw.split(/\s+AND\s+/i)) {
+    const t = part.trim();
+    if (t.length === 0) continue;
+    if (/\bIS\s+NULL\b/i.test(t)) {
+      const col2 = ident(t.split(/\s+IS\s+NULL\b/i)[0] ?? "");
+      clauses.push({ column: col2, operator: "IS NULL", value: null, list: false });
+      continue;
+    }
+    if (/\bIS\s+NOT\s+NULL\b/i.test(t)) {
+      const col2 = ident(t.split(/\s+IS\s+NOT\s+NULL\b/i)[0] ?? "");
+      clauses.push({ column: col2, operator: "IS NOT NULL", value: null, list: false });
+      continue;
+    }
+    const opMatch = /^\s*((?:"[^"]+")|([A-Za-z_][A-Za-z0-9_]*))\s*(=|!=|>=|<=|>|<|like|in|not\s+in)\s*(.+)$/i.exec(
+      t
+    );
+    if (opMatch === null) continue;
+    const col = ident(opMatch[1] ?? "");
+    const op = (opMatch[3] ?? opMatch[2] ?? "").toLowerCase();
+    const rhs = (opMatch[4] ?? "").trim();
+    if (op === "in" || op === "not in") {
+      const inner = rhs.replace(/^\(|\)$/g, "");
+      const items = splitListItems(inner);
+      const list = items.map((item) => {
+        if (item.trim() === "?") return cursor.take();
+        return stripQuotes(item);
+      });
+      clauses.push({ column: col, operator: op, value: list, list: true });
+      continue;
+    }
+    let value;
+    if (rhs === "?") {
+      value = cursor.take();
+    } else {
+      value = stripQuotes(rhs);
+    }
+    clauses.push({ column: col, operator: op, value, list: false });
+  }
+  return clauses;
+}
+function matchWhere(clauses, row) {
+  return clauses.every((c) => matchValue(row[c.column], c));
+}
+function splitListItems(inner) {
+  const items = [];
+  let depth = 0;
+  let buffer = "";
+  for (let i = 0; i < inner.length; i += 1) {
+    const ch = inner[i];
+    if (ch === "(") depth += 1;
+    else if (ch === ")") depth -= 1;
+    if (ch === "," && depth === 0) {
+      items.push(buffer);
+      buffer = "";
+    } else {
+      buffer += ch;
+    }
+  }
+  items.push(buffer);
+  return items;
+}
+function matchValue(value, clause) {
+  const op = clause.operator;
+  if (op === "IS NULL") return value === null || value === void 0;
+  if (op === "IS NOT NULL") return value !== null && value !== void 0;
+  if (op === "in") return clause.value.some((item) => value === item);
+  if (op === "not in") return !clause.value.some((item) => value === item);
+  if (op === "like") {
+    if (typeof value !== "string") return false;
+    const pattern = String(clause.value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/%/g, ".*").replace(/_/g, ".");
+    return new RegExp(`^${pattern}$`, "s").test(value);
+  }
+  const left = value;
+  const right = clause.value;
+  switch (op) {
+    case "=":
+      return left === right;
+    case "!=":
+      return left !== right;
+    case ">":
+      return left !== null && right !== null && left > right;
+    case ">=":
+      return left !== null && right !== null && left >= right;
+    case "<":
+      return left !== null && right !== null && left < right;
+    case "<=":
+      return left !== null && right !== null && left <= right;
+    default:
+      return false;
+  }
+}
+function assertReadOnly(sql) {
+  const stripped = sql.replace(/'[^']*(?:''[^']*)*'/g, "").replace(/"[^"]*(?:""[^"]*)*"/g, "").replace(/--[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+  if (stripped.includes(";")) throw new SimDbError("DB_UNSAFE_OP", "\u4EC5\u5141\u8BB8\u5355\u6761\u8BED\u53E5\uFF0C\u7981\u6B62\u591A\u8BED\u53E5\u5806\u53E0");
+  const head = stripped.trim().replace(/^\(+/, "").trim().toUpperCase();
+  if (!head.startsWith("SELECT") && !head.startsWith("WITH")) {
+    throw new SimDbError("DB_UNSAFE_OP", "cloud.db.query \u4EC5\u5141\u8BB8\u53EA\u8BFB\u67E5\u8BE2\uFF08SELECT / WITH\uFF09");
+  }
+  if (/ATTACH|DETACH/.test(stripped.toUpperCase())) {
+    throw new SimDbError("DB_UNSAFE_OP", "\u7981\u6B62\u8DE8\u5E93\u64CD\u4F5C\uFF08ATTACH / DETACH\uFF09");
+  }
+  if (/SQLITE_\w+/i.test(stripped) && !/SQLITE_MASTER\b/i.test(stripped)) {
+    throw new SimDbError("DB_UNSAFE_OP", "\u7981\u6B62\u8BBF\u95EE\u7CFB\u7EDF\u8868\uFF08sqlite_*\uFF09");
+  }
+}
+var SimSqlEngine = class {
+  tables = {};
+  storage;
+  memoryOnly;
+  savepointDepth = 0;
+  txSnapshot = null;
+  constructor(options = {}) {
+    this.storage = options.storage ?? { load: async () => null, save: async () => void 0 };
+    this.memoryOnly = options.memoryOnly ?? false;
+  }
+  async load() {
+    if (this.memoryOnly) return;
+    const persisted = await this.storage.load();
+    if (persisted !== null) this.tables = persisted;
+  }
+  async persist() {
+    if (this.memoryOnly) return;
+    await this.storage.save(this.tables);
+  }
+  ensureTable(name) {
+    let table = this.tables[name];
+    if (table === void 0) {
+      table = { columns: [], rows: [], nextAutoincrement: 1 };
+      this.tables[name] = table;
+    }
+    return table;
+  }
+  applyAutoincrement(table, row) {
+    const pk = table.columns.find((c) => c.primaryKey && c.autoincrement);
+    if (pk === void 0) return;
+    const val = row[pk.name];
+    if (val !== null && val !== void 0) {
+      const n = Number(val);
+      if (Number.isInteger(n) && n >= table.nextAutoincrement) table.nextAutoincrement = n + 1;
+      return;
+    }
+    row[pk.name] = table.nextAutoincrement;
+    table.nextAutoincrement += 1;
+  }
+  catalog() {
+    const out = [];
+    for (const [name] of Object.entries(this.tables)) {
+      out.push({ type: "table", name, tbl_name: name });
+    }
+    return out;
+  }
+  async run(sql, params = []) {
+    const stmt = sql.trim();
+    if (/^BEGIN\s*$/i.test(stmt)) {
+      this.txSnapshot = structuredClone(this.tables);
+      return { changes: 0 };
+    }
+    if (/^COMMIT\s*$/i.test(stmt)) {
+      this.txSnapshot = null;
+      await this.persist();
+      return { changes: 0 };
+    }
+    if (/^ROLLBACK\s*$/i.test(stmt)) {
+      if (this.txSnapshot !== null) {
+        this.tables = this.txSnapshot;
+        this.txSnapshot = null;
+      }
+      await this.persist();
+      return { changes: 0 };
+    }
+    if (/^SAVEPOINT\s+/i.test(stmt)) {
+      this.savepointDepth += 1;
+      return { changes: 0 };
+    }
+    if (/^RELEASE\s+SAVEPOINT\s+/i.test(stmt)) {
+      this.savepointDepth = Math.max(0, this.savepointDepth - 1);
+      return { changes: 0 };
+    }
+    if (/^ROLLBACK\s+TO\s+SAVEPOINT\s+/i.test(stmt)) return { changes: 0 };
+    if (/^CREATE\s+TABLE/i.test(stmt)) {
+      const parsed = parseCreateTable(stmt);
+      if (parsed === null) throw new SimDbError("DB_UNSAFE_OP", `\u65E0\u6CD5\u89E3\u6790\u5EFA\u8868\u8BED\u53E5`);
+      if (this.tables[parsed.name] === void 0) {
+        this.tables[parsed.name] = { columns: parsed.columns, rows: [], nextAutoincrement: 1 };
+        await this.persist();
+      }
+      return { changes: 0 };
+    }
+    if (/^INSERT\s+INTO/i.test(stmt)) return this.execInsert(stmt, params);
+    if (/^UPDATE\s+/i.test(stmt)) return this.execUpdate(stmt, params);
+    if (/^DELETE\s+FROM/i.test(stmt)) return this.execDelete(stmt, params);
+    throw new SimDbError("DB_UNSAFE_OP", `sim SQL \u5F15\u64CE\u4E0D\u652F\u6301\u8BE5\u8BED\u53E5`);
+  }
+  execInsert(sql, params) {
+    const match = /^INSERT\s+INTO\s+((?:"[^"]+")|([A-Za-z_][A-Za-z0-9_]*))\s*\(([^)]*)\)\s*VALUES\s*([\s\S]+)$/i.exec(
+      sql
+    );
+    if (match === null) throw new SimDbError("DB_UNSAFE_OP", "\u65E0\u6CD5\u89E3\u6790 INSERT");
+    const tableName = ident(match[1]);
+    const cols = match[3].split(",").map(ident);
+    const valueBody = match[4].trim();
+    const cursor = new ParamCursor(params);
+    const table = this.ensureTable(tableName);
+    let inserted = 0;
+    for (const group of splitListItems(valueBody)) {
+      const inner = group.trim().replace(/^\(|\)$/g, "");
+      const values = splitListItems(inner).map(
+        (item) => item.trim() === "?" ? cursor.take() : stripQuotes(item)
+      );
+      const row = {};
+      cols.forEach((col, i) => {
+        row[col] = values[i] ?? null;
+      });
+      this.applyAutoincrement(table, row);
+      table.rows.push(row);
+      inserted += 1;
+    }
+    void this.persist();
+    return { changes: inserted };
+  }
+  execUpdate(sql, params) {
+    const match = /^UPDATE\s+((?:"[^"]+")|([A-Za-z_][A-Za-z0-9_]*))\s+SET\s+([\s\S]+?)\s+WHERE\s+([\s\S]+)$/i.exec(
+      sql
+    );
+    if (match === null) throw new SimDbError("DB_UNSAFE_OP", "UPDATE \u5FC5\u987B\u5E26 WHERE");
+    const tableName = ident(match[1]);
+    const setRaw = match[3];
+    const whereRaw = match[4];
+    const cursor = new ParamCursor(params);
+    const sets = splitListItems(setRaw).map((part) => {
+      const [col, , mark] = part.trim().split(/\s+/);
+      return { col: ident(col ?? ""), mark: mark ?? "?" };
+    });
+    const table = this.ensureTable(tableName);
+    const boundSets = sets.map((set) => ({
+      col: set.col,
+      value: set.mark === "?" ? cursor.take() : stripQuotes(set.mark)
+    }));
+    const whereClauses = parseWhereClauses(whereRaw, cursor);
+    let changes = 0;
+    for (const row of table.rows) {
+      if (!matchWhere(whereClauses, row)) continue;
+      for (const set of boundSets) {
+        row[set.col] = set.value;
+      }
+      changes += 1;
+    }
+    void this.persist();
+    return { changes };
+  }
+  execDelete(sql, params) {
+    const match = /^DELETE\s+FROM\s+((?:"[^"]+")|([A-Za-z_][A-Za-z0-9_]*))\s+WHERE\s+([\s\S]+)$/i.exec(sql);
+    if (match === null) throw new SimDbError("DB_UNSAFE_OP", "DELETE \u5FC5\u987B\u5E26 WHERE");
+    const tableName = ident(match[1]);
+    const whereRaw = match[3];
+    const cursor = new ParamCursor(params);
+    const table = this.ensureTable(tableName);
+    const whereClauses = parseWhereClauses(whereRaw, cursor);
+    const keep = [];
+    let changes = 0;
+    for (const row of table.rows) {
+      if (!matchWhere(whereClauses, row)) keep.push(row);
+      else changes += 1;
+    }
+    table.rows = keep;
+    void this.persist();
+    return { changes };
+  }
+  select(sql, params) {
+    const m = /^SELECT\s+([\s\S]+?)\s+FROM\s+((?:"[^"]+")|([A-Za-z_][A-Za-z0-9_]*))([\s\S]*)$/i.exec(
+      sql.trim()
+    );
+    if (m === null) throw new SimDbError("DB_UNSAFE_OP", "\u65E0\u6CD5\u89E3\u6790 SELECT");
+    const selectRaw = m[1].trim();
+    const tableName = ident(m[2]);
+    const tail = m[4] ?? "";
+    const cursor = new ParamCursor(params);
+    if (tableName.toLowerCase() === "sqlite_master") {
+      return project(this.catalog(), selectRaw);
+    }
+    const table = this.ensureTable(tableName);
+    const whereMatch = /\bWHERE\b/i.exec(tail);
+    const orderMatch = /\bORDER\s+BY\b/i.exec(tail);
+    const limitMatch = /\bLIMIT\b/i.exec(tail);
+    const offsetMatch = /\bOFFSET\b/i.exec(tail);
+    const whereRaw = whereMatch === null ? "" : tail.slice(
+      whereMatch.index + whereMatch[0].length,
+      indexAfter(whereMatch.index, [orderMatch, limitMatch, offsetMatch], tail)
+    );
+    let rows = table.rows;
+    if (whereRaw.trim().length > 0) {
+      const clauses = parseWhereClauses(whereRaw, cursor);
+      rows = rows.filter((row) => matchWhere(clauses, row));
+    }
+    if (orderMatch !== null) {
+      const orderRaw = tail.slice(
+        orderMatch.index + orderMatch[0].length,
+        indexAfter(orderMatch.index, [limitMatch, offsetMatch], tail)
+      );
+      const oc = /^\s*((?:"[^"]+")|([A-Za-z_][A-Za-z0-9_]*))\s+(asc|desc)/i.exec(orderRaw);
+      if (oc !== null) {
+        const col = ident(oc[1]);
+        const dir = oc[3].toLowerCase();
+        rows = [...rows].toSorted((a, b) => {
+          const av = a[col];
+          const bv = b[col];
+          const cmp = av === bv ? 0 : av === null ? -1 : bv === null ? 1 : av > bv ? 1 : -1;
+          return dir === "desc" ? -cmp : cmp;
+        });
+      }
+    }
+    if (limitMatch !== null) {
+      const limRaw = tail.slice(
+        limitMatch.index + limitMatch[0].length,
+        indexAfter(limitMatch.index, [offsetMatch], tail)
+      );
+      const lim = limRaw.trim() === "?" ? cursor.take() : toNumber(limRaw);
+      if (typeof lim === "number") rows = rows.slice(0, lim);
+    }
+    if (offsetMatch !== null) {
+      const offRaw = tail.slice(
+        offsetMatch.index + offsetMatch[0].length,
+        indexAfter(offsetMatch.index, [limitMatch], tail)
+      );
+      const off = offRaw.trim() === "?" ? cursor.take() : toNumber(offRaw);
+      if (typeof off === "number") rows = rows.slice(off);
+    }
+    return project(rows, selectRaw);
+  }
+  async all(sql, params = []) {
+    assertReadOnly(sql);
+    return this.select(sql, params);
+  }
+  async get(sql, params = []) {
+    assertReadOnly(sql);
+    return this.select(sql, params)[0] ?? null;
+  }
+  async close() {
+    void this.savepointDepth;
+  }
+};
+function indexAfter(start, matches, tail) {
+  const candidates = matches.filter((x) => x !== null && x.index > start).map((x) => x.index);
+  const end = candidates.length === 0 ? -1 : Math.min(...candidates);
+  return end === -1 ? tail.length : end;
+}
+function project(rows, selectRaw) {
+  if (/^count\s*\(\s*\*/i.test(selectRaw) || /^count\s*\(\s*1\)/i.test(selectRaw)) {
+    const alias = selectRaw.match(/\bAS\s+([A-Za-z_][A-Za-z0-9_]*)/i)?.[1] ?? "n";
+    return [{ [alias]: rows.length }];
+  }
+  const constMatch = /^(\d+)\s+AS\s+([A-Za-z_][A-Za-z0-9_]*)/i.exec(selectRaw);
+  if (constMatch !== null) {
+    return [{ [constMatch[2]]: Number(constMatch[1]) }];
+  }
+  if (selectRaw.trim() === "*") return rows;
+  const cols = selectRaw.split(",").map((s) => ident(s.trim()));
+  return rows.map((row) => {
+    const out = {};
+    for (const col of cols) out[col] = row[col];
+    return out;
+  });
+}
+
+// packages/cli/src/sim/db.ts
+function toProjectDriver(engine) {
+  return {
+    engine: "sqlite",
+    run: (sql, params = []) => engine.run(sql, params),
+    all: (sql, params = []) => engine.all(sql, params),
+    get: (sql, params = []) => engine.get(sql, params),
+    close: () => engine.close()
+  };
+}
+function createSimDbCapability(options = {}) {
+  const engine = new SimSqlEngine({
+    storage: options.storage ?? { load: async () => null, save: async () => void 0 },
+    memoryOnly: options.storage === void 0
+  });
+  const driver = toProjectDriver(engine);
+  const bundle = createDbCapability(driver);
+  return { bundle, engine, driver };
+}
+
+// packages/cli/src/sim/storage.ts
+import { join as join3 } from "node:path";
+
+// packages/runtime/src/storage/driver.ts
+var PROJECT_QUOTA_BYTES = 1024 * 1024 * 1024;
+var StorageError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "StorageError";
+  }
+};
+var STORAGE_CODES = {
+  invalidPath: "STORAGE_INVALID_PATH",
+  notFound: "STORAGE_NOT_FOUND",
+  quotaExceeded: "STORAGE_QUOTA_EXCEEDED"
+};
+function assertSafeStoragePath(path) {
+  if (typeof path !== "string" || path.length === 0) {
+    throw new StorageError(400, STORAGE_CODES.invalidPath, "\u5B58\u50A8\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  if (path.length > 1024) {
+    throw new StorageError(400, STORAGE_CODES.invalidPath, "\u5B58\u50A8\u8DEF\u5F84\u8FC7\u957F\uFF08\u4E0A\u9650 1024 \u5B57\u7B26\uFF09");
+  }
+  if (path.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path) || /[\0\r\n]/.test(path)) {
+    throw new StorageError(400, STORAGE_CODES.invalidPath, "\u5B58\u50A8\u8DEF\u5F84\u5FC5\u987B\u662F\u9879\u76EE\u6876\u5185\u7684\u76F8\u5BF9\u8DEF\u5F84");
+  }
+  const segments = path.split("/");
+  for (const segment of segments) {
+    if (segment === "" || segment === "." || segment === "..") {
+      throw new StorageError(
+        400,
+        STORAGE_CODES.invalidPath,
+        `\u5B58\u50A8\u8DEF\u5F84\u542B\u975E\u6CD5\u6BB5 "${segment}"\uFF08\u7981\u6B62\u7A7A\u6BB5 / . / .. \u7A7F\u8D8A\uFF09`
+      );
+    }
+    if (/[\\]/.test(segment)) {
+      throw new StorageError(400, STORAGE_CODES.invalidPath, "\u5B58\u50A8\u8DEF\u5F84\u7981\u6B62\u53CD\u659C\u6760");
+    }
+  }
+  return path;
+}
+
+// packages/runtime/src/storage/hmac-sha256.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var rotr = (x, n) => x >>> n | x << 32 - n;
+function compress(h, block, w) {
+  for (let i = 0; i < 16; i += 1) {
+    const j = i * 4;
+    w[i] = (block[j] ?? 0) << 24 | (block[j + 1] ?? 0) << 16 | (block[j + 2] ?? 0) << 8 | (block[j + 3] ?? 0);
+  }
+  for (let i = 16; i < 64; i += 1) {
+    const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ w[i - 15] >>> 3;
+    const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ w[i - 2] >>> 10;
+    w[i] = w[i - 16] + s0 + w[i - 7] + s1 | 0;
+  }
+  let [a, b, c, d, e, f, g, hh] = [h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]];
+  for (let i = 0; i < 64; i += 1) {
+    const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+    const ch = e & f ^ ~e & g;
+    const t1 = hh + S1 + ch + K[i] + w[i] | 0;
+    const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+    const maj = a & b ^ a & c ^ b & c;
+    const t2 = S0 + maj | 0;
+    hh = g;
+    g = f;
+    f = e;
+    e = d + t1 | 0;
+    d = c;
+    c = b;
+    b = a;
+    a = t1 + t2 | 0;
+  }
+  h[0] = h[0] + a | 0;
+  h[1] = h[1] + b | 0;
+  h[2] = h[2] + c | 0;
+  h[3] = h[3] + d | 0;
+  h[4] = h[4] + e | 0;
+  h[5] = h[5] + f | 0;
+  h[6] = h[6] + g | 0;
+  h[7] = h[7] + hh | 0;
+}
+function sha256(data) {
+  const h = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  const bitLength = data.length * 8;
+  const paddedLength = Math.ceil((data.length + 9) / 64) * 64;
+  const padded = new Uint8Array(paddedLength);
+  padded.set(data);
+  padded[data.length] = 128;
+  const view = new DataView(padded.buffer);
+  view.setUint32(paddedLength - 4, bitLength >>> 0, false);
+  view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296), false);
+  const w = new Uint32Array(64);
+  for (let offset = 0; offset < paddedLength; offset += 64) {
+    compress(h, padded.subarray(offset, offset + 64), w);
+  }
+  const out = new Uint8Array(32);
+  const outView = new DataView(out.buffer);
+  for (let i = 0; i < 8; i += 1) outView.setUint32(i * 4, h[i], false);
+  return out;
+}
+function toBytes(input) {
+  if (typeof input !== "string") return input;
+  return new TextEncoder().encode(input);
+}
+function hmacSha256(key, message) {
+  const blockSize = 64;
+  let keyBytes = toBytes(key);
+  if (keyBytes.length > blockSize) keyBytes = sha256(keyBytes);
+  const padded = new Uint8Array(blockSize);
+  padded.set(keyBytes);
+  const inner = new Uint8Array(blockSize);
+  const outer = new Uint8Array(blockSize);
+  for (let i = 0; i < blockSize; i += 1) {
+    inner[i] = padded[i] ^ 54;
+    outer[i] = padded[i] ^ 92;
+  }
+  const innerInput = new Uint8Array(blockSize + toBytes(message).length);
+  innerInput.set(inner);
+  innerInput.set(toBytes(message), blockSize);
+  const innerHash = sha256(innerInput);
+  const outerInput = new Uint8Array(blockSize + 32);
+  outerInput.set(outer);
+  outerInput.set(innerHash, blockSize);
+  return sha256(outerInput);
+}
+function hmacSha256Hex(key, message) {
+  return [...hmacSha256(key, message)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// packages/runtime/src/storage/signature.ts
+var DEFAULT_SIGN_TTL_SECONDS = 15 * 60;
+var SIGN_EXPIRES_KEY = "x-expires";
+var SIGN_SIGNATURE_KEY = "x-signature";
+function sign(secret, projectId, path, expires) {
+  const payload = `${projectId}|${path}|${expires}`;
+  return hmacSha256Hex(secret, payload);
+}
+function signDownloadUrl(config, projectId, path, ttlSeconds = DEFAULT_SIGN_TTL_SECONDS) {
+  const expires = Math.floor(Date.now() / 1e3) + ttlSeconds;
+  const base = `${config.baseUrl}/api/v1/projects/${encodeURIComponent(projectId)}/files/${encodeURIComponent(path)}`;
+  const signature = sign(config.secret, projectId, path, expires);
+  return `${base}?${SIGN_EXPIRES_KEY}=${expires}&${SIGN_SIGNATURE_KEY}=${signature}`;
+}
+
+// packages/runtime/src/storage/cloud.ts
+var DEFAULT_VISIBILITY = "private";
+function asBytes(data) {
+  if (typeof data === "string") return new TextEncoder().encode(data);
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (data instanceof Uint8Array) return data;
+  const candidate = data;
+  if (candidate.data instanceof Uint8Array) return candidate.data;
+  throw new StorageError(400, STORAGE_CODES.invalidPath, "\u4E0D\u652F\u6301\u7684\u5B58\u50A8\u6570\u636E\u7C7B\u578B");
+}
+function toStoredFile(meta) {
+  return {
+    path: meta.path,
+    size: meta.size,
+    visibility: meta.visibility,
+    ...meta.contentType === void 0 ? {} : { contentType: meta.contentType },
+    ...meta.updatedAt === void 0 ? {} : { updatedAt: meta.updatedAt }
+  };
+}
+function createStorageCapability(driver, signer, projectId) {
+  const handler = async (method, args) => {
+    switch (method) {
+      case "upload": {
+        const [path, data] = args;
+        return toStoredFile(
+          await driver.put(projectId, path, asBytes(data), { visibility: DEFAULT_VISIBILITY })
+        );
+      }
+      case "get": {
+        const [path] = args;
+        return (await driver.get(projectId, path)).data;
+      }
+      case "remove": {
+        const [path] = args;
+        await driver.remove(projectId, path);
+        return void 0;
+      }
+      case "list": {
+        const [prefix] = args;
+        return (await driver.list(projectId, prefix)).map(toStoredFile);
+      }
+      case "getSignedUrl": {
+        const [path, ttlSeconds] = args;
+        return signDownloadUrl(signer, projectId, path, ttlSeconds);
+      }
+      default:
+        throw new StorageError(
+          400,
+          "STORAGE_INVALID_METHOD",
+          `\u672A\u77E5\u7684 cloud.storage \u65B9\u6CD5 "${method}"`
+        );
+    }
+  };
+  return {
+    capabilities: [{ name: "storage", value: { [RPC_CAPABILITY_KEY]: true } }],
+    rpcHandlers: { storage: handler }
+  };
+}
+
+// packages/runtime/src/storage/driver/local.ts
+import { mkdir, readFile, readdir, rm, stat, unlink, writeFile } from "node:fs/promises";
+import { dirname as dirname2, join as join2 } from "node:path";
+var META_SUFFIX = ".adep-meta.json";
+function createLocalStorageDriver(options) {
+  const quotaBytes = options.quotaBytes ?? PROJECT_QUOTA_BYTES;
+  const bucketDir = (projectId) => join2(options.dir, projectId);
+  const objectPath = (projectId, path) => join2(bucketDir(projectId), path);
+  const metaPath = (projectId, path) => join2(dirname2(objectPath(projectId, path)), `${path.split("/").pop() ?? ""}${META_SUFFIX}`);
+  const readStoredMeta = async (projectId, path) => {
+    const raw = await readFile(metaPath(projectId, path), "utf8");
+    return JSON.parse(raw);
+  };
+  const writeStoredMeta = async (projectId, path, meta) => {
+    const payload = {
+      visibility: meta.visibility,
+      size: meta.size,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...meta.contentType === void 0 ? {} : { contentType: meta.contentType }
+    };
+    await writeFile(metaPath(projectId, path), JSON.stringify(payload), "utf8");
+  };
+  const totalSize = async (projectId) => {
+    const root = bucketDir(projectId);
+    let total = 0;
+    const walk = async (dir) => {
+      let entries;
+      try {
+        entries = await readdir(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      const tasks = [];
+      for (const entry of entries) {
+        const full = join2(dir, entry.name);
+        if (entry.isDirectory()) {
+          tasks.push(walk(full));
+        } else if (entry.isFile() && !entry.name.endsWith(META_SUFFIX)) {
+          tasks.push(
+            (async () => {
+              try {
+                const info = await stat(full);
+                total += info.size;
+              } catch {
+              }
+            })()
+          );
+        }
+      }
+      await Promise.all(tasks);
+    };
+    await walk(root);
+    return total;
+  };
+  return {
+    async put(projectId, path, data, putOptions) {
+      assertSafeStoragePath(path);
+      if (!(data instanceof Uint8Array)) {
+        throw new StorageError(400, "STORAGE_INVALID_PAYLOAD", "\u5199\u5165\u5185\u5BB9\u5FC5\u987B\u662F\u5B57\u8282\u6570\u7EC4");
+      }
+      const used = await totalSize(projectId);
+      let existingSize = 0;
+      try {
+        existingSize = (await stat(objectPath(projectId, path))).size;
+      } catch {
+        existingSize = 0;
+      }
+      const projected = used - existingSize + data.byteLength;
+      if (options.quotaCheck !== void 0) {
+        await options.quotaCheck(projectId, projected);
+      } else if (projected > quotaBytes) {
+        throw new StorageError(
+          413,
+          STORAGE_CODES.quotaExceeded,
+          `\u9879\u76EE\u5B58\u50A8\u7A7A\u95F4\u4E0D\u8DB3\uFF1A\u914D\u989D ${quotaBytes} \u5B57\u8282\u5DF2\u7528\u5C3D\uFF08STORAGE_QUOTA_EXCEEDED\uFF09`
+        );
+      }
+      const dest = objectPath(projectId, path);
+      await mkdir(dirname2(dest), { recursive: true });
+      await writeFile(dest, data);
+      await writeStoredMeta(projectId, path, {
+        visibility: putOptions.visibility,
+        size: data.byteLength,
+        ...putOptions.contentType === void 0 ? {} : { contentType: putOptions.contentType }
+      });
+      const meta = await readStoredMeta(projectId, path);
+      return {
+        path,
+        size: meta.size,
+        visibility: meta.visibility,
+        updatedAt: meta.updatedAt,
+        ...meta.contentType === void 0 ? {} : { contentType: meta.contentType }
+      };
+    },
+    async get(projectId, path) {
+      assertSafeStoragePath(path);
+      let meta;
+      try {
+        meta = await readStoredMeta(projectId, path);
+      } catch {
+        throw new StorageError(404, STORAGE_CODES.notFound, `\u6587\u4EF6 "${path}" \u4E0D\u5B58\u5728`);
+      }
+      const data = await readFile(objectPath(projectId, path));
+      const result = {
+        path,
+        size: meta.size,
+        visibility: meta.visibility,
+        updatedAt: meta.updatedAt,
+        ...meta.contentType === void 0 ? {} : { contentType: meta.contentType }
+      };
+      return { data, meta: result };
+    },
+    async getMeta(projectId, path) {
+      assertSafeStoragePath(path);
+      let meta;
+      try {
+        meta = await readStoredMeta(projectId, path);
+      } catch {
+        throw new StorageError(404, STORAGE_CODES.notFound, `\u6587\u4EF6 "${path}" \u4E0D\u5B58\u5728`);
+      }
+      const result = {
+        path,
+        size: meta.size,
+        visibility: meta.visibility,
+        updatedAt: meta.updatedAt,
+        ...meta.contentType === void 0 ? {} : { contentType: meta.contentType }
+      };
+      return result;
+    },
+    async remove(projectId, path) {
+      assertSafeStoragePath(path);
+      let exists = true;
+      try {
+        await stat(objectPath(projectId, path));
+      } catch {
+        exists = false;
+      }
+      if (!exists) {
+        throw new StorageError(404, STORAGE_CODES.notFound, `\u6587\u4EF6 "${path}" \u4E0D\u5B58\u5728`);
+      }
+      await rm(objectPath(projectId, path), { force: true });
+      await unlink(metaPath(projectId, path)).catch(() => void 0);
+    },
+    async list(projectId, prefix) {
+      if (prefix !== void 0 && prefix !== "") {
+        const segments = prefix.split("/");
+        if (prefix.startsWith("/") || /[\\]/.test(prefix) || segments.some((segment) => segment === "..")) {
+          throw new StorageError(
+            400,
+            STORAGE_CODES.invalidPath,
+            `\u975E\u6CD5\u524D\u7F00 "${prefix}"\uFF08\u7981\u6B62 / \u5F00\u5934\u3001\u53CD\u659C\u6760\u6216 .. \u7A7F\u8D8A\uFF09`
+          );
+        }
+      }
+      const root = bucketDir(projectId);
+      const metas = [];
+      const walk = async (dir, relative) => {
+        let entries;
+        try {
+          entries = await readdir(dir, { withFileTypes: true });
+        } catch {
+          return;
+        }
+        const tasks = [];
+        for (const entry of entries) {
+          if (entry.name.endsWith(META_SUFFIX)) continue;
+          const full = join2(dir, entry.name);
+          const rel = relative === "" ? entry.name : `${relative}/${entry.name}`;
+          if (entry.isFile()) {
+            if (prefix !== void 0 && !rel.startsWith(prefix)) continue;
+            tasks.push(
+              (async () => {
+                try {
+                  const payload = JSON.parse(
+                    await readFile(full + META_SUFFIX, "utf8")
+                  );
+                  metas.push({
+                    path: rel,
+                    size: payload.size,
+                    visibility: payload.visibility,
+                    updatedAt: payload.updatedAt,
+                    ...payload.contentType === void 0 ? {} : { contentType: payload.contentType }
+                  });
+                } catch {
+                }
+              })()
+            );
+          } else if (entry.isDirectory()) {
+            if (prefix !== void 0 && !rel.startsWith(prefix)) {
+              const subIncluded = prefix.startsWith(rel + "/") || rel.startsWith(prefix);
+              if (!subIncluded) continue;
+            }
+            tasks.push(walk(full, rel));
+          }
+        }
+        await Promise.all(tasks);
+      };
+      await walk(root, "");
+      metas.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+      return metas;
+    },
+    async usage(projectId) {
+      return totalSize(projectId);
+    }
+  };
+}
+
+// packages/cli/src/sim/storage.ts
+function createSimStorageCapability(options) {
+  const dir = join3(options.cwd, ".adep", "sim", "storage");
+  const driver = createLocalStorageDriver({ dir });
+  const signer = {
+    secret: options.secret ?? "adep-sim-secret",
+    baseUrl: options.baseUrl ?? "http://127.0.0.1:8787"
+  };
+  const bundle = createStorageCapability(driver, signer, options.projectId ?? "sim-project");
+  return { bundle, driver };
+}
+
+// packages/cli/src/sim/realtime.ts
+var SimRealtime = class {
+  seq = 0;
+  subscribers = /* @__PURE__ */ new Map();
+  /** 向某 channel 广播一条消息；返回被投递的连接数（单进程内）。 */
+  publish(channel, data, publisher) {
+    this.seq += 1;
+    const message = {
+      channel,
+      seq: this.seq,
+      data,
+      publishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...publisher === void 0 ? {} : { publisher }
+    };
+    const set = this.subscribers.get(channel);
+    if (set === void 0) return { delivered: 0 };
+    let delivered = 0;
+    for (const listener of set) {
+      listener(message);
+      delivered += 1;
+    }
+    return { delivered };
+  }
+  /** 订阅某 channel；返回退订函数。 */
+  subscribe(channel, listener) {
+    let set = this.subscribers.get(channel);
+    if (set === void 0) {
+      set = /* @__PURE__ */ new Set();
+      this.subscribers.set(channel, set);
+    }
+    set.add(listener);
+    return () => {
+      set?.delete(listener);
+    };
+  }
+  /** 当前有订阅者的 channel 数（调试用）。 */
+  channelCount() {
+    return this.subscribers.size;
+  }
+};
+var MAX_BUFFERED_MESSAGES = 64;
+var MAX_SUBSCRIPTIONS = 64;
+var REALTIME_CODES = REALTIME_CAPABILITY_CODES;
+function realtimeError(code, message) {
+  return new Error(`[${code}] ${message}`);
+}
+function createSimRealtimeCapability() {
+  const sim = new SimRealtime();
+  const buffers = /* @__PURE__ */ new Map();
+  const disposers = /* @__PURE__ */ new Map();
+  let seq = 0;
+  const handler = async (method, args) => {
+    switch (method) {
+      case "publish": {
+        if (args.length > 2) {
+          throw realtimeError(
+            REALTIME_CODES.unsupportedArg,
+            "\u672C\u5730\u5355\u8FDB\u7A0B\u5185\u5B58\u5E7F\u64AD\u65E0\u8FDE\u63A5\u8EAB\u4EFD\uFF0C\u4E0D\u652F\u6301 publish \u7684 except \u5B9E\u53C2"
+          );
+        }
+        const [channel, data] = args;
+        return sim.publish(channel, data);
+      }
+      case "subscribe": {
+        if (buffers.size >= MAX_SUBSCRIPTIONS) {
+          throw realtimeError(
+            REALTIME_CODES.tooManySubscriptions,
+            `\u672C\u5730\u8BA2\u9605\u6570\u5DF2\u8FBE\u4E0A\u9650 ${String(MAX_SUBSCRIPTIONS)}\uFF0C\u8BF7\u5148 unsubscribe`
+          );
+        }
+        const [channel] = args;
+        seq += 1;
+        const id = `sub-${String(seq)}`;
+        const buffer = [];
+        const off = sim.subscribe(channel, (msg) => {
+          buffer.push(msg);
+          if (buffer.length > MAX_BUFFERED_MESSAGES) buffer.shift();
+        });
+        buffers.set(id, buffer);
+        disposers.set(id, off);
+        return { subscription: id, channel };
+      }
+      case "receive": {
+        const buffer = buffers.get(args[0]);
+        if (buffer === void 0) {
+          throw realtimeError(
+            REALTIME_CODES.subscriptionNotFound,
+            `\u672C\u5730\u8BA2\u9605 "${String(args[0])}" \u4E0D\u5B58\u5728\u6216\u5DF2\u9000\u8BA2`
+          );
+        }
+        return buffer.splice(0, buffer.length);
+      }
+      case "unsubscribe": {
+        const id = args[0];
+        const off = disposers.get(id);
+        if (off === void 0) {
+          throw realtimeError(
+            REALTIME_CODES.subscriptionNotFound,
+            `\u672C\u5730\u8BA2\u9605 "${id}" \u4E0D\u5B58\u5728\u6216\u5DF2\u9000\u8BA2`
+          );
+        }
+        off();
+        disposers.delete(id);
+        buffers.delete(id);
+        return { removed: true };
+      }
+      default:
+        throw realtimeError(
+          REALTIME_CODES.invalidMethod,
+          `\u672A\u77E5\u7684 cloud.realtime \u65B9\u6CD5 "${method}"\uFF08\u53EF\u7528\uFF1A${REALTIME_CAPABILITY_METHODS.join(" / ")}\uFF09`
+        );
+    }
+  };
+  return {
+    bundle: {
+      capabilities: [{ name: "realtime", value: { [RPC_CAPABILITY_KEY]: true } }],
+      rpcHandlers: { realtime: handler }
+    },
+    realtime: sim
+  };
+}
+
+// packages/cli/src/sim/runtime.ts
+function simDir(cwd) {
+  return join4(cwd, ".adep", "sim");
+}
+function mergeBundles(bundles) {
+  const capabilities = [];
+  const byName = /* @__PURE__ */ new Map();
+  for (const bundle of bundles) {
+    for (const cap of bundle.capabilities) {
+      const existing = byName.get(cap.name);
+      if (existing !== void 0) capabilities.splice(capabilities.indexOf(existing), 1);
+      byName.set(cap.name, cap);
+      capabilities.push(cap);
+    }
+  }
+  const rpcHandlers = {};
+  for (const bundle of bundles) {
+    for (const [name, handler] of Object.entries(bundle.rpcHandlers)) {
+      rpcHandlers[name] = handler;
+    }
+  }
+  return { capabilities, rpcHandlers };
+}
+function jsonStorage(cwd) {
+  const file = join4(simDir(cwd), "db.json");
+  return {
+    async load() {
+      try {
+        const raw = await readFile2(file, "utf8");
+        return JSON.parse(raw);
+      } catch {
+        return null;
+      }
+    },
+    async save(tables) {
+      await mkdir2(dirname3(file), { recursive: true });
+      await writeFile2(file, JSON.stringify(tables), "utf8");
+    }
+  };
+}
+async function createSimRuntime(options) {
+  const db = createSimDbCapability({
+    storage: options.dbStorage ?? jsonStorage(options.cwd),
+    ...options.log === void 0 ? {} : { log: options.log }
+  });
+  const storage = createSimStorageCapability({
+    cwd: options.cwd,
+    ...options.baseUrl === void 0 ? {} : { baseUrl: options.baseUrl },
+    projectId: options.projectId ?? "local"
+  });
+  const simRealtime = createSimRealtimeCapability();
+  const bundle = mergeBundles([db.bundle, storage.bundle, simRealtime.bundle]);
+  await db.engine.load();
+  return {
+    bundle,
+    realtime: simRealtime.realtime,
+    db,
+    dispose: async () => {
+      await db.driver.close();
+    }
+  };
+}
+
+// packages/cli/src/sim/env.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+function parseEnv(content) {
+  const env = {};
+  for (const raw of content.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line.length === 0 || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq === -1) continue;
+    const key = line.slice(0, eq).trim();
+    if (key.length === 0) continue;
+    env[key] = line.slice(eq + 1).trim();
+  }
+  return env;
+}
+async function loadSimEnv(cwd, config = {}) {
+  const envRoot = await readFile3(join5(cwd, ".env"), "utf8").catch(() => "");
+  const envLocal = await readFile3(join5(cwd, ".env.local"), "utf8").catch(() => "");
+  const merged = { ...parseEnv(envRoot), ...parseEnv(envLocal) };
+  for (const secret of config.secrets ?? []) {
+    if (merged[secret] !== void 0) continue;
+    if (process.env[secret] !== void 0) {
+      merged[secret] = process.env[secret];
+      continue;
+    }
+    throw new Error(
+      `secret "${secret}" \u672A\u914D\u7F6E\uFF1A\u8BF7\u5728 .env.local \u6DFB\u52A0 ${secret}=<value>\uFF0C\u6216\u7528\u73AF\u5883\u53D8\u91CF\u5BFC\u51FA\u540E\u91CD\u8BD5 adep dev\uFF08\u6A21\u62DF\u73AF\u5883\u6C38\u4E0D\u843D\u76D8\u8BE5\u503C\uFF09`
+    );
+  }
+  return merged;
+}
+
+// packages/cli/src/sim/invoke.ts
+function resolveFunctionEntry(files, fnName) {
+  const flat = `${fnName}.ts`;
+  if (files[flat] !== void 0) return flat;
+  const directory = `${fnName}/index.ts`;
+  if (files[directory] !== void 0) return directory;
+  return void 0;
+}
+function createSimInvokeHandler(options) {
+  return async (method, args) => {
+    if (method !== "invoke") {
+      throw new Error(`\u672A\u77E5\u7684 cloud.invoke \u65B9\u6CD5 "${method}"`);
+    }
+    const input = args[0];
+    if (typeof input?.name !== "string" || input.name.length === 0) {
+      throw new Error("cloud.invoke \u9700\u8981\u76EE\u6807\u51FD\u6570\u540D\uFF08InvokeInput.name\uFF09");
+    }
+    const targetEntry = resolveFunctionEntry(options.files, input.name);
+    if (targetEntry === void 0) {
+      throw new Error(`\u76EE\u6807\u51FD\u6570 "${input.name}" \u4E0D\u5B58\u5728`);
+    }
+    const executeInput = {
+      project: { id: "local", slug: "local" },
+      fn: { id: input.name, name: input.name },
+      files: options.files,
+      entry: targetEntry,
+      request: {
+        method: "POST",
+        path: `/${input.name}`,
+        query: input.query ?? {},
+        headers: {},
+        ...input.body === void 0 ? {} : { body: input.body }
+      },
+      timeoutMs: 1e4,
+      ...options.env === void 0 ? {} : { env: options.env }
+    };
+    const result = await options.executor.execute(executeInput);
+    return result.body;
+  };
+}
+
+// packages/cli/src/sim/boundary.ts
+var SIM_BOUNDARIES = [
+  {
+    kind: "capability",
+    title: "\u89E6\u53D1\u5668\u4E0D\u81EA\u52A8\u6267\u884C",
+    detail: "\u5B9A\u65F6 / \u4E8B\u4EF6\u89E6\u53D1\u5668\u53EA\u767B\u8BB0\uFF0C\u4E0D\u7531\u6A21\u62DF\u5668\u81EA\u52A8\u89E6\u53D1\uFF08\u672C\u5730\u4EE5\u624B\u5DE5 HTTP \u8C03\u7528\u66FF\u4EE3\uFF09\u3002"
+  },
+  {
+    kind: "diff",
+    title: "\u65E0\u8DE8\u5B9E\u4F8B\u5E7F\u64AD",
+    detail: "cloud.realtime \u5DF2\u6CE8\u5165\uFF0C\u4F46\u4E3A\u5355\u8FDB\u7A0B\u5185\u5B58\u5E7F\u64AD\uFF1A\u4E0D\u652F\u6301\u8DE8\u8FDB\u7A0B / \u8DE8\u5B9E\u4F8B\uFF0C\u7EBF\u4E0A\u591A\u5B9E\u4F8B\u8BED\u4E49\u4E0D\u540C\u3002"
+  },
+  {
+    kind: "capability",
+    title: "publish \u4E0D\u652F\u6301 except",
+    detail: "\u672C\u5730\u4E0D\u5EFA WS \u63E1\u624B\u3001\u65E0\u8FDE\u63A5\u8EAB\u4EFD\uFF0C\u6545 cloud.realtime.publish \u7684 except\uFF08\u4E0D\u53D1\u56DE\u53D1\u9001\u8005\uFF09\u65E0\u4ECE\u5B9E\u73B0\uFF0C\u4F20\u5165\u5373\u62A5\u9519\u3002"
+  },
+  {
+    kind: "capability",
+    title: "\u65E0\u9650\u989D\u7B49\u4EF7",
+    detail: "\u672C\u5730\u4E0D\u6267\u884C\u8BA1\u91CF / \u914D\u989D\u95E8\u7981\uFF08\u4E0D\u6309\u51FD\u6570\u8C03\u7528\u3001\u6D41\u91CF\u3001\u63A8\u9001\u8BA1\u6570\uFF09\uFF0C\u9650\u989D\u8BED\u4E49\u4EC5\u7EBF\u4E0A\u751F\u6548\u3002"
+  },
+  {
+    kind: "diff",
+    title: "\u4E0D\u8BA1\u91CF",
+    detail: "\u672C\u6A21\u62DF\u8FD0\u884C\u65F6\u4E0D\u4EA7\u51FA\u8BA1\u91CF\u4E8B\u4EF6\uFF0C\u4E5F\u4E0D\u5199 billing\uFF1B\u79BB\u7EBF\u5F00\u53D1\u4E0D\u8BA1\u8D39\u3002"
+  }
+];
+
+// packages/cli/src/ts-config.ts
+import { stat as stat2, readFile as readFile4 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+
+// shared/sdk/adep-config.ts
+var DEFAULT_ADEP_CONFIG = {
+  functionsDir: "functions",
+  functions_prefix: "/api"
+};
+function typeNameOf(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function asRecord(value) {
+  if (value === null || Array.isArray(value) || typeof value !== "object") return null;
+  return value;
+}
+function asStringRecord(value) {
+  const rec = asRecord(value);
+  if (rec === null) return null;
+  for (const v of Object.values(rec)) {
+    if (typeof v !== "string") return null;
+  }
+  return rec;
+}
+function parseAdepConfig(raw) {
+  if (raw === null || raw === void 0) {
+    return { ok: true, data: { ...DEFAULT_ADEP_CONFIG } };
+  }
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    return {
+      ok: false,
+      errors: [`adep.config.ts \u7684 default export \u5FC5\u987B\u662F\u5BF9\u8C61\uFF0C\u6536\u5230 ${typeNameOf(raw)}`]
+    };
+  }
+  const errors = [];
+  const input = raw;
+  const data = { ...DEFAULT_ADEP_CONFIG };
+  if (input.name !== void 0) {
+    if (typeof input.name !== "string") {
+      errors.push(`name \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\uFF0C\u6536\u5230 ${typeNameOf(input.name)}`);
+    } else {
+      data.name = input.name;
+    }
+  }
+  if (input.functionsDir !== void 0) {
+    if (typeof input.functionsDir !== "string") {
+      errors.push(`functionsDir \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\uFF0C\u6536\u5230 ${typeNameOf(input.functionsDir)}`);
+    } else {
+      data.functionsDir = input.functionsDir;
+    }
+  }
+  if (input.functions_prefix !== void 0) {
+    if (typeof input.functions_prefix !== "string") {
+      errors.push(`functions_prefix \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\uFF0C\u6536\u5230 ${typeNameOf(input.functions_prefix)}`);
+    } else {
+      data.functions_prefix = input.functions_prefix;
+    }
+  }
+  if (input.frontend !== void 0) {
+    const rec = asRecord(input.frontend);
+    if (rec === null) {
+      errors.push(`frontend \u5FC5\u987B\u662F\u5BF9\u8C61\uFF0C\u6536\u5230 ${typeNameOf(input.frontend)}`);
+    } else {
+      data.frontend = rec;
+    }
+  }
+  if (input.environment !== void 0) {
+    const rec = asStringRecord(input.environment);
+    if (rec === null) {
+      errors.push(
+        `environment \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u5230\u5B57\u7B26\u4E32\u7684\u6620\u5C04\uFF08Record<string, string>\uFF09\uFF0C\u6536\u5230 ${typeNameOf(input.environment)}`
+      );
+    } else {
+      data.environment = rec;
+    }
+  }
+  if (input.runtime !== void 0) {
+    const rec = asRecord(input.runtime);
+    if (rec === null) {
+      errors.push(`runtime \u5FC5\u987B\u662F\u5BF9\u8C61\uFF0C\u6536\u5230 ${typeNameOf(input.runtime)}`);
+    } else {
+      data.runtime = rec;
+    }
+  }
+  if (errors.length > 0) return { ok: false, errors };
+  return { ok: true, data };
+}
+
+// packages/cli/src/ts-config.ts
+async function loadAdepConfigModule(cwd) {
+  const configPath = join6(cwd, "adep.config.ts");
+  try {
+    await stat2(configPath);
+  } catch {
+    return null;
+  }
+  let rawDefault;
+  try {
+    const bun = globalThis.Bun;
+    if (bun !== void 0) {
+      const mod = await import(configPath);
+      rawDefault = mod.default;
+    } else {
+      const { transform } = await import("esbuild");
+      const source = await readFile4(configPath, "utf8");
+      const { code } = await transform(source, {
+        loader: "ts",
+        format: "esm",
+        target: "node22"
+      });
+      const url = `data:text/javascript;base64,${Buffer.from(code).toString("base64")}`;
+      const mod = await import(url);
+      rawDefault = mod.default;
+    }
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    const message = `adep.config.ts \u52A0\u8F7D\u5931\u8D25\uFF1A${reason}`;
+    process.stderr.write(`\u9519\u8BEF\uFF1A${message}
+`);
+    throw new Error(message, { cause: error });
+  }
+  const result = parseAdepConfig(rawDefault);
+  if (!result.ok) {
+    const message = `adep.config.ts \u6821\u9A8C\u5931\u8D25\uFF1A
+${result.errors.map((e) => `  - ${e}`).join("\n")}`;
+    process.stderr.write(`${message}
+`);
+    throw new Error(message);
+  }
+  return result.data;
+}
+
+// packages/cli/src/dev.ts
+async function loadConfig(cwd) {
+  const name = basename(resolve2(cwd));
+  const config = await loadAdepConfigModule(cwd);
+  return {
+    name: config?.name ?? name,
+    functionsDir: config?.functionsDir ?? "functions",
+    functionsPrefix: config?.functions_prefix ?? ""
+  };
+}
+function parseEnvFile(content) {
+  const env = {};
+  for (const raw of content.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line.length === 0 || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq === -1) continue;
+    const key = line.slice(0, eq).trim();
+    if (key.length === 0) continue;
+    env[key] = line.slice(eq + 1).trim();
+  }
+  return env;
+}
+async function collectFunctions(dir) {
+  const files = {};
+  const walk = async (sub, prefix) => {
+    let entries;
+    try {
+      entries = await readdir2(sub, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const rel = prefix.length === 0 ? entry.name : `${prefix}/${entry.name}`;
+      const full = join7(sub, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full, rel);
+      } else if (entry.isFile() && entry.name.endsWith(".ts")) {
+        files[rel] = await readFile5(full, "utf8");
+      }
+    }
+  };
+  await walk(dir, "");
+  return files;
+}
+function bodyOf(req) {
+  return new Promise((resolveBody, rejectBody) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString("utf8");
+      if (raw.length === 0) {
+        resolveBody(void 0);
+        return;
+      }
+      try {
+        resolveBody(JSON.parse(raw));
+      } catch {
+        resolveBody(raw);
+      }
+    });
+    req.on("error", rejectBody);
+  });
+}
+function resolveRouteFnName(pathname, prefix) {
+  const segments = pathname.split("/").filter((segment) => segment.length > 0);
+  const normalizedPrefix = prefix.replace(/^\/+|\/+$/g, "");
+  if (normalizedPrefix.length === 0) {
+    const first = segments[0];
+    return first === void 0 ? {} : { fnName: first };
+  }
+  if (segments[0] !== normalizedPrefix) {
+    return {
+      error: {
+        code: "FN_PREFIX_REQUIRED",
+        message: `\u5DF2\u914D\u7F6E functions_prefix "${normalizedPrefix}"\uFF1A\u4EE5 /${normalizedPrefix}/{fnName} \u8C03\u7528\u672C\u5730\u51FD\u6570`
+      }
+    };
+  }
+  const second = segments[1];
+  if (second === void 0) {
+    return {
+      error: {
+        code: "FN_NAME_REQUIRED",
+        message: `\u4EE5 /${normalizedPrefix}/{fnName} \u8C03\u7528\u672C\u5730\u51FD\u6570`
+      }
+    };
+  }
+  return { fnName: second };
+}
+function writeJson(res, status, payload) {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(payload));
+}
+function printBoundaries(log) {
+  log("[adep] \u80FD\u529B\u8FB9\u754C\uFF08\u6A21\u62DF\u8FD0\u884C\u65F6\u53EA\u66FF\u6362\u4F20\u8F93/\u6301\u4E45\u5316\uFF0C\u4E0D\u6539\u5199\u8BED\u4E49\uFF09\uFF1A");
+  for (const b of SIM_BOUNDARIES) {
+    log(`[adep]   - [${b.kind}] ${b.title}\uFF1A${b.detail}`);
+  }
+}
+async function ensureGitignore(cwd) {
+  const gitignorePath = join7(cwd, ".gitignore");
+  const existing = await readFile5(gitignorePath, "utf8").catch(() => "");
+  if (existing.split(/\r?\n/).includes(".adep/")) return;
+  await writeFile3(gitignorePath, `${existing.replace(/\n+$/, "")}
+.adep/
+`, "utf8");
+}
+async function startDevServer(options) {
+  const cwd = resolve2(options.cwd);
+  const log = options.log ?? ((line) => process.stdout.write(`${line}
+`));
+  const config = await loadConfig(cwd);
+  if (options.prefix !== void 0) {
+    config.functionsPrefix = options.prefix.replace(/^\/+|\/+$/g, "");
+  }
+  const functionsDir = join7(cwd, config.functionsDir);
+  const coldStartAt = Date.now();
+  const executor = new WorkerFunctionExecutor();
+  await mkdir3(functionsDir, { recursive: true });
+  const runtime = await createSimRuntime({
+    cwd,
+    projectId: "local",
+    baseUrl: `http://127.0.0.1:${options.port ?? 8787}`,
+    log
+  });
+  await ensureGitignore(cwd);
+  let files = await collectFunctions(functionsDir);
+  let env = await loadSimEnv(cwd).catch(() => ({}));
+  const dbBundle = runtime.bundle;
+  const invokeHandler = createSimInvokeHandler({ executor, files });
+  const reload = async () => {
+    const [nextFiles, envText2] = await Promise.all([
+      collectFunctions(functionsDir),
+      readFile5(join7(cwd, ".env.local"), "utf8").catch(() => "")
+    ]);
+    files = nextFiles;
+    env = parseEnvFile(envText2);
+  };
+  const envText = await readFile5(join7(cwd, ".env.local"), "utf8").catch(() => "");
+  env = parseEnvFile(envText);
+  let debounceTimer;
+  let watcher;
+  try {
+    watcher = watch(cwd, { recursive: true }, () => {
+      if (debounceTimer !== void 0) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => {
+        void reload();
+      }, 120);
+    });
+  } catch {
+    watcher = void 0;
+  }
+  const buildInput = async (fnName, entry, url, req) => {
+    const query = {};
+    for (const key of new Set(url.searchParams.keys())) {
+      const values = url.searchParams.getAll(key);
+      query[key] = values.length > 1 ? values.join(",") : values[0] ?? "";
+    }
+    const headers = {};
+    for (const [key, value] of Object.entries(req.headers)) {
+      if (typeof value === "string") headers[key] = value;
+    }
+    const body = req.method === "GET" || req.method === "HEAD" ? void 0 : await bodyOf(req);
+    const hasEnv = Object.keys(env).length > 0;
+    return {
+      project: { id: "local", slug: config.name },
+      fn: { id: fnName, name: fnName },
+      files,
+      entry,
+      request: {
+        method: req.method ?? "GET",
+        path: url.pathname,
+        query,
+        headers,
+        ...body === void 0 ? {} : { body }
+      },
+      // 模拟运行时能力：db / storage / realtime 各自只读复用线上装配，语义一致。
+      capabilities: dbBundle.capabilities,
+      rpcHandlers: {
+        ...dbBundle.rpcHandlers,
+        invoke: invokeHandler
+      },
+      timeoutMs: 1e4,
+      ...hasEnv ? { env } : {}
+    };
+  };
+  const handle = async (req, res) => {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    const { fnName, error: routeError } = resolveRouteFnName(url.pathname, config.functionsPrefix);
+    if (routeError !== void 0) {
+      writeJson(res, 400, { error: routeError });
+      return;
+    }
+    if (fnName === void 0) {
+      writeJson(res, 400, {
+        error: { code: "FN_NAME_REQUIRED", message: "\u4EE5 /{fnName} \u8C03\u7528\u672C\u5730\u51FD\u6570" }
+      });
+      return;
+    }
+    const entry = resolveFunctionEntry(files, fnName);
+    if (entry === void 0) {
+      log(`[adep] ${req.method ?? "GET"} /${fnName} -> 404\uFF08\u51FD\u6570\u4E0D\u5B58\u5728\uFF09`);
+      writeJson(res, 404, { error: { code: "FN_NOT_FOUND", message: `\u51FD\u6570 "${fnName}" \u4E0D\u5B58\u5728` } });
+      return;
+    }
+    const input = await buildInput(fnName, entry, url, req);
+    const startedAt = performance.now();
+    try {
+      const result = await executor.execute(input);
+      const durationMs = Math.round(performance.now() - startedAt);
+      log(`[adep] ${req.method ?? "GET"} /${fnName} -> 200 ${durationMs}ms`);
+      for (const line of result.logs) log(`[adep]   ${line}`);
+      writeJson(res, 200, result.body === void 0 ? null : result.body);
+    } catch (error) {
+      const durationMs = Math.round(performance.now() - startedAt);
+      if (error instanceof ExecutorError) {
+        log(
+          `[adep] ${req.method ?? "GET"} /${fnName} -> ${error.status} ${durationMs}ms (${error.code})`
+        );
+        writeJson(res, error.status, { error: { code: error.code, message: error.message } });
+        return;
+      }
+      log(`[adep] ${req.method ?? "GET"} /${fnName} -> 500 ${durationMs}ms`);
+      writeJson(res, 500, {
+        error: {
+          code: "FN_EXEC_ERROR",
+          message: error instanceof Error ? error.message : "\u51FD\u6570\u6267\u884C\u5931\u8D25"
+        }
+      });
+    }
+  };
+  const server = createServer((req, res) => {
+    void handle(req, res);
+  });
+  const port = options.port ?? 8787;
+  const disposeAfterListenError = async () => {
+    if (debounceTimer !== void 0) clearTimeout(debounceTimer);
+    try {
+      watcher?.close();
+    } catch {
+    }
+    try {
+      await executor.dispose();
+    } catch {
+    }
+    try {
+      await runtime.dispose();
+    } catch {
+    }
+  };
+  await new Promise((resolveListen, rejectListen) => {
+    const onListenError = (error) => {
+      void disposeAfterListenError().finally(() => rejectListen(error));
+    };
+    server.once("error", onListenError);
+    server.listen(port, "127.0.0.1", () => {
+      server.off("error", onListenError);
+      resolveListen();
+    });
+  });
+  const address = server.address();
+  const actualPort = typeof address === "object" && address !== null ? address.port : port;
+  const baseUrl = `http://127.0.0.1:${actualPort}`;
+  const coldStartMs = Date.now() - coldStartAt;
+  const curlPath = config.functionsPrefix.length === 0 ? "/hello" : `/${config.functionsPrefix}/hello`;
+  log(`[adep] dev server listening on ${baseUrl}\uFF08\u6A21\u62DF\u8FD0\u884C\u65F6\uFF0C\u51B7\u542F\u52A8 ${coldStartMs}ms\uFF09`);
+  log(`[adep] curl \u793A\u4F8B\uFF1Acurl ${baseUrl}${curlPath}`);
+  printBoundaries(log);
+  log(`[adep] \u6A21\u62DF\u6570\u636E\u76EE\u5F55\uFF1A${simDir(cwd)}`);
+  return {
+    port: actualPort,
+    baseUrl,
+    close: async () => {
+      if (debounceTimer !== void 0) clearTimeout(debounceTimer);
+      watcher?.close();
+      await new Promise((resolveClose) => server.close(() => resolveClose()));
+      await executor.dispose();
+      await runtime.dispose();
+    }
+  };
+}
+
+// packages/cli/src/vite.ts
+import {
+  createAdepFnProxyScriptMiddleware,
+  createAdepProxyMiddleware,
+  FN_FETCH_INTERCEPTOR_SCRIPT,
+  injectFnProxyScriptTag,
+  isAddrInUse,
+  normalizeFunctionPrefix
+} from "@adep/vite-plugin";
+var createDevServer = (opts) => startDevServer({ cwd: opts.cwd, port: opts.port, prefix: opts.prefix, log: opts.log });
+var loadConfig2 = (cwd) => loadAdepConfigModule(cwd);
+function adepVitePlugin(options = {}) {
+  return adepPlugin({ ...options, createDevServer, loadConfig: loadConfig2 });
+}
+var vite_default = adepVitePlugin;
+export {
+  FN_FETCH_INTERCEPTOR_SCRIPT,
+  adepVitePlugin,
+  createAdepFnProxyScriptMiddleware,
+  createAdepProxyMiddleware,
+  vite_default as default,
+  injectFnProxyScriptTag,
+  isAddrInUse,
+  normalizeFunctionPrefix
+};