@adep/runtime 0.1.0

package/dist/index.js

@@ -0,0 +1,1397 @@
+// 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/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"
+};
+
+// 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((resolve2, 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();
+            resolve2({ 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/runtime/src/database/sdk/cloud.ts
+import { randomUUID } from "node:crypto";
+
+// 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
+import { randomFillSync } from "node:crypto";
+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 ulid(now = Date.now()) {
+  const time = encodeTime(now);
+  let random;
+  if (now === lastTime) {
+    random = incrBase32(lastRandom);
+  } else {
+    lastTime = now;
+    const bytes = new Uint8Array(10);
+    randomFillSync(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 = 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/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/signature.ts
+import { createHmac, timingSafeEqual } from "node:crypto";
+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 createHmac("sha256", secret).update(payload).digest("hex");
+}
+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}`;
+}
+function verifyDownloadSignature(config, projectId, path, query, nowSeconds = Math.floor(Date.now() / 1e3)) {
+  const expiresRaw = query.expires;
+  const signatureRaw = query.signature;
+  if (typeof expiresRaw !== "string" || typeof signatureRaw !== "string") {
+    return { ok: false, reason: "missing" };
+  }
+  if (!/^\d{1,15}$/.test(expiresRaw)) return { ok: false, reason: "malformed" };
+  const expires = Number(expiresRaw);
+  if (!Number.isFinite(expires)) return { ok: false, reason: "malformed" };
+  if (nowSeconds > expires) return { ok: false, reason: "expired" };
+  const expected = sign(config.secret, projectId, path, expires);
+  const actual = Buffer.from(signatureRaw, "utf8");
+  const candidate = Buffer.from(expected, "utf8");
+  if (actual.length !== candidate.length || !timingSafeEqual(actual, candidate)) {
+    return { ok: false, reason: "invalid" };
+  }
+  return { ok: true };
+}
+
+// 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/runtime/src/shared/function-source.ts
+async function resolveFunctionSource(db, fn) {
+  const readDraft = async () => {
+    const drafts = await db.functionFiles.listByFunction(fn.id);
+    if (drafts.length === 0) return null;
+    return Object.fromEntries(drafts.map((file) => [file.path, file.content]));
+  };
+  if (fn.publishedVersion === null || fn.publishedVersion === void 0) return readDraft();
+  const version = await db.functionVersions.findByFunctionAndVersion(fn.id, fn.publishedVersion);
+  if (version === null) return readDraft();
+  return parseSnapshot(version.code);
+}
+function parseSnapshot(code) {
+  return JSON.parse(code);
+}
+export {
+  CHAIN_CAPABILITY_KEY,
+  DB_RPC,
+  DEFAULT_MEMORY_LIMIT_MB,
+  DEFAULT_TIMEOUT_MS,
+  ExecutorError,
+  OOM_CODE,
+  RPC_CAPABILITY_KEY,
+  STORAGE_CODES,
+  StorageError,
+  TIMEOUT_CODE,
+  WorkerFunctionExecutor,
+  createCloudDb,
+  createDbCapability,
+  createLocalStorageDriver,
+  createStorageCapability,
+  parseSnapshot,
+  resolveFunctionSource,
+  signDownloadUrl,
+  verifyDownloadSignature
+};