@adep/cli 0.1.0 → 0.1.2

package/dist/vite.js

@@ -1,19 +1,20 @@
-// src/vite.ts
-import { request as httpRequest } from "node:http";
-import { resolve as resolve3 } from "node:path";
+// packages/cli/src/vite.ts
+import { adepPlugin } from "@adep/vite-plugin";
 
-// src/dev.ts
+// packages/cli/src/dev.ts
 import { createServer } from "node:http";
 import { watch } from "node:fs";
 import { mkdir as mkdir3, readdir as readdir2, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
-import { basename, join as join7, resolve as resolve2 } from "node:path";
+import { basename, join as join8, resolve as resolve2 } from "node:path";
 
-// ../runtime/src/shared/capability-keys.ts
+// 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",
+  /** 写路径（CF-013）：`(method=writeQuery, args=[sql, params])` → `{ changes }`。 */
+  writeQuery: "writeQuery",
   /** 读取 owned 表变更流（DB-006）：`(method=changes, args=[table, query])`。 */
   changes: "changes",
   /** 开启事务：`begin → txId`。 */
@@ -40,7 +41,7 @@ var REALTIME_CAPABILITY_METHODS = [
   "unsubscribe"
 ];
 
-// ../runtime/src/shared/executor-runtime.ts
+// packages/runtime/src/shared/executor-runtime.ts
 var ExecutorError = class extends Error {
   constructor(status, code, message) {
     super(message);
@@ -60,19 +61,38 @@ function normalizeHttpStatus(status) {
   return isHttpStatus(status) ? status : 500;
 }
 
-// ../runtime/src/functions/runtime/worker-executor.ts
+// 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";
 import { dirname, join } from "node:path";
 import { Worker } from "node:worker_threads";
 
-// ../runtime/src/functions/deps/resolve.ts
+// packages/runtime/src/functions/deps/resolve.ts
 import { resolve } from "node:path";
 
-// ../runtime/src/functions/deps/manifest.ts
+// packages/runtime/src/functions/deps/manifest.ts
 import { createHash } from "node:crypto";
 
-// ../runtime/src/functions/domain.ts
+// packages/runtime/src/functions/domain.ts
 var MAX_TOTAL_SOURCE_BYTES = 256 * 1024;
 var FnError = class extends Error {
   status;
@@ -85,7 +105,7 @@ var FnError = class extends Error {
   }
 };
 
-// ../runtime/src/functions/deps/manifest.ts
+// 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;
@@ -162,12 +182,19 @@ 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);
 }
 
-// ../runtime/src/functions/deps/resolve.ts
+// packages/runtime/src/functions/deps/resolve.ts
 function resolveExecutionDeps(config, projectId, manifestContent) {
   const manifest = tryParseManifestDependencies(manifestContent);
   const { customDeps } = classifyDependencies(manifest, config.builtin);
@@ -180,7 +207,7 @@ function resolveExecutionDeps(config, projectId, manifestContent) {
   };
 }
 
-// ../runtime/src/functions/runtime/worker-executor.ts
+// packages/runtime/src/functions/runtime/worker-executor.ts
 function resolveWorkerEntry(baseDir = fileURLToPath(new URL(".", import.meta.url))) {
   const candidates = [
     join(baseDir, "worker-entry.js"),
@@ -230,7 +257,7 @@ var WorkerFunctionExecutor = class {
     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((resolve4, reject) => {
+    return new Promise((resolve3, reject) => {
       let worker;
       try {
         worker = new Worker(resolveWorkerEntry(), {
@@ -292,7 +319,7 @@ var WorkerFunctionExecutor = class {
           if (message.type === "result") {
             clearTimeout(timer);
             void worker.terminate();
-            resolve4({ body: message.body, logs });
+            resolve3({ body: message.body, logs });
             return;
           }
           if (message.type === "error") {
@@ -325,11 +352,11 @@ var WorkerFunctionExecutor = class {
   }
 };
 
-// src/sim/runtime.ts
+// packages/cli/src/sim/runtime.ts
 import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname3, join as join4 } from "node:path";
 
-// ../runtime/src/database/builder/dialect.ts
+// packages/runtime/src/database/builder/dialect.ts
 var sqliteDialect = {
   name: "sqlite",
   placeholder: () => "?",
@@ -348,7 +375,7 @@ function dialectFor(driver) {
   return driver.engine === "pg" ? postgresDialect : sqliteDialect;
 }
 
-// ../runtime/src/database/provision/identifier.ts
+// packages/runtime/src/database/provision/identifier.ts
 var DbError = class extends Error {
   constructor(status, code, message) {
     super(message);
@@ -372,31 +399,45 @@ function quoteIdentifier(name) {
   return `"${name.replace(/"/g, '""')}"`;
 }
 
-// ../runtime/src/database/builder/guards.ts
+// 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) {
+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"
+    );
+  }
 }
 
-// ../runtime/src/database/builder/owned.ts
+// packages/runtime/src/database/builder/owned.ts
 var OWNED_PK = "id";
 var OWNED_OWNER_KEY = "__owner_key";
 var CHANGE_LOG_PREFIX = "_adep_changes_";
@@ -509,7 +550,7 @@ async function readChanges(driver, table, query = {}) {
   return rows.map(parseChange);
 }
 
-// ../runtime/src/database/builder/ulid.ts
+// packages/runtime/src/database/builder/ulid.ts
 var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
 var TIME_LEN = 10;
 var RANDOM_LEN = 16;
@@ -575,7 +616,7 @@ function ulid(now = Date.now()) {
   return time + random;
 }
 
-// ../runtime/src/database/builder/table.ts
+// packages/runtime/src/database/builder/table.ts
 var OPERATORS = /* @__PURE__ */ new Set([
   "=",
   "!=",
@@ -894,7 +935,7 @@ function createTableBuilder(table, driver, dialect, options = {}) {
   return build(initialState);
 }
 
-// ../runtime/src/database/builder/index.ts
+// packages/runtime/src/database/builder/index.ts
 var TX_STATES = /* @__PURE__ */ new WeakMap();
 function createCloudDb(driver, options = {}) {
   const dialect = options.dialect ?? dialectFor(driver);
@@ -939,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);
       }
@@ -948,13 +997,14 @@ function createCloudDb(driver, options = {}) {
   return makeHandle({ allowWriteDuringTx: false });
 }
 
-// ../runtime/src/database/sdk/cloud.ts
+// 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"],
+  // 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"]);
@@ -1009,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);
@@ -1052,7 +1106,7 @@ function createDbCapability(driver, options = {}) {
   };
 }
 
-// src/sim/sql-engine.ts
+// packages/cli/src/sim/sql-engine.ts
 var SimDbError = class extends Error {
   constructor(code, message) {
     super(message);
@@ -1470,7 +1524,7 @@ function project(rows, selectRaw) {
   });
 }
 
-// src/sim/db.ts
+// packages/cli/src/sim/db.ts
 function toProjectDriver(engine) {
   return {
     engine: "sqlite",
@@ -1490,10 +1544,110 @@ function createSimDbCapability(options = {}) {
   return { bundle, engine, driver };
 }
 
-// src/sim/storage.ts
+// 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";
 
-// ../runtime/src/storage/driver.ts
+// packages/runtime/src/storage/driver.ts
 var PROJECT_QUOTA_BYTES = 1024 * 1024 * 1024;
 var StorageError = class extends Error {
   constructor(status, code, message) {
@@ -1534,7 +1688,7 @@ function assertSafeStoragePath(path) {
   return path;
 }
 
-// ../runtime/src/storage/hmac-sha256.ts
+// packages/runtime/src/storage/hmac-sha256.ts
 var K = new Uint32Array([
   1116352408,
   1899447441,
@@ -1695,7 +1849,7 @@ function hmacSha256Hex(key, message) {
   return [...hmacSha256(key, message)].map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 
-// ../runtime/src/storage/signature.ts
+// packages/runtime/src/storage/signature.ts
 var DEFAULT_SIGN_TTL_SECONDS = 15 * 60;
 var SIGN_EXPIRES_KEY = "x-expires";
 var SIGN_SIGNATURE_KEY = "x-signature";
@@ -1710,7 +1864,7 @@ function signDownloadUrl(config, projectId, path, ttlSeconds = DEFAULT_SIGN_TTL_
   return `${base}?${SIGN_EXPIRES_KEY}=${expires}&${SIGN_SIGNATURE_KEY}=${signature}`;
 }
 
-// ../runtime/src/storage/cloud.ts
+// packages/runtime/src/storage/cloud.ts
 var DEFAULT_VISIBILITY = "private";
 function asBytes(data) {
   if (typeof data === "string") return new TextEncoder().encode(data);
@@ -1733,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": {
@@ -1769,7 +1926,7 @@ function createStorageCapability(driver, signer, projectId) {
   };
 }
 
-// ../runtime/src/storage/driver/local.ts
+// 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";
@@ -1976,7 +2133,7 @@ function createLocalStorageDriver(options) {
   };
 }
 
-// src/sim/storage.ts
+// packages/cli/src/sim/storage.ts
 function createSimStorageCapability(options) {
   const dir = join3(options.cwd, ".adep", "sim", "storage");
   const driver = createLocalStorageDriver({ dir });
@@ -1988,7 +2145,7 @@ function createSimStorageCapability(options) {
   return { bundle, driver };
 }
 
-// src/sim/realtime.ts
+// packages/cli/src/sim/realtime.ts
 var SimRealtime = class {
   seq = 0;
   subscribers = /* @__PURE__ */ new Map();
@@ -2110,7 +2267,7 @@ function createSimRealtimeCapability() {
   };
 }
 
-// src/sim/runtime.ts
+// packages/cli/src/sim/runtime.ts
 function simDir(cwd) {
   return join4(cwd, ".adep", "sim");
 }
@@ -2161,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,
@@ -2173,7 +2331,7 @@ async function createSimRuntime(options) {
   };
 }
 
-// src/sim/env.ts
+// packages/cli/src/sim/env.ts
 import { readFile as readFile3 } from "node:fs/promises";
 import { join as join5 } from "node:path";
 function parseEnv(content) {
@@ -2206,7 +2364,7 @@ async function loadSimEnv(cwd, config = {}) {
   return merged;
 }
 
-// src/sim/invoke.ts
+// packages/cli/src/sim/invoke.ts
 function resolveFunctionEntry(files, fnName) {
   const flat = `${fnName}.ts`;
   if (files[flat] !== void 0) return flat;
@@ -2247,7 +2405,14 @@ function createSimInvokeHandler(options) {
   };
 }
 
-// src/sim/boundary.ts
+// 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 = [
   {
     kind: "capability",
@@ -2276,11 +2441,11 @@ var SIM_BOUNDARIES = [
   }
 ];
 
-// src/ts-config.ts
+// packages/cli/src/ts-config.ts
 import { stat as stat2, readFile as readFile4 } from "node:fs/promises";
 import { join as join6 } from "node:path";
 
-// ../../shared/sdk/adep-config.ts
+// shared/sdk/adep-config.ts
 var DEFAULT_ADEP_CONFIG = {
   functionsDir: "functions",
   functions_prefix: "/api"
@@ -2302,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 } };
@@ -2362,11 +2572,15 @@ 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 };
 }
 
-// src/ts-config.ts
+// packages/cli/src/ts-config.ts
 async function loadAdepConfigModule(cwd) {
   const configPath = join6(cwd, "adep.config.ts");
   try {
@@ -2410,14 +2624,1036 @@ ${result.errors.map((e) => `  - ${e}`).join("\n")}`;
   return result.data;
 }
 
-// src/dev.ts
+// 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));
   const config = await loadAdepConfigModule(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) {
@@ -2444,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")) {
@@ -2511,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+$/, "")}
@@ -2526,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,
@@ -2538,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 {
@@ -2610,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`);
@@ -2621,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);
@@ -2680,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()));
@@ -2693,126 +4049,28 @@ async function startDevServer(options) {
   };
 }
 
-// src/vite.ts
-function normalizeFunctionPrefix(raw) {
-  const value = (raw ?? "").trim();
-  if (value.length === 0 || value === "/") return "";
-  return value.replace(/^\/+|\/+$/g, "");
-}
-function isAddrInUse(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "EADDRINUSE";
-}
-function createAdepProxyMiddleware(prefix, targetBase) {
-  const normalized = normalizeFunctionPrefix(prefix);
-  const prefixPath = normalized === "" ? "" : `/${normalized}`;
-  return (req, res, next) => {
-    if (prefixPath === "") return next();
-    const url = new URL(req.url ?? "/", "http://127.0.0.1");
-    if (url.pathname !== prefixPath && !url.pathname.startsWith(`${prefixPath}/`)) {
-      return next();
-    }
-    const target = new URL(url.pathname + url.search, targetBase);
-    const proxyReq = httpRequest(
-      target,
-      { method: req.method, headers: { ...req.headers, host: target.host } },
-      (proxyRes) => {
-        res.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
-        proxyRes.pipe(res);
-      }
-    );
-    proxyReq.on("error", (error) => {
-      if (!res.headersSent) {
-        res.writeHead(502, { "content-type": "application/json" });
-      }
-      res.end(
-        JSON.stringify({
-          error: {
-            code: "ADEP_DEV_UNAVAILABLE",
-            message: `\u4E91\u51FD\u6570\u4EE3\u7406\u5931\u8D25\uFF08adep dev server \u4E0D\u53EF\u8FBE\uFF09\uFF1A${error.message}`
-          }
-        })
-      );
-    });
-    req.pipe(proxyReq);
-  };
-}
+// packages/cli/src/vite.ts
+import {
+  createAdepFnProxyScriptMiddleware,
+  createAdepProxyMiddleware,
+  FN_FETCH_INTERCEPTOR_SCRIPT,
+  injectFnProxyScriptTag,
+  isAddrInUse,
+  normalizeFunctionPrefix
+} from "@adep/vite-plugin";
+var createDevServer = (opts) => startDevServer({ cwd: opts.cwd, port: opts.port, prefix: opts.prefix, log: opts.log });
+var loadConfig2 = (cwd) => loadAdepConfigModule(cwd);
 function adepVitePlugin(options = {}) {
-  const cwd = resolve3(options.cwd ?? process.cwd());
-  let dev;
-  let prefix = normalizeFunctionPrefix(options.prefix);
-  let prefixPath = "";
-  let startPromise;
-  const startAdepDev = async (log) => {
-    if (startPromise !== void 0) return startPromise;
-    startPromise = (async () => {
-      if (prefix === "") {
-        const config = await loadAdepConfigModule(cwd);
-        prefix = normalizeFunctionPrefix(config?.functions_prefix);
-        if (prefix === "") {
-          log("[adep] adep.config.ts \u672A\u914D\u7F6E functions_prefix\uFF0C\u4E91\u51FD\u6570\u4EE3\u7406\u524D\u7F00\u9ED8\u8BA4 /api");
-          prefix = "api";
-        }
-      }
-      prefixPath = `/${prefix}`;
-      const targetPort = options.port ?? 8787;
-      try {
-        dev = await startDevServer({ cwd, port: targetPort, prefix, log });
-      } catch (error) {
-        if (isAddrInUse(error)) {
-          log(`[adep] \u7AEF\u53E3 ${targetPort} \u88AB\u5360\u7528\uFF0C\u6539\u7528\u968F\u673A\u7AEF\u53E3`);
-          dev = await startDevServer({ cwd, port: 0, prefix, log });
-        } else {
-          log(
-            `[adep] \u4E91\u51FD\u6570 dev server \u542F\u52A8\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}\uFF08vite \u524D\u7AEF\u7167\u5E38\uFF0C\u51FD\u6570\u4EE3\u7406\u4E0D\u53EF\u7528\uFF09`
-          );
-        }
-      }
-      if (dev !== void 0) {
-        log(
-          `[adep] \u4E91\u51FD\u6570\u5DF2\u5C31\u7EEA\uFF1A${dev.baseUrl}${prefixPath}/<fn>\uFF08vite \u4EE3\u7406 ${prefixPath}/* \u2192 \u4E91\u51FD\u6570\uFF09`
-        );
-      }
-    })();
-    try {
-      await startPromise;
-    } finally {
-      startPromise = void 0;
-    }
-  };
-  const disposeAdepDev = async () => {
-    if (dev === void 0) return;
-    const target = dev;
-    dev = void 0;
-    await target.close();
-  };
-  const attachProxy = (server) => {
-    if (dev === void 0 || prefixPath === "") return;
-    server.middlewares.use(createAdepProxyMiddleware(prefixPath, dev.baseUrl));
-  };
-  return {
-    name: "adep-cloud-functions",
-    async configureServer(server) {
-      const log = (line) => server.config.logger.info(line);
-      await startAdepDev(log);
-      attachProxy(server);
-      server.httpServer?.on("close", () => {
-        void disposeAdepDev();
-      });
-    },
-    async configurePreviewServer(server) {
-      const log = (line) => server.config.logger.info(line);
-      await startAdepDev(log);
-      attachProxy(server);
-    },
-    async closeBundle() {
-      await disposeAdepDev();
-    }
-  };
+  return adepPlugin({ ...options, createDevServer, loadConfig: loadConfig2 });
 }
 var vite_default = adepVitePlugin;
 export {
+  FN_FETCH_INTERCEPTOR_SCRIPT,
   adepVitePlugin,
+  createAdepFnProxyScriptMiddleware,
   createAdepProxyMiddleware,
   vite_default as default,
+  injectFnProxyScriptTag,
+  isAddrInUse,
   normalizeFunctionPrefix
 };