@adep/cli 0.1.1 → 0.1.2

package/dist/vite.js

@@ -5,7 +5,7 @@ import { adepPlugin } from "@adep/vite-plugin";
 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";
+import { basename, join as join8, resolve as resolve2 } from "node:path";
 
 // packages/runtime/src/shared/capability-keys.ts
 var RPC_CAPABILITY_KEY = "__adepRpc";
@@ -13,6 +13,8 @@ var CHAIN_CAPABILITY_KEY = "__adepChain";
 var DB_RPC = {
   /** 直通方法（如 query）：`(method=query, args=[sql, params])`。 */
   query: "query",
+  /** 写路径（CF-013）：`(method=writeQuery, args=[sql, params])` → `{ changes }`。 */
+  writeQuery: "writeQuery",
   /** 读取 owned 表变更流（DB-006）：`(method=changes, args=[table, query])`。 */
   changes: "changes",
   /** 开启事务：`begin → txId`。 */
@@ -59,6 +61,25 @@ function normalizeHttpStatus(status) {
   return isHttpStatus(status) ? status : 500;
 }
 
+// packages/runtime/src/shared/http-envelope.ts
+function isAdepHttpEnvelope(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const envelope = value.__adepHttp;
+  if (typeof envelope !== "object" || envelope === null) return false;
+  const status = envelope.status;
+  return typeof status === "number" && Number.isInteger(status) && status >= 100 && status <= 599;
+}
+function writeEnvelopeResponse(res, envelope) {
+  const { status, headers, body } = envelope.__adepHttp;
+  const noBody = status >= 100 && status < 200 || status === 204 || status === 205;
+  res.writeHead(status, { "content-type": "application/json", ...headers });
+  if (noBody) {
+    res.end();
+    return;
+  }
+  res.end(JSON.stringify(body === void 0 ? null : body));
+}
+
 // packages/runtime/src/functions/runtime/worker-executor.ts
 import { readFileSync } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -161,6 +182,13 @@ function classifyDependencies(dependencies, builtin) {
   }
   return { builtinDeps, customDeps };
 }
+function splitBareSpecifier(request) {
+  if (request.startsWith("@")) {
+    const segments = request.split("/");
+    return segments.slice(0, 2).join("/");
+  }
+  return request.split("/")[0];
+}
 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);
@@ -378,21 +406,35 @@ function unsafeOperation(message) {
 function stripLiterals(sql) {
   return sql.replace(/'[^']*(?:''[^']*)*'/g, "").replace(/"[^"]*(?:""[^"]*)*"/g, "").replace(/--[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
 }
-function assertReadOnlyQuery(sql) {
+function sqlHead(sql) {
+  return sql.trim().replace(/^\(+/, "").trim().toUpperCase();
+}
+function assertSafeStatement(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");
   }
+  return sqlHead(stripped);
+}
+function assertReadOnlyQuery(sql) {
+  const head = assertSafeStatement(sql);
+  if (!head.startsWith("SELECT") && !head.startsWith("WITH")) {
+    throw unsafeOperation("cloud.db.query \u4EC5\u5141\u8BB8\u53EA\u8BFB\u67E5\u8BE2\uFF08SELECT / WITH\uFF09");
+  }
+}
+function assertWriteQuery(sql) {
+  const head = assertSafeStatement(sql);
+  if (!head.startsWith("INSERT") && !head.startsWith("UPDATE") && !head.startsWith("DELETE")) {
+    throw unsafeOperation(
+      "cloud.db.writeQuery \u4EC5\u5141\u8BB8 DML\uFF08INSERT / UPDATE / DELETE\uFF09\uFF0CDDL \u8BF7\u8D70\u63A7\u5236\u53F0"
+    );
+  }
 }
 
 // packages/runtime/src/database/builder/owned.ts
@@ -938,6 +980,14 @@ function createCloudDb(driver, options = {}) {
         assertReadOnlyQuery(sql);
         return driver.all(sql, params);
       },
+      async writeQuery(sql, params) {
+        if (!Array.isArray(params)) {
+          throw unsafeOperation("writeQuery \u7684 params \u5FC5\u987B\u63D0\u4F9B\uFF08\u65E0\u53C2\u4F20 []\uFF09");
+        }
+        guardWrite();
+        assertWriteQuery(sql);
+        return driver.run(sql, params);
+      },
       async changes(table, query = {}) {
         return readChanges(driver, table, query);
       }
@@ -953,7 +1003,8 @@ var CLOUD_DB_SPEC = {
   rootMethod: "table",
   stepMethods: ["select", "where", "orderBy", "limit", "offset"],
   terminalMethods: ["get", "first", "count", "insert", "insertMany", "update", "delete"],
-  directMethods: ["query", "changes"],
+  // CF-013：writeQuery 是 D1 shim 的写路径（INSERT/UPDATE/DELETE），与 query 并列直通方法。
+  directMethods: ["query", "writeQuery", "changes"],
   transactionMethod: "transaction"
 };
 var WRITE_TERMINALS = /* @__PURE__ */ new Set(["insert", "insertMany", "update", "delete"]);
@@ -1008,6 +1059,10 @@ function createDbCapability(driver, options = {}) {
           const [sql, params] = args;
           return await db.query(sql, params);
         }
+        case DB_RPC.writeQuery: {
+          const [sql, params] = args;
+          return await db.writeQuery(sql, params);
+        }
         case DB_RPC.changes: {
           const [table, query] = args;
           return await db.changes(table, query);
@@ -1489,6 +1544,106 @@ function createSimDbCapability(options = {}) {
   return { bundle, engine, driver };
 }
 
+// packages/runtime/src/database/sdk/kv.ts
+var KV_TABLE = "_adep_kv";
+var KV_RPC = {
+  get: "get",
+  put: "put",
+  delete: "delete",
+  list: "list"
+};
+var KV_CAPABILITY_CODES = {
+  invalidMethod: "KV_INVALID_METHOD"
+};
+var KV_LIST_DEFAULT_LIMIT = 100;
+function nowSeconds() {
+  return Math.floor(Date.now() / 1e3);
+}
+function errorWithCode2(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 createKvCapability(driver) {
+  let ensurePromise = null;
+  const ensureTable = () => {
+    if (ensurePromise === null) {
+      ensurePromise = driver.run(
+        `CREATE TABLE IF NOT EXISTS ${KV_TABLE} (key TEXT PRIMARY KEY, value TEXT, expires_at INTEGER)`
+      ).then(() => void 0);
+    }
+    return ensurePromise;
+  };
+  const handler = async (method, args) => {
+    try {
+      await ensureTable();
+      switch (method) {
+        case KV_RPC.get: {
+          const [key] = args;
+          const row = await driver.get(`SELECT value, expires_at FROM ${KV_TABLE} WHERE key = ?`, [
+            key
+          ]);
+          if (row === null || row === void 0) return null;
+          const expiresAt = row.expires_at;
+          if (expiresAt !== null && expiresAt !== void 0 && Number(expiresAt) <= nowSeconds()) {
+            return null;
+          }
+          return row.value;
+        }
+        case KV_RPC.put: {
+          const [key, value, options] = args;
+          const ttl = options?.expirationTtlSeconds;
+          const expiresAt = typeof ttl === "number" && ttl > 0 ? nowSeconds() + Math.floor(ttl) : null;
+          await driver.run(`DELETE FROM ${KV_TABLE} WHERE key = ?`, [key]);
+          await driver.run(`INSERT INTO ${KV_TABLE} (key, value, expires_at) VALUES (?, ?, ?)`, [
+            key,
+            value,
+            expiresAt
+          ]);
+          return void 0;
+        }
+        case KV_RPC.delete: {
+          const [key] = args;
+          await driver.run(`DELETE FROM ${KV_TABLE} WHERE key = ?`, [key]);
+          return void 0;
+        }
+        case KV_RPC.list: {
+          const [options] = args;
+          const prefix = options?.prefix ?? "";
+          const limit = options?.limit ?? KV_LIST_DEFAULT_LIMIT;
+          const rows = prefix === "" ? await driver.all(`SELECT key, expires_at FROM ${KV_TABLE}`) : await driver.all(`SELECT key, expires_at FROM ${KV_TABLE} WHERE key LIKE ?`, [
+            `${prefix}%`
+          ]);
+          const now = nowSeconds();
+          const entries = [];
+          for (const row of rows) {
+            const expiresAt = row.expires_at;
+            if (expiresAt !== null && expiresAt !== void 0 && Number(expiresAt) <= now) continue;
+            entries.push({
+              name: String(row.key),
+              expiration: expiresAt === null || expiresAt === void 0 ? null : Number(expiresAt)
+            });
+            if (entries.length >= limit) break;
+          }
+          return entries;
+        }
+        default:
+          throw new Error(
+            `\u672A\u77E5\u7684 cloud.kv \u65B9\u6CD5 "${String(method)}"\uFF08${KV_CAPABILITY_CODES.invalidMethod}\uFF09`
+          );
+      }
+    } catch (error) {
+      throw errorWithCode2(error);
+    }
+  };
+  return {
+    capabilities: [{ name: "kv", value: { [RPC_CAPABILITY_KEY]: true } }],
+    rpcHandlers: { kv: handler }
+  };
+}
+
 // packages/cli/src/sim/storage.ts
 import { join as join3 } from "node:path";
 
@@ -1732,9 +1887,12 @@ function createStorageCapability(driver, signer, projectId) {
   const handler = async (method, args) => {
     switch (method) {
       case "upload": {
-        const [path, data] = args;
+        const [path, data, options] = args;
         return toStoredFile(
-          await driver.put(projectId, path, asBytes(data), { visibility: DEFAULT_VISIBILITY })
+          await driver.put(projectId, path, asBytes(data), {
+            visibility: DEFAULT_VISIBILITY,
+            ...options?.contentType === void 0 ? {} : { contentType: options.contentType }
+          })
         );
       }
       case "get": {
@@ -2160,7 +2318,8 @@ async function createSimRuntime(options) {
     projectId: options.projectId ?? "local"
   });
   const simRealtime = createSimRealtimeCapability();
-  const bundle = mergeBundles([db.bundle, storage.bundle, simRealtime.bundle]);
+  const kvBundle = createKvCapability(db.driver);
+  const bundle = mergeBundles([db.bundle, storage.bundle, kvBundle, simRealtime.bundle]);
   await db.engine.load();
   return {
     bundle,
@@ -2246,6 +2405,13 @@ function createSimInvokeHandler(options) {
   };
 }
 
+// packages/cli/src/builtin-deps.ts
+var LOCAL_STATE_OBJECTS_SPECIFIER = "@adep/runtime/state-objects";
+var LOCAL_BUILTIN_DEPS = [
+  "@adep/cf-compat",
+  LOCAL_STATE_OBJECTS_SPECIFIER
+];
+
 // packages/cli/src/sim/boundary.ts
 var SIM_BOUNDARIES = [
   {
@@ -2301,6 +2467,51 @@ function asStringRecord(value) {
   }
   return rec;
 }
+function asBindingArray(value, label, errors, optionalKey) {
+  if (!Array.isArray(value)) {
+    errors.push(`${label} \u5FC5\u987B\u662F\u6570\u7EC4\uFF0C\u6536\u5230 ${typeNameOf(value)}`);
+    return null;
+  }
+  const out = [];
+  value.forEach((item, i) => {
+    const idx = `${label}[${i}]`;
+    if (item === null || typeof item !== "object" || Array.isArray(item)) {
+      errors.push(`${idx} \u5FC5\u987B\u662F\u5BF9\u8C61\uFF0C\u6536\u5230 ${typeNameOf(item)}`);
+      return;
+    }
+    const rec = item;
+    if (typeof rec.name !== "string" || rec.name.length === 0) {
+      errors.push(`${idx}.name \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\uFF0C\u6536\u5230 ${typeNameOf(rec.name)}`);
+      return;
+    }
+    const entry = { name: rec.name };
+    const optional = rec[optionalKey];
+    if (optional !== void 0) {
+      if (typeof optional !== "string") {
+        errors.push(`${idx}.${optionalKey} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\uFF0C\u6536\u5230 ${typeNameOf(optional)}`);
+      } else {
+        entry[optionalKey] = optional;
+      }
+    }
+    out.push(entry);
+  });
+  return out;
+}
+function asCfBindingsConfig(value, errors) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    errors.push(`cfBindings \u5FC5\u987B\u662F\u5BF9\u8C61\uFF0C\u6536\u5230 ${typeNameOf(value)}`);
+    return null;
+  }
+  const rec = value;
+  const bindings = {};
+  const kv = rec.kv === void 0 ? void 0 : asBindingArray(rec.kv, "cfBindings.kv", errors, "namespace");
+  if (kv !== null && kv !== void 0) bindings.kv = kv;
+  const d1 = rec.d1 === void 0 ? void 0 : asBindingArray(rec.d1, "cfBindings.d1", errors, "database");
+  if (d1 !== null && d1 !== void 0) bindings.d1 = d1;
+  const r2 = rec.r2 === void 0 ? void 0 : asBindingArray(rec.r2, "cfBindings.r2", errors, "bucket");
+  if (r2 !== null && r2 !== void 0) bindings.r2 = r2;
+  return bindings;
+}
 function parseAdepConfig(raw) {
   if (raw === null || raw === void 0) {
     return { ok: true, data: { ...DEFAULT_ADEP_CONFIG } };
@@ -2361,6 +2572,10 @@ function parseAdepConfig(raw) {
       data.runtime = rec;
     }
   }
+  if (input.cfBindings !== void 0) {
+    const bindings = asCfBindingsConfig(input.cfBindings, errors);
+    if (bindings !== null) data.cfBindings = bindings;
+  }
   if (errors.length > 0) return { ok: false, errors };
   return { ok: true, data };
 }
@@ -2409,6 +2624,1027 @@ ${result.errors.map((e) => `  - ${e}`).join("\n")}`;
   return result.data;
 }
 
+// packages/runtime/src/state-objects/runtime.ts
+var StateObject = class {
+  id;
+  /** 对象内存状态（单例驻留）；load 时从后端恢复。 */
+  state;
+  alarmAt = null;
+  /** 运行时注入的持久化句柄（内部；protected，子类 flush() 使用）。 */
+  runtime;
+  constructor(id) {
+    this.id = id;
+    this.state = this.initialState();
+  }
+  /** 供运行时读取/序列化。 */
+  getState() {
+    return { ...this.state };
+  }
+  /** 通用快照方法（任何对象可经 invoke(type, id, 'snapshot') 读取）。 */
+  async snapshot() {
+    return this.getState();
+  }
+  /** 设置未来唤醒（alarm）：到期时运行时调 onAlarm（调度 CF-037 落地）。 */
+  setAlarm(at) {
+    this.alarmAt = at;
+  }
+  clearAlarm() {
+    this.alarmAt = null;
+  }
+  /** alarm 到期回调（子类覆写）。 */
+  async onAlarm() {
+  }
+  /** 显式持久化当前状态（方法内任何位置可调）。 */
+  async flush() {
+    await this.runtime.flush(this);
+  }
+};
+var StateObjectError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "StateObjectError";
+    this.code = code;
+  }
+};
+var StateObjectRuntime = class {
+  registry = /* @__PURE__ */ new Map();
+  instances = /* @__PURE__ */ new Map();
+  backend;
+  constructor(backend) {
+    this.backend = backend;
+  }
+  define(cls) {
+    this.registry.set(cls.typeName, cls);
+  }
+  /** 已注册类型清单（控制台/审计用）。 */
+  types() {
+    return [...this.registry.keys()];
+  }
+  /** 内存驻留实例数（诊断用）。 */
+  residentCount() {
+    return this.instances.size;
+  }
+  key(type, id) {
+    return `${type}:${id}`;
+  }
+  /** 取对象实例（单例驻留）：内存有 → 复用；无 → 后端恢复或 new 初始态。 */
+  async get(type, id) {
+    const cls = this.registry.get(type);
+    if (cls === void 0) {
+      throw new StateObjectError(
+        "STATE_TYPE_NOT_REGISTERED",
+        `\u72B6\u6001\u5BF9\u8C61\u7C7B\u578B "${type}" \u672A\u6CE8\u518C\uFF08\u5DF2\u6CE8\u518C\uFF1A${this.types().join(", ") || "\u65E0"}\uFF09`
+      );
+    }
+    const k = this.key(type, id);
+    const hit = this.instances.get(k);
+    if (hit !== void 0) return hit;
+    const snapshot = await this.backend.load(type, id);
+    const raw = new cls(id);
+    const created = raw;
+    created.state = snapshot !== null ? snapshot.state : created.state;
+    created.alarmAt = snapshot !== null ? snapshot.alarmAt : null;
+    created.runtime = this;
+    this.instances.set(k, created);
+    return created;
+  }
+  /** 方法路由：单例对象上串行执行方法。 */
+  async invoke(type, id, method, args = []) {
+    const inst = await this.get(type, id);
+    const fn = inst[method];
+    if (typeof fn !== "function") {
+      throw new StateObjectError(
+        "STATE_METHOD_NOT_FOUND",
+        `\u72B6\u6001\u5BF9\u8C61 "${type}:${id}" \u65E0\u65B9\u6CD5 "${method}"`
+      );
+    }
+    try {
+      return await fn.call(inst, ...args);
+    } catch (error) {
+      if (error instanceof StateObjectError) throw error;
+      throw new StateObjectError(
+        "STATE_INVOKE_ERROR",
+        `\u72B6\u6001\u5BF9\u8C61 "${type}:${id}" \u65B9\u6CD5 "${method}" \u6267\u884C\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /** 持久化快照（对象方法内 flush() 触发，或运行时统一写）。 */
+  async flush(inst) {
+    const raw = inst;
+    const type = inst.constructor.typeName;
+    if (type === void 0) {
+      throw new StateObjectError("STATE_TYPE_NOT_REGISTERED", "\u72B6\u6001\u5BF9\u8C61\u7C7B\u5FC5\u987B\u58F0\u660E static typeName");
+    }
+    await this.backend.save(type, inst.id, inst.getState(), raw.alarmAt);
+  }
+  /**
+   * alarm 轮询：把到期对象唤醒并调 onAlarm（CF-037）。
+   * - onAlarm 后统一持久化（flush）：onAlarm 内改的 state 与 setAlarm 重调度 / clearAlarm
+   *   的新 alarmAt 都落库；
+   * - 单对象 onAlarm 抛错**不阻塞**同 tick 其余对象：失败对象不落库、alarmAt 保留
+   *   → 下轮 dueAlarms 仍命中重试；错误折叠进 failed（不泄漏内部栈）。
+   */
+  async pump(now) {
+    const due = await this.backend.dueAlarms(now);
+    const fired = [];
+    const failed = [];
+    for (const d of due) {
+      try {
+        const inst = await this.get(d.type, d.id);
+        await inst.onAlarm();
+        await this.flush(inst);
+        fired.push({ type: d.type, id: d.id });
+      } catch (error) {
+        failed.push({
+          type: d.type,
+          id: d.id,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return { fired, failed };
+  }
+  /** 释放内存驻留（进程重启 / 测试隔离用）；不删后端数据。 */
+  evictAll() {
+    this.instances.clear();
+  }
+};
+
+// packages/runtime/src/state-objects/backend.ts
+var STATE_OBJECTS_TABLE = "_adep_state_objects";
+function createProjectDriverStateBackend(driver) {
+  let ensured = false;
+  const ensureTable = async () => {
+    if (ensured) return;
+    await driver.run(
+      `CREATE TABLE IF NOT EXISTS ${STATE_OBJECTS_TABLE} ("type" TEXT NOT NULL, "id" TEXT NOT NULL, "state" TEXT NOT NULL, "alarm_at" INTEGER, "updated_at" INTEGER NOT NULL, PRIMARY KEY ("type", "id"))`
+    );
+    ensured = true;
+  };
+  return {
+    async load(type, id) {
+      await ensureTable();
+      const rows = await driver.all(
+        `SELECT "state", "alarm_at" FROM ${STATE_OBJECTS_TABLE} WHERE "type" = ? AND "id" = ?`,
+        [type, id]
+      );
+      if (rows.length === 0) return null;
+      return {
+        state: JSON.parse(String(rows[0].state)),
+        alarmAt: rows[0].alarm_at
+      };
+    },
+    async save(type, id, state, alarmAt) {
+      await ensureTable();
+      const existing = await driver.all(
+        `SELECT 1 FROM ${STATE_OBJECTS_TABLE} WHERE "type" = ? AND "id" = ?`,
+        [type, id]
+      );
+      const stateJson = JSON.stringify(state);
+      if (existing.length === 0) {
+        await driver.run(
+          `INSERT INTO ${STATE_OBJECTS_TABLE} ("type", "id", "state", "alarm_at", "updated_at") VALUES (?, ?, ?, ?, ?)`,
+          [type, id, stateJson, alarmAt, Date.now()]
+        );
+      } else {
+        await driver.run(
+          `UPDATE ${STATE_OBJECTS_TABLE} SET "state" = ?, "alarm_at" = ?, "updated_at" = ? WHERE "type" = ? AND "id" = ?`,
+          [stateJson, alarmAt, Date.now(), type, id]
+        );
+      }
+    },
+    async dueAlarms(now) {
+      await ensureTable();
+      const rows = await driver.all(
+        `SELECT "type", "id", "alarm_at" FROM ${STATE_OBJECTS_TABLE} WHERE "alarm_at" IS NOT NULL AND "alarm_at" <= ?`,
+        [now]
+      );
+      return rows.map((r) => ({
+        type: r.type,
+        id: r.id,
+        alarmAt: r.alarm_at
+      }));
+    },
+    async remove(type, id) {
+      await ensureTable();
+      await driver.run(`DELETE FROM ${STATE_OBJECTS_TABLE} WHERE "type" = ? AND "id" = ?`, [
+        type,
+        id
+      ]);
+    }
+  };
+}
+
+// packages/runtime/src/state-objects/http.ts
+var STATE_PATH = "state";
+function parseStatePath(rest) {
+  const segments = rest.split("/").filter((s) => s.length > 0);
+  if (segments[0] !== STATE_PATH || segments.length < 4) return null;
+  return {
+    type: decodeURIComponent(segments[1]),
+    id: decodeURIComponent(segments[2]),
+    method: decodeURIComponent(segments.slice(3).join("/"))
+  };
+}
+function parseStateBody(body) {
+  if (body === null || body.length === 0) return { args: [] };
+  try {
+    const parsed = JSON.parse(body);
+    if (!Array.isArray(parsed)) return { error: "body \u5FC5\u987B\u662F\u53C2\u6570\u6570\u7EC4\uFF08JSON\uFF09" };
+    return { args: parsed };
+  } catch {
+    return { error: "body \u5FC5\u987B\u662F\u5408\u6CD5 JSON" };
+  }
+}
+
+// packages/runtime/src/state-objects/demo.ts
+var DemoCounter = class extends StateObject {
+  static typeName = "DemoCounter";
+  initialState() {
+    return { count: 0 };
+  }
+  async increment(by = 1) {
+    this.state.count += by;
+    await this.flush();
+    return { count: this.state.count };
+  }
+  async get() {
+    return { count: this.state.count };
+  }
+};
+var DemoChatRoom = class extends StateObject {
+  static typeName = "DemoChatRoom";
+  initialState() {
+    return { members: [], messages: [], cursor: 0 };
+  }
+  async join(user) {
+    if (!this.state.members.includes(user)) this.state.members.push(user);
+    this.state.cursor += 1;
+    await this.flush();
+    return { members: this.state.members, cursor: this.state.cursor };
+  }
+  async send(user, text) {
+    const seq = this.state.messages.length + 1;
+    this.state.messages.push({ user, text, at: Date.now() });
+    await this.flush();
+    return { seq };
+  }
+};
+
+// packages/runtime/src/functions/runtime/sandbox.ts
+import vm from "node:vm";
+import * as nodeModule from "node:module";
+
+// packages/runtime/src/functions/runtime/exports.ts
+function transformModule(code) {
+  let out = code;
+  const named = [];
+  out = out.replace(/(^|\n)(\s*)export\s+default\s+/g, "$1$2module.default = ");
+  out = out.replace(
+    /import\s*\{([^}]*)\}\s*from\s*(['"][^'"]*['"])[ \t]*;?/g,
+    (_match, names, source) => `const {${names}} = require(${source})`
+  );
+  out = out.replace(
+    /import\s*\*\s*as\s*([A-Za-z_$][\w$]*)\s*from\s*(['"][^'"]*['"])[ \t]*;?/g,
+    (_match, name, source) => `const ${name} = require(${source})`
+  );
+  out = out.replace(
+    /import\s+([A-Za-z_$][\w$]*)\s+from\s*(['"][^'"]*['"])[ \t]*;?/g,
+    (_match, name, source) => `const ${name} = require(${source})`
+  );
+  out = out.replace(
+    /export\s+(const|let|var)\s+([A-Za-z_$][\w$]*)/g,
+    (_match, kw, name) => {
+      named.push(name);
+      return `${kw} ${name}`;
+    }
+  );
+  out = out.replace(
+    /export\s+(async\s+)?function\s*\*?\s*([A-Za-z_$][\w$]*)/g,
+    (_match, asyncKw, name) => {
+      named.push(name);
+      return `${asyncKw ?? ""}function ${name}`;
+    }
+  );
+  out = out.replace(/export\s+class\s+([A-Za-z_$][\w$]*)/g, (_match, name) => {
+    named.push(name);
+    return `class ${name}`;
+  });
+  if (named.length > 0) {
+    out += `
+;Object.assign(exports, { ${named.join(", ")} })`;
+  }
+  return out;
+}
+
+// packages/runtime/src/functions/runtime/sandbox.ts
+var bunTranspiler;
+function transpile(code) {
+  const bun = globalThis["Bun"];
+  if (bun?.Transpiler !== void 0) {
+    bunTranspiler ??= new bun.Transpiler({ loader: "ts" });
+    return bunTranspiler.transformSync(code);
+  }
+  const stripTypeScriptTypes2 = nodeModule.stripTypeScriptTypes;
+  if (typeof stripTypeScriptTypes2 === "function") {
+    return stripTypeScriptTypes2(code, { mode: "strip" });
+  }
+  return code;
+}
+function transformExports(code) {
+  return transformModule(code);
+}
+var SANDBOX_BUILTIN_REJECTED = "FN_SANDBOX_BUILTIN_BLOCKED";
+function resolveModulePath(fromDir, request, files) {
+  if (!request.startsWith("./") && !request.startsWith("../")) return null;
+  const base = joinPosix(fromDir, request);
+  const candidates = [base, `${base}.ts`, `${base}.js`, `${base}/index.ts`, `${base}/index.js`];
+  for (const candidate of candidates) {
+    const normalized = normalizePosix(candidate);
+    if (files[normalized] !== void 0) return normalized;
+  }
+  return null;
+}
+function joinPosix(dir, request) {
+  const parts = [...dir.split("/"), ...request.split("/")];
+  const stack = [];
+  for (const part of parts) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") stack.pop();
+    else stack.push(part);
+  }
+  return stack.join("/");
+}
+function normalizePosix(p) {
+  return joinPosix("", p);
+}
+function loadModule(path, files, sandboxGlobals, cache, resolveBare, bareCache) {
+  const cached = cache.get(path);
+  if (cached !== void 0) return cached;
+  const source = files[path];
+  if (source === void 0) {
+    throw new Error(`\u6A21\u5757\u4E0D\u5B58\u5728\uFF1A${path}`);
+  }
+  const exports = {};
+  cache.set(path, exports);
+  const dir = path.includes("/") ? path.slice(0, path.lastIndexOf("/")) : "";
+  const module = { exports, default: void 0 };
+  const require2 = (request) => {
+    const resolved = resolveModulePath(dir, request, files);
+    if (resolved !== null) {
+      return loadModule(resolved, files, sandboxGlobals, cache, resolveBare, bareCache);
+    }
+    if (resolveBare !== void 0 && !request.startsWith("./") && !request.startsWith("../")) {
+      const cachedModule = bareCache?.get(request);
+      if (cachedModule !== void 0) return cachedModule;
+      const loaded = resolveBare(request);
+      bareCache?.set(request, loaded);
+      return loaded;
+    }
+    const error = new Error(
+      `\u6C99\u7BB1\u62D2\u7EDD\u8BE5\u5F15\u7528\uFF1A"${request}"\u3002\u51FD\u6570\u5185\u53EA\u80FD require \u9879\u76EE\u5185\u7684\u76F8\u5BF9\u8DEF\u5F84\u6587\u4EF6\uFF08FN_SANDBOX_BUILTIN_BLOCKED\uFF09`
+    );
+    error.code = SANDBOX_BUILTIN_REJECTED;
+    throw error;
+  };
+  let transformed;
+  try {
+    transformed = transformExports(transpile(source));
+  } catch (error) {
+    const rawMessage = error instanceof Error ? error.message : String(error);
+    const stack = error.stack;
+    const line = typeof stack === "string" ? /(?:^|\n):(\d+)(?:\n|$)/.exec(stack)?.[1] : void 0;
+    const location = line === void 0 ? path : `${path}:${line}`;
+    const wrapped = new Error(`\u6E90\u7801\u8BED\u6CD5\u9519\u8BEF\uFF08${location}\uFF09\uFF1A${rawMessage}`, { cause: error });
+    const code = error.code;
+    if (typeof code === "string") wrapped.code = code;
+    throw wrapped;
+  }
+  const wrapper = vm.runInNewContext(
+    `(function (module, exports, require) { ${transformed} 
+})`,
+    vm.createContext({ ...sandboxGlobals }),
+    { filename: path }
+  );
+  wrapper(module, exports, require2);
+  if (module.default !== void 0 && exports["default"] === void 0) {
+    exports["default"] = module.default;
+  }
+  return exports;
+}
+function loadFunctionModule(files, entry, sandboxGlobals, resolveBare) {
+  const cache = /* @__PURE__ */ new Map();
+  const bareCache = /* @__PURE__ */ new Map();
+  const entryExports = loadModule(entry, files, sandboxGlobals, cache, resolveBare, bareCache);
+  const handler = entryExports["default"];
+  if (typeof handler !== "function") {
+    throw new Error(`\u5165\u53E3\u6587\u4EF6 ${entry} \u7F3A\u5C11 default \u5BFC\u51FA\u7684\u51FD\u6570`);
+  }
+  return { handler };
+}
+
+// packages/runtime/src/state-objects/loader.ts
+var STATE_OBJECTS_ENTRY = "state-objects.ts";
+var STATE_OBJECTS_SPECIFIER = "@adep/runtime/state-objects";
+function resolveStateObjectSpecifier(request) {
+  if (request === STATE_OBJECTS_SPECIFIER) return { StateObject };
+  return void 0;
+}
+function defaultStateSandboxGlobals() {
+  return {
+    console,
+    URL,
+    URLSearchParams,
+    Request,
+    Response,
+    Headers,
+    TextEncoder,
+    TextDecoder,
+    AbortController,
+    AbortSignal,
+    ReadableStream,
+    WritableStream,
+    TransformStream,
+    Blob,
+    FormData,
+    crypto,
+    performance,
+    atob,
+    btoa,
+    structuredClone
+  };
+}
+function collectStateObjectClasses(exports_) {
+  const classes = [];
+  for (const value of Object.values(exports_)) {
+    if (typeof value !== "function") continue;
+    const proto = value.prototype;
+    if (typeof proto !== "object" || proto === null) continue;
+    if (!(proto instanceof StateObject)) continue;
+    if (!Object.hasOwn(value, "typeName")) {
+      throw new Error(
+        `\u72B6\u6001\u5BF9\u8C61\u7C7B\u5FC5\u987B\u58F0\u660E static typeName\uFF08${value.name ?? "anonymous"}\uFF09`
+      );
+    }
+    const typeName = value.typeName;
+    if (typeof typeName !== "string" || typeName.length === 0) {
+      throw new Error(
+        `\u72B6\u6001\u5BF9\u8C61\u7C7B\u5FC5\u987B\u58F0\u660E static typeName\uFF08${value.name ?? "anonymous"}\uFF09`
+      );
+    }
+    classes.push(value);
+  }
+  return classes;
+}
+function loadStateObjectClasses(files, entry = STATE_OBJECTS_ENTRY, options = {}) {
+  if (files[entry] === void 0) {
+    throw new Error(`\u72B6\u6001\u5BF9\u8C61\u58F0\u660E\u6587\u4EF6\u7F3A\u5931\uFF1A${entry}\uFF08\u7EA6\u5B9A ${STATE_OBJECTS_ENTRY}\uFF09`);
+  }
+  const globals = options.sandboxGlobals ?? defaultStateSandboxGlobals();
+  const exportsObject = loadModule(entry, files, globals, /* @__PURE__ */ new Map(), options.resolveBare, /* @__PURE__ */ new Map());
+  return collectStateObjectClasses(exportsObject);
+}
+
+// packages/runtime/src/functions/runtime/worker-entry.ts
+import { parentPort, workerData } from "node:worker_threads";
+import { createRequire } from "node:module";
+import { join as join7 } from "node:path";
+
+// packages/runtime/src/functions/runtime/cloud-container.ts
+var KNOWN_CAPABILITY_HINTS = {
+  db: {
+    code: "DB_NOT_PROVISIONED",
+    message: "\u9879\u76EE\u6570\u636E\u5E93\u5C1A\u672A\u5F00\u542F\uFF1A\u8BF7\u5230\u9879\u76EE\u8BBE\u7F6E\u542F\u52A8\u6570\u636E\u5E93\uFF08DB_NOT_PROVISIONED\uFF09"
+  },
+  storage: {
+    code: "STORAGE_NOT_AVAILABLE",
+    message: "\u6587\u4EF6\u5B58\u50A8\u5C1A\u672A\u5F00\u542F\uFF1A\u8BF7\u5230\u9879\u76EE\u8BBE\u7F6E\u5F00\u542F\u6587\u4EF6\u5B58\u50A8\uFF08STORAGE_NOT_AVAILABLE\uFF09"
+  },
+  fetch: {
+    code: "FN_FETCH_DISABLED",
+    message: "\u6C99\u7BB1\u7F51\u7EDC\u672A\u5F00\u542F\uFF1A\u8BF7\u914D\u7F6E FUNCTIONS_FETCH_ALLOWLIST \u767D\u540D\u5355\u540E\u91CD\u542F\uFF08FN_FETCH_DISABLED\uFF09"
+  },
+  realtime: {
+    code: "REALTIME_NOT_AVAILABLE",
+    message: "\u5B9E\u65F6\u901A\u9053\u672A\u88C5\u914D\uFF1Arealtime \u57DF\u672A\u88C5\u8F7D\uFF08\u68C0\u67E5\u90E8\u7F72\u5F62\u6001\u4E0E Redis \u914D\u7F6E\uFF09\uFF08REALTIME_NOT_AVAILABLE\uFF09"
+  },
+  kv: {
+    code: "KV_NOT_PROVISIONED",
+    message: "\u9879\u76EE KV \u5B58\u50A8\u672A\u53EF\u7528\uFF1Akv \u968F\u9879\u76EE\u6570\u636E\u5E93\u63D0\u4F9B\uFF0C\u8BF7\u5148\u542F\u52A8\u6570\u636E\u5E93\uFF08KV_NOT_PROVISIONED\uFF09"
+  }
+};
+var CapabilityNotRegisteredError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "CapabilityNotRegisteredError";
+  }
+};
+function createCloud(registrations) {
+  const store = registrations;
+  return new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        if (typeof prop !== "string") return void 0;
+        if (!store.has(prop)) {
+          const hint = KNOWN_CAPABILITY_HINTS[prop];
+          throw new CapabilityNotRegisteredError(
+            hint?.code ?? "CAPABILITY_NOT_REGISTERED",
+            hint?.message ?? `\u80FD\u529B "${prop}" \u672A\u6CE8\u518C\uFF1A\u8BF7\u5728\u51FD\u6570\u6240\u5728\u9879\u76EE\u5B89\u88C5\u5BF9\u5E94\u80FD\u529B`
+          );
+        }
+        return store.get(prop);
+      },
+      has: () => true
+      // 支持 'db' in ctx.cloud 形态
+    }
+  );
+}
+function createCloudContainer() {
+  const registry = /* @__PURE__ */ new Map();
+  const names = /* @__PURE__ */ new Set();
+  let cloud = null;
+  const rebuild = () => {
+    cloud = createCloud(registry);
+  };
+  rebuild();
+  return {
+    register(name, impl) {
+      registry.set(name, impl);
+      names.add(name);
+      rebuild();
+    },
+    unregister(name) {
+      registry.delete(name);
+      names.delete(name);
+      rebuild();
+    },
+    get names() {
+      return [...names];
+    },
+    get cloud() {
+      return cloud;
+    }
+  };
+}
+
+// packages/runtime/src/functions/runtime/sandbox-fetch.ts
+var SandboxFetchError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "SandboxFetchError";
+    this.code = code;
+  }
+};
+var DEFAULT_MAX_RESPONSE_BYTES = 100 * 1024 * 1024;
+var defaultFetch = (url, init) => (
+  // 真实 Response 与内部 ResponseLike 结构性一致；getReader 的多态签名差异属纯类型问题，运行语义等价。
+  globalThis.fetch(url, init)
+);
+function isHostAllowed(host, rules) {
+  const h = host.toLocaleLowerCase();
+  return rules.some((raw) => {
+    const rule = raw.trim().toLocaleLowerCase();
+    if (rule.startsWith("*.")) {
+      const base = rule.slice(2);
+      return h === base || h.endsWith(`.${base}`);
+    }
+    return h === rule;
+  });
+}
+var FORBIDDEN = (url) => new SandboxFetchError(
+  "FN_FETCH_FORBIDDEN",
+  `cloud.fetch \u62D2\u7EDD\u8BBF\u95EE "${url}"\uFF1A\u8BE5\u4E3B\u673A\u4E0D\u5728\u6C99\u7BB1\u7F51\u7EDC\u767D\u540D\u5355\u5185\uFF08FN_FETCH_FORBIDDEN\uFF09`
+);
+var TOO_LARGE = new SandboxFetchError(
+  "FN_FETCH_TOO_LARGE",
+  "cloud.fetch \u54CD\u5E94\u4F53\u8D85\u8FC7\u4E0A\u9650\uFF08FN_FETCH_TOO_LARGE\uFF09"
+);
+function headersToRecord(headers) {
+  const out = {};
+  if (headers === void 0 || headers === null) return out;
+  if (typeof headers.forEach === "function") {
+    ;
+    headers.forEach((value, key) => {
+      out[String(key).toLocaleLowerCase()] = String(value);
+    });
+    return out;
+  }
+  for (const [key, value] of Object.entries(headers)) {
+    out[key.toLocaleLowerCase()] = String(value);
+  }
+  return out;
+}
+function contentLength(res) {
+  const headers = res.headers;
+  if (headers === void 0 || headers === null) return null;
+  if (typeof headers.get === "function") {
+    const raw2 = headers.get?.("content-length");
+    if (raw2 === void 0 || raw2 === null || raw2.trim() === "") return null;
+    const n2 = Number(raw2);
+    return Number.isFinite(n2) && n2 >= 0 ? n2 : null;
+  }
+  const record = headers;
+  const raw = record["content-length"] ?? record["Content-Length"];
+  if (raw === void 0 || raw === null) return null;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? n : null;
+}
+function concatChunks(chunks, total) {
+  const merged = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    merged.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return merged;
+}
+async function readBodyBytes(res, maxBytes) {
+  if (maxBytes > 0) {
+    const cl = contentLength(res);
+    if (cl !== null && cl > maxBytes) throw TOO_LARGE;
+  }
+  const body = res.body;
+  if (body !== void 0 && body !== null) {
+    const reader = body.getReader();
+    const chunks = [];
+    let total = 0;
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value !== void 0) {
+        total += value.byteLength;
+        if (maxBytes > 0 && total > maxBytes) throw TOO_LARGE;
+        chunks.push(value);
+      }
+    }
+    return concatChunks(chunks, total);
+  }
+  if (typeof res.arrayBuffer === "function") {
+    const buffer = await res.arrayBuffer();
+    const bytes2 = new Uint8Array(buffer);
+    if (maxBytes > 0 && bytes2.byteLength > maxBytes) throw TOO_LARGE;
+    return bytes2;
+  }
+  const text = await res.text();
+  const bytes = encoder.encode(text);
+  if (maxBytes > 0 && bytes.byteLength > maxBytes) throw TOO_LARGE;
+  return bytes;
+}
+var encoder = new TextEncoder();
+function errorMessageOf(error) {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+function normalizeResponse(res, maxBytes) {
+  let cached = null;
+  let cachedPromise = null;
+  const readCached = () => {
+    if (cached !== null) return Promise.resolve(cached);
+    cachedPromise ??= readBodyBytes(res, maxBytes).then((bytes) => {
+      cached = bytes;
+      return bytes;
+    });
+    return cachedPromise;
+  };
+  const read = () => readCached();
+  return {
+    ok: res.ok,
+    status: res.status,
+    statusText: res.statusText,
+    headers: headersToRecord(res.headers),
+    text: async () => decoder.decode(await read()),
+    arrayBuffer: async () => bufferViewToArrayBuffer(await read()),
+    json: async () => JSON.parse(decoder.decode(await read()))
+  };
+}
+var decoder = new TextDecoder();
+function bufferViewToArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+function createSandboxFetch(options) {
+  const fetchImpl = options.fetchImpl ?? defaultFetch;
+  const { allowlist, timeoutMs } = options;
+  const maxBytes = options.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES;
+  return async (url, init) => {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      throw new SandboxFetchError("FN_FETCH_INVALID_URL", `cloud.fetch \u6536\u5230\u975E\u6CD5 URL"${url}"`);
+    }
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") throw FORBIDDEN(url);
+    if (!isHostAllowed(parsed.hostname, allowlist)) throw FORBIDDEN(url);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const signals = [controller.signal];
+    if (init?.signal !== void 0) signals.push(init.signal);
+    const signal = signals.length === 1 ? signals[0] : AbortSignal.any(signals);
+    try {
+      let res;
+      try {
+        res = await fetchImpl(url, { ...init, signal });
+      } catch (error) {
+        if (controller.signal.aborted) {
+          throw new SandboxFetchError(
+            "FN_FETCH_TIMEOUT",
+            `cloud.fetch \u8BF7\u6C42\u8D85\u65F6\uFF08\u8D85\u8FC7 ${timeoutMs}ms\uFF09`
+          );
+        }
+        if (init?.signal?.aborted === true) {
+          throw new SandboxFetchError("FN_FETCH_ABORTED", "cloud.fetch \u8BF7\u6C42\u88AB\u8C03\u7528\u65B9\u4E2D\u6B62");
+        }
+        throw new SandboxFetchError(
+          "FN_FETCH_FAILED",
+          `cloud.fetch \u8BF7\u6C42\u5931\u8D25\uFF1A${errorMessageOf(error)}`
+        );
+      }
+      return normalizeResponse(res, maxBytes);
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+}
+
+// packages/runtime/src/functions/runtime/chain.ts
+function isChainCapability(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const spec = value[CHAIN_CAPABILITY_KEY];
+  return typeof spec === "object" && spec !== null && Array.isArray(spec.stepMethods) && Array.isArray(spec.terminalMethods);
+}
+function createChainClient(capability, port, pending, nextId, spec) {
+  const call = (method, args) => new Promise((resolve3, reject) => {
+    const id = nextId();
+    pending.set(id, { resolve: resolve3, reject });
+    port.postMessage({ type: "rpc", id, capability, method, args });
+  });
+  const makeChainable = (rootArgs, steps, txId) => new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        if (typeof prop !== "string") return void 0;
+        if (spec.stepMethods.includes(prop)) {
+          return (...args) => makeChainable(rootArgs, [...steps, { method: prop, args }], txId);
+        }
+        if (spec.terminalMethods.includes(prop)) {
+          return (...args) => call(DB_RPC.chain, [
+            {
+              rootArgs,
+              steps,
+              terminal: prop,
+              terminalArgs: args,
+              ...txId === void 0 ? {} : { txId }
+            }
+          ]);
+        }
+        return void 0;
+      }
+    }
+  );
+  const makeRoot = (txId) => new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        if (typeof prop !== "string") return void 0;
+        if (prop === spec.rootMethod) {
+          return (...rootArgs) => makeChainable(rootArgs, [], txId);
+        }
+        if (spec.directMethods.includes(prop)) {
+          return (...args) => call(prop, args);
+        }
+        if (prop === spec.transactionMethod) {
+          return (fn) => orchestrateTransaction(fn, txId);
+        }
+        return void 0;
+      }
+    }
+  );
+  const orchestrateTransaction = async (fn, _outerTxId) => {
+    const txId = await call(DB_RPC.begin, []);
+    const tx = makeRoot(txId);
+    const settle = async (commit) => {
+      await call(commit ? DB_RPC.commit : DB_RPC.rollback, [txId]).catch(() => void 0);
+    };
+    try {
+      const result = await fn(tx);
+      await settle(true);
+      return result;
+    } catch (error) {
+      await settle(false);
+      throw error;
+    }
+  };
+  return makeRoot(void 0);
+}
+
+// packages/runtime/src/functions/runtime/worker-entry.ts
+function isRpcCapability(value) {
+  return typeof value === "object" && value !== null && value[RPC_CAPABILITY_KEY] === true;
+}
+function createRpcClient(capability, port, pending, nextId) {
+  return new Proxy(
+    {},
+    {
+      get(_target, method) {
+        if (typeof method !== "string") return void 0;
+        return (...args) => {
+          const id = nextId();
+          return new Promise((resolve3, reject) => {
+            pending.set(id, { resolve: resolve3, reject });
+            port.postMessage({ type: "rpc", id, capability, method, args });
+          });
+        };
+      }
+    }
+  );
+}
+function errorMessageOf2(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "object" && error !== null && "message" in error) {
+    const message = error.message;
+    if (typeof message === "string") return message;
+  }
+  return String(error);
+}
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function firstUserFrame(stack, files) {
+  for (const key of Object.keys(files)) {
+    const match = new RegExp(
+      `(?<![\\w$/.])${escapeRegExp(key)}:(\\d+)(?::(\\d+))?(?::(\\d+))?`
+    ).exec(stack);
+    if (match !== null) {
+      return match[2] === void 0 ? `${key}:${match[1]}` : `${key}:${match[1]}:${match[2]}`;
+    }
+  }
+  return void 0;
+}
+function errorMessageWithLocation(error, files) {
+  const message = errorMessageOf2(error);
+  const stack = error.stack;
+  if (typeof stack !== "string") return message;
+  const frame = firstUserFrame(stack, files);
+  return frame === void 0 ? message : `${message}\uFF08${frame}\uFF09`;
+}
+function createBareResolver(deps) {
+  const platformRequire = createRequire(import.meta.url);
+  const depsRequire = deps.dir === null ? null : createRequire(join7(deps.dir, "__deps__.js"));
+  return (request) => {
+    if (deps.builtin.includes(request)) return platformRequire(request);
+    const root = splitBareSpecifier(request);
+    if (deps.builtin.includes(root)) return platformRequire(request);
+    if (deps.custom.includes(root)) {
+      if (depsRequire === null) {
+        throw new Error(`\u4F9D\u8D56 "${root}" \u672A\u88C5\u8F7D\uFF1A\u9879\u76EE\u4F9D\u8D56\u76EE\u5F55\u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u53D1\u5E03\u51FD\u6570\u89E6\u53D1\u4F9D\u8D56\u88C5\u8F7D`);
+      }
+      try {
+        return depsRequire(request);
+      } catch (error2) {
+        const message = errorMessageOf2(error2);
+        throw new Error(
+          `\u4F9D\u8D56 "${request}" \u88C5\u8F7D\u5931\u8D25\uFF08\u76EE\u5F55 ${deps.dir}\uFF09\uFF1A\u8BF7\u91CD\u65B0\u53D1\u5E03\u51FD\u6570\u4EE5\u89E6\u53D1\u4F9D\u8D56\u5B89\u88C5\u3002\u539F\u56E0\uFF1A${message}`,
+          { cause: error2 }
+        );
+      }
+    }
+    const error = new Error(
+      `\u6C99\u7BB1\u62D2\u7EDD\u8BE5\u5F15\u7528\uFF1A"${request}"\u3002\u4EC5\u5141\u8BB8\u76F8\u5BF9\u8DEF\u5F84\u6587\u4EF6\u4E0E\u5DF2\u58F0\u660E\u7684\u4F9D\u8D56\uFF08\u5185\u7F6E\u767D\u540D\u5355\u6216 package.json\uFF09\uFF0C\u88F8\u6A21\u5757 "${root}" \u672A\u58F0\u660E\uFF08FN_SANDBOX_BUILTIN_BLOCKED\uFF09`
+    );
+    error.code = SANDBOX_BUILTIN_REJECTED;
+    throw error;
+  };
+}
+function runWorker(input, port) {
+  const emit = (level, args) => {
+    port.postMessage({ type: "log", level, message: args.map(String).join(" ") });
+  };
+  const forwardedConsole = {
+    log: (...args) => emit("log", args),
+    error: (...args) => emit("error", args),
+    warn: (...args) => emit("warn", args)
+  };
+  const container = createCloudContainer();
+  const pending = /* @__PURE__ */ new Map();
+  let rpcId = 0;
+  port.on?.((message) => {
+    const reply = message;
+    if (reply?.type !== "rpc-response" || typeof reply.id !== "number") return;
+    const entry = pending.get(reply.id);
+    if (entry === void 0) return;
+    pending.delete(reply.id);
+    if (reply.ok === true) entry.resolve(reply.result);
+    else entry.reject(new Error(reply.error ?? "RPC \u80FD\u529B\u8C03\u7528\u5931\u8D25"));
+  });
+  for (const capability of input.capabilities ?? []) {
+    container.register(
+      capability.name,
+      isChainCapability(capability.value) ? createChainClient(
+        capability.name,
+        port,
+        pending,
+        () => ++rpcId,
+        capability.value[CHAIN_CAPABILITY_KEY]
+      ) : isRpcCapability(capability.value) ? createRpcClient(capability.name, port, pending, () => ++rpcId) : capability.value
+    );
+  }
+  const sandboxGlobals = {
+    console: forwardedConsole,
+    // CF-015：Cloudflare Workers 代码重度依赖 Web 标准 API（URL / Request / Response /
+    // Headers / 流 / 编码 / crypto 等）。Node 18+ 全局内置，直接注入 vm 上下文；
+    // 与 @adep/cf-compat 的 Workers 适配（ctxToRequest / responseToEnvelopeBody）配套。
+    URL,
+    URLSearchParams,
+    Request,
+    Response,
+    Headers,
+    TextEncoder,
+    TextDecoder,
+    AbortController,
+    AbortSignal,
+    ReadableStream,
+    WritableStream,
+    TransformStream,
+    Blob,
+    FormData,
+    crypto,
+    performance,
+    atob,
+    btoa,
+    structuredClone
+  };
+  if (input.env !== void 0) {
+    sandboxGlobals["process"] = { env: input.env };
+  }
+  if (input.fetch !== void 0) {
+    const sandboxFetch = createSandboxFetch({
+      allowlist: input.fetch.allowlist,
+      timeoutMs: input.fetch.timeoutMs,
+      ...input.fetch.maxResponseBytes === void 0 ? {} : { maxResponseBytes: input.fetch.maxResponseBytes }
+    });
+    sandboxGlobals["fetch"] = sandboxFetch;
+    container.register("fetch", sandboxFetch);
+  }
+  const ctx = {
+    method: input.request.method,
+    path: input.request.path,
+    query: input.request.query,
+    headers: input.request.headers,
+    ...input.request.body === void 0 ? {} : { body: input.request.body },
+    files: input.request.files ?? [],
+    cloud: container.cloud,
+    user: input.request.user ?? null,
+    ...input.env === void 0 ? {} : { env: input.env }
+  };
+  try {
+    const { handler } = loadFunctionModule(
+      input.files,
+      input.entry,
+      sandboxGlobals,
+      input.deps === void 0 ? void 0 : createBareResolver(input.deps)
+    );
+    const result = Promise.resolve(handler(ctx));
+    void result.then(
+      (value) => {
+        port.postMessage({ type: "result", body: value === void 0 ? null : value });
+        return void 0;
+      },
+      (error) => {
+        port.postMessage({
+          type: "error",
+          message: errorMessageWithLocation(error, input.files),
+          code: error.code,
+          // FN-011：函数抛错可携带 status（4xx/5xx），透传给执行器落 ExecutorError.status。
+          status: error.status
+        });
+        return void 0;
+      }
+    );
+  } catch (error) {
+    port.postMessage({
+      type: "error",
+      message: errorMessageWithLocation(error, input.files),
+      code: error.code,
+      status: error.status
+    });
+  }
+}
+var workerPort = parentPort;
+if (workerPort !== null && workerData !== void 0) {
+  const port = {
+    // eslint-disable-next-line unicorn/require-post-message-target-origin -- node worker_threads 无 targetOrigin 语义
+    postMessage: (message) => workerPort.postMessage(message),
+    on: (listener) => {
+      workerPort.on("message", (value) => listener(value));
+    }
+  };
+  runWorker(workerData, port);
+}
+
 // packages/cli/src/dev.ts
 async function loadConfig(cwd) {
   const name = basename(resolve2(cwd));
@@ -2416,7 +3652,8 @@ async function loadConfig(cwd) {
   return {
     name: config?.name ?? name,
     functionsDir: config?.functionsDir ?? "functions",
-    functionsPrefix: config?.functions_prefix ?? ""
+    functionsPrefix: config?.functions_prefix ?? "",
+    ...config?.environment === void 0 ? {} : { environment: config.environment }
   };
 }
 function parseEnvFile(content) {
@@ -2443,7 +3680,7 @@ async function collectFunctions(dir) {
     }
     for (const entry of entries) {
       const rel = prefix.length === 0 ? entry.name : `${prefix}/${entry.name}`;
-      const full = join7(sub, entry.name);
+      const full = join8(sub, entry.name);
       if (entry.isDirectory()) {
         await walk(full, rel);
       } else if (entry.isFile() && entry.name.endsWith(".ts")) {
@@ -2510,7 +3747,7 @@ function printBoundaries(log) {
   }
 }
 async function ensureGitignore(cwd) {
-  const gitignorePath = join7(cwd, ".gitignore");
+  const gitignorePath = join8(cwd, ".gitignore");
   const existing = await readFile5(gitignorePath, "utf8").catch(() => "");
   if (existing.split(/\r?\n/).includes(".adep/")) return;
   await writeFile3(gitignorePath, `${existing.replace(/\n+$/, "")}
@@ -2525,9 +3762,11 @@ async function startDevServer(options) {
   if (options.prefix !== void 0) {
     config.functionsPrefix = options.prefix.replace(/^\/+|\/+$/g, "");
   }
-  const functionsDir = join7(cwd, config.functionsDir);
+  const functionsDir = join8(cwd, config.functionsDir);
   const coldStartAt = Date.now();
-  const executor = new WorkerFunctionExecutor();
+  const executor = new WorkerFunctionExecutor({
+    deps: { rootDir: cwd, builtin: LOCAL_BUILTIN_DEPS }
+  });
   await mkdir3(functionsDir, { recursive: true });
   const runtime = await createSimRuntime({
     cwd,
@@ -2537,19 +3776,91 @@ async function startDevServer(options) {
   });
   await ensureGitignore(cwd);
   let files = await collectFunctions(functionsDir);
-  let env = await loadSimEnv(cwd).catch(() => ({}));
+  let env = {
+    ...config.environment,
+    ...await loadSimEnv(cwd).catch(() => ({}))
+  };
   const dbBundle = runtime.bundle;
   const invokeHandler = createSimInvokeHandler({ executor, files });
+  let stateRuntime = null;
+  let stateFingerprint = "";
+  const bareResolver = createBareResolver({
+    dir: null,
+    builtin: [...LOCAL_BUILTIN_DEPS],
+    custom: []
+  });
+  const collectStateDeclarations = () => {
+    const declared = [];
+    const dirs = /* @__PURE__ */ new Set();
+    for (const path of Object.keys(files)) {
+      if (path === STATE_OBJECTS_ENTRY || path.endsWith(`/${STATE_OBJECTS_ENTRY}`)) {
+        dirs.add(path === STATE_OBJECTS_ENTRY ? "" : path.slice(0, -STATE_OBJECTS_ENTRY.length - 1));
+      }
+    }
+    for (const dir of dirs) {
+      const prefix = dir.length === 0 ? "" : `${dir}/`;
+      const fileMap = {};
+      for (const [path, content] of Object.entries(files)) {
+        if (path.startsWith(prefix)) fileMap[path] = content;
+      }
+      declared.push({ dir, files: fileMap });
+    }
+    return declared;
+  };
+  const stateObjectBareResolver = (request) => {
+    const state = resolveStateObjectSpecifier(request);
+    if (state !== void 0) return state;
+    return bareResolver(request);
+  };
+  const refreshStateRuntime = () => {
+    const declarations = collectStateDeclarations();
+    const fingerprint = declarations.map(
+      (d) => `${d.dir}\0${d.files[`${d.dir === "" ? "" : `${d.dir}/`}${STATE_OBJECTS_ENTRY}`] ?? ""}`
+    ).join("
");
+    if (stateRuntime !== null && stateFingerprint === fingerprint) return stateRuntime;
+    stateRuntime = new StateObjectRuntime(createProjectDriverStateBackend(runtime.db.driver));
+    stateRuntime.define(DemoCounter);
+    stateRuntime.define(DemoChatRoom);
+    for (const d of declarations) {
+      const loaded = loadStateObjectClasses(
+        d.files,
+        `${d.dir === "" ? "" : `${d.dir}/`}${STATE_OBJECTS_ENTRY}`,
+        {
+          resolveBare: stateObjectBareResolver
+        }
+      );
+      for (const cls of loaded) stateRuntime.define(cls);
+    }
+    stateFingerprint = fingerprint;
+    return stateRuntime;
+  };
+  let stateAlarmTimer;
+  const startStateAlarmScheduler = () => {
+    if (stateAlarmTimer !== void 0) return;
+    stateAlarmTimer = setInterval(() => {
+      void refreshStateRuntime().pump(Date.now()).catch((error) => {
+        log(
+          `[adep] \u72B6\u6001\u5BF9\u8C61 alarm tick \u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`
+        );
+      });
+    }, options.stateAlarmTickMs ?? 1e3);
+    stateAlarmTimer.unref?.();
+  };
+  const stopStateAlarmScheduler = () => {
+    if (stateAlarmTimer === void 0) return;
+    clearInterval(stateAlarmTimer);
+    stateAlarmTimer = void 0;
+  };
   const reload = async () => {
     const [nextFiles, envText2] = await Promise.all([
       collectFunctions(functionsDir),
-      readFile5(join7(cwd, ".env.local"), "utf8").catch(() => "")
+      readFile5(join8(cwd, ".env.local"), "utf8").catch(() => "")
     ]);
     files = nextFiles;
-    env = parseEnvFile(envText2);
+    env = { ...config.environment, ...parseEnvFile(envText2) };
   };
-  const envText = await readFile5(join7(cwd, ".env.local"), "utf8").catch(() => "");
-  env = parseEnvFile(envText);
+  const envText = await readFile5(join8(cwd, ".env.local"), "utf8").catch(() => "");
+  env = { ...config.environment, ...parseEnvFile(envText) };
   let debounceTimer;
   let watcher;
   try {
@@ -2609,6 +3920,43 @@ async function startDevServer(options) {
       });
       return;
     }
+    if (fnName === "state") {
+      const normalizedPrefix = config.functionsPrefix.replace(/^\/+|\/+$/g, "");
+      const rest = normalizedPrefix.length === 0 ? url.pathname : url.pathname.replace(new RegExp(`^/${normalizedPrefix}`), "");
+      const parsed = parseStatePath(rest);
+      if (parsed === null) {
+        writeJson(res, 400, {
+          error: { code: "STATE_BAD_PATH", message: "\u72B6\u6001\u5BF9\u8C61\u8DEF\u5F84\uFF1A/api/state/:type/:id/:method" }
+        });
+        return;
+      }
+      const rawBody = await bodyOf(req);
+      const parsedBody = parseStateBody(
+        req.method === "GET" || req.method === "HEAD" ? null : rawBody === void 0 ? null : typeof rawBody === "string" ? rawBody : JSON.stringify(rawBody)
+      );
+      if ("error" in parsedBody) {
+        writeJson(res, 400, { error: { code: "STATE_BAD_ARGS", message: parsedBody.error } });
+        return;
+      }
+      try {
+        const result = await refreshStateRuntime().invoke(
+          parsed.type,
+          parsed.id,
+          parsed.method,
+          parsedBody.args
+        );
+        writeJson(res, 200, { ok: true, data: result });
+      } catch (error) {
+        if (error instanceof StateObjectError) {
+          writeJson(res, error.code === "STATE_TYPE_NOT_REGISTERED" ? 404 : 400, {
+            error: { code: error.code, message: error.message }
+          });
+          return;
+        }
+        writeJson(res, 500, { error: { code: "STATE_INVOKE_ERROR", message: String(error) } });
+      }
+      return;
+    }
     const entry = resolveFunctionEntry(files, fnName);
     if (entry === void 0) {
       log(`[adep] ${req.method ?? "GET"} /${fnName} -> 404\uFF08\u51FD\u6570\u4E0D\u5B58\u5728\uFF09`);
@@ -2620,8 +3968,15 @@ async function startDevServer(options) {
     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}`);
+      if (isAdepHttpEnvelope(result.body)) {
+        log(
+          `[adep] ${req.method ?? "GET"} /${fnName} -> ${result.body.__adepHttp.status} ${durationMs}ms`
+        );
+        writeEnvelopeResponse(res, result.body);
+        return;
+      }
+      log(`[adep] ${req.method ?? "GET"} /${fnName} -> 200 ${durationMs}ms`);
       writeJson(res, 200, result.body === void 0 ? null : result.body);
     } catch (error) {
       const durationMs = Math.round(performance.now() - startedAt);
@@ -2679,10 +4034,12 @@ async function startDevServer(options) {
   log(`[adep] curl \u793A\u4F8B\uFF1Acurl ${baseUrl}${curlPath}`);
   printBoundaries(log);
   log(`[adep] \u6A21\u62DF\u6570\u636E\u76EE\u5F55\uFF1A${simDir(cwd)}`);
+  startStateAlarmScheduler();
   return {
     port: actualPort,
     baseUrl,
     close: async () => {
+      stopStateAlarmScheduler();
       if (debounceTimer !== void 0) clearTimeout(debounceTimer);
       watcher?.close();
       await new Promise((resolveClose) => server.close(() => resolveClose()));