@adep/cli 0.1.1 → 0.1.2

package/dist/index.js

@@ -250,6 +250,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 } };
@@ -310,6 +355,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 };
 }
@@ -345,6 +394,9 @@ function renderAdepConfig(config, options = {}) {
   if (config.runtime !== void 0) {
     lines.push(`  runtime: ${renderTsValue(config.runtime)},`);
   }
+  if (config.cfBindings !== void 0) {
+    lines.push(`  cfBindings: ${renderTsValue(config.cfBindings)},`);
+  }
   if (options.extraFields !== void 0) {
     for (const [key, value] of Object.entries(options.extraFields)) {
       lines.push(`  ${key}: ${renderTsValue(value)},`);
@@ -417,6 +469,8 @@ var init_capability_keys = __esm({
     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`。 */
@@ -479,6 +533,30 @@ var init_executor = __esm({
   }
 });
 
+// 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));
+}
+var init_http_envelope = __esm({
+  "packages/runtime/src/shared/http-envelope.ts"() {
+    "use strict";
+  }
+});
+
 // packages/runtime/src/functions/domain.ts
 var MAX_TOTAL_SOURCE_BYTES, FnError;
 var init_domain = __esm({
@@ -573,6 +651,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);
@@ -589,14 +674,14 @@ var init_manifest = __esm({
 });
 
 // packages/runtime/src/functions/deps/resolve.ts
-import { resolve as resolve2 } from "node:path";
+import { resolve as resolve3 } from "node:path";
 function resolveExecutionDeps(config, projectId, manifestContent) {
   const manifest = tryParseManifestDependencies(manifestContent);
   const { customDeps } = classifyDependencies(manifest, config.builtin);
   const custom = Object.keys(customDeps);
   return {
     // 绝对化（相对进程 cwd，与 installer 侧 resolve(rootDir) 同基准）：worker 的 createRequire 需要确定路径
-    dir: custom.length === 0 ? null : resolve2(config.rootDir, projectId, depsKeyOf(customDeps)),
+    dir: custom.length === 0 ? null : resolve3(config.rootDir, projectId, depsKeyOf(customDeps)),
     builtin: [...config.builtin],
     custom
   };
@@ -611,22 +696,22 @@ var init_resolve = __esm({
 // packages/runtime/src/functions/runtime/worker-executor.ts
 import { readFileSync } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { dirname as dirname3, join as join2 } from "node:path";
+import { dirname as dirname4, join as join3 } from "node:path";
 import { Worker } from "node:worker_threads";
 function resolveWorkerEntry(baseDir = fileURLToPath(new URL(".", import.meta.url))) {
   const candidates = [
-    join2(baseDir, "worker-entry.js"),
-    join2(baseDir, "worker-entry.ts"),
-    join2(baseDir, "domains/functions/runtime/worker-entry.js"),
-    join2(baseDir, "domains/functions/runtime/worker-entry.ts")
+    join3(baseDir, "worker-entry.js"),
+    join3(baseDir, "worker-entry.ts"),
+    join3(baseDir, "domains/functions/runtime/worker-entry.js"),
+    join3(baseDir, "domains/functions/runtime/worker-entry.ts")
   ];
   let current = baseDir;
   for (let depth = 0; depth < 8; depth += 1) {
     candidates.push(
-      join2(current, "packages/runtime/src/functions/runtime/worker-entry.js"),
-      join2(current, "packages/runtime/src/functions/runtime/worker-entry.ts")
+      join3(current, "packages/runtime/src/functions/runtime/worker-entry.js"),
+      join3(current, "packages/runtime/src/functions/runtime/worker-entry.ts")
     );
-    const parent = dirname3(current);
+    const parent = dirname4(current);
     if (parent === current) break;
     current = parent;
   }
@@ -668,7 +753,7 @@ var init_worker_executor = __esm({
         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((resolve12, reject) => {
+        return new Promise((resolve13, reject) => {
           let worker;
           try {
             worker = new Worker(resolveWorkerEntry(), {
@@ -730,7 +815,7 @@ var init_worker_executor = __esm({
               if (message.type === "result") {
                 clearTimeout(timer);
                 void worker.terminate();
-                resolve12({ body: message.body, logs });
+                resolve13({ body: message.body, logs });
                 return;
               }
               if (message.type === "error") {
@@ -827,21 +912,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"
+    );
+  }
 }
 var init_guards = __esm({
   "packages/runtime/src/database/builder/guards.ts"() {
@@ -1417,6 +1516,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);
       }
@@ -1489,6 +1596,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);
@@ -1543,7 +1654,8 @@ var init_cloud = __esm({
       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"
     };
     WRITE_TERMINALS = /* @__PURE__ */ new Set(["insert", "insertMany", "update", "delete"]);
@@ -2001,6 +2113,113 @@ var init_db = __esm({
   }
 });
 
+// packages/runtime/src/database/sdk/kv.ts
+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 }
+  };
+}
+var KV_TABLE, KV_RPC, KV_CAPABILITY_CODES, KV_LIST_DEFAULT_LIMIT;
+var init_kv = __esm({
+  "packages/runtime/src/database/sdk/kv.ts"() {
+    "use strict";
+    init_capability_keys();
+    KV_TABLE = "_adep_kv";
+    KV_RPC = {
+      get: "get",
+      put: "put",
+      delete: "delete",
+      list: "list"
+    };
+    KV_CAPABILITY_CODES = {
+      invalidMethod: "KV_INVALID_METHOD"
+    };
+    KV_LIST_DEFAULT_LIMIT = 100;
+  }
+});
+
 // packages/runtime/src/storage/driver.ts
 function assertSafeStoragePath(path) {
   if (typeof path !== "string" || path.length === 0) {
@@ -2259,9 +2478,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": {
@@ -2306,15 +2528,15 @@ var init_cloud2 = __esm({
 });
 
 // packages/runtime/src/storage/driver/local.ts
-import { mkdir as mkdir3, readFile as readFile2, readdir, rm as rm2, stat as stat3, unlink, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname4, join as join3 } from "node:path";
+import { mkdir as mkdir4, readFile as readFile3, readdir as readdir2, rm as rm2, stat as stat4, unlink, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname5, join as join4 } from "node:path";
 function createLocalStorageDriver(options) {
   const quotaBytes = options.quotaBytes ?? PROJECT_QUOTA_BYTES;
-  const bucketDir = (projectId) => join3(options.dir, projectId);
-  const objectPath = (projectId, path) => join3(bucketDir(projectId), path);
-  const metaPath = (projectId, path) => join3(dirname4(objectPath(projectId, path)), `${path.split("/").pop() ?? ""}${META_SUFFIX}`);
+  const bucketDir = (projectId) => join4(options.dir, projectId);
+  const objectPath = (projectId, path) => join4(bucketDir(projectId), path);
+  const metaPath = (projectId, path) => join4(dirname5(objectPath(projectId, path)), `${path.split("/").pop() ?? ""}${META_SUFFIX}`);
   const readStoredMeta = async (projectId, path) => {
-    const raw = await readFile2(metaPath(projectId, path), "utf8");
+    const raw = await readFile3(metaPath(projectId, path), "utf8");
     return JSON.parse(raw);
   };
   const writeStoredMeta = async (projectId, path, meta) => {
@@ -2324,7 +2546,7 @@ function createLocalStorageDriver(options) {
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       ...meta.contentType === void 0 ? {} : { contentType: meta.contentType }
     };
-    await writeFile2(metaPath(projectId, path), JSON.stringify(payload), "utf8");
+    await writeFile3(metaPath(projectId, path), JSON.stringify(payload), "utf8");
   };
   const totalSize = async (projectId) => {
     const root = bucketDir(projectId);
@@ -2332,20 +2554,20 @@ function createLocalStorageDriver(options) {
     const walk = async (dir) => {
       let entries;
       try {
-        entries = await readdir(dir, { withFileTypes: true });
+        entries = await readdir2(dir, { withFileTypes: true });
       } catch {
         return;
       }
       const tasks = [];
       for (const entry of entries) {
-        const full = join3(dir, entry.name);
+        const full = join4(dir, entry.name);
         if (entry.isDirectory()) {
           tasks.push(walk(full));
         } else if (entry.isFile() && !entry.name.endsWith(META_SUFFIX)) {
           tasks.push(
             (async () => {
               try {
-                const info = await stat3(full);
+                const info = await stat4(full);
                 total += info.size;
               } catch {
               }
@@ -2367,7 +2589,7 @@ function createLocalStorageDriver(options) {
       const used = await totalSize(projectId);
       let existingSize = 0;
       try {
-        existingSize = (await stat3(objectPath(projectId, path))).size;
+        existingSize = (await stat4(objectPath(projectId, path))).size;
       } catch {
         existingSize = 0;
       }
@@ -2382,8 +2604,8 @@ function createLocalStorageDriver(options) {
         );
       }
       const dest = objectPath(projectId, path);
-      await mkdir3(dirname4(dest), { recursive: true });
-      await writeFile2(dest, data);
+      await mkdir4(dirname5(dest), { recursive: true });
+      await writeFile3(dest, data);
       await writeStoredMeta(projectId, path, {
         visibility: putOptions.visibility,
         size: data.byteLength,
@@ -2406,7 +2628,7 @@ function createLocalStorageDriver(options) {
       } catch {
         throw new StorageError(404, STORAGE_CODES.notFound, `\u6587\u4EF6 "${path}" \u4E0D\u5B58\u5728`);
       }
-      const data = await readFile2(objectPath(projectId, path));
+      const data = await readFile3(objectPath(projectId, path));
       const result = {
         path,
         size: meta.size,
@@ -2437,7 +2659,7 @@ function createLocalStorageDriver(options) {
       assertSafeStoragePath(path);
       let exists = true;
       try {
-        await stat3(objectPath(projectId, path));
+        await stat4(objectPath(projectId, path));
       } catch {
         exists = false;
       }
@@ -2460,25 +2682,25 @@ function createLocalStorageDriver(options) {
       }
       const root = bucketDir(projectId);
       const metas = [];
-      const walk = async (dir, relative3) => {
+      const walk = async (dir, relative4) => {
         let entries;
         try {
-          entries = await readdir(dir, { withFileTypes: true });
+          entries = await readdir2(dir, { withFileTypes: true });
         } catch {
           return;
         }
         const tasks = [];
         for (const entry of entries) {
           if (entry.name.endsWith(META_SUFFIX)) continue;
-          const full = join3(dir, entry.name);
-          const rel = relative3 === "" ? entry.name : `${relative3}/${entry.name}`;
+          const full = join4(dir, entry.name);
+          const rel = relative4 === "" ? entry.name : `${relative4}/${entry.name}`;
           if (entry.isFile()) {
             if (prefix !== void 0 && !rel.startsWith(prefix)) continue;
             tasks.push(
               (async () => {
                 try {
                   const payload = JSON.parse(
-                    await readFile2(full + META_SUFFIX, "utf8")
+                    await readFile3(full + META_SUFFIX, "utf8")
                   );
                   metas.push({
                     path: rel,
@@ -2520,9 +2742,9 @@ var init_local = __esm({
 });
 
 // packages/cli/src/sim/storage.ts
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 function createSimStorageCapability(options) {
-  const dir = join4(options.cwd, ".adep", "sim", "storage");
+  const dir = join5(options.cwd, ".adep", "sim", "storage");
   const driver = createLocalStorageDriver({ dir });
   const signer = {
     secret: options.secret ?? "adep-sim-secret",
@@ -2669,10 +2891,10 @@ var init_realtime = __esm({
 });
 
 // packages/cli/src/sim/runtime.ts
-import { mkdir as mkdir4, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname5, join as join5 } from "node:path";
+import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname6, join as join6 } from "node:path";
 function simDir(cwd) {
-  return join5(cwd, ".adep", "sim");
+  return join6(cwd, ".adep", "sim");
 }
 function mergeBundles(bundles) {
   const capabilities = [];
@@ -2694,19 +2916,19 @@ function mergeBundles(bundles) {
   return { capabilities, rpcHandlers };
 }
 function jsonStorage(cwd) {
-  const file = join5(simDir(cwd), "db.json");
+  const file = join6(simDir(cwd), "db.json");
   return {
     async load() {
       try {
-        const raw = await readFile3(file, "utf8");
+        const raw = await readFile4(file, "utf8");
         return JSON.parse(raw);
       } catch {
         return null;
       }
     },
     async save(tables) {
-      await mkdir4(dirname5(file), { recursive: true });
-      await writeFile3(file, JSON.stringify(tables), "utf8");
+      await mkdir5(dirname6(file), { recursive: true });
+      await writeFile4(file, JSON.stringify(tables), "utf8");
     }
   };
 }
@@ -2721,7 +2943,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,
@@ -2736,14 +2959,15 @@ var init_runtime = __esm({
   "packages/cli/src/sim/runtime.ts"() {
     "use strict";
     init_db();
+    init_kv();
     init_storage();
     init_realtime();
   }
 });
 
 // packages/cli/src/sim/env.ts
-import { readFile as readFile4 } from "node:fs/promises";
-import { join as join6 } from "node:path";
+import { readFile as readFile5 } from "node:fs/promises";
+import { join as join7 } from "node:path";
 function parseEnv(content) {
   const env = {};
   for (const raw of content.split(/\r?\n/)) {
@@ -2758,8 +2982,8 @@ function parseEnv(content) {
   return env;
 }
 async function loadSimEnv(cwd, config = {}) {
-  const envRoot = await readFile4(join6(cwd, ".env"), "utf8").catch(() => "");
-  const envLocal = await readFile4(join6(cwd, ".env.local"), "utf8").catch(() => "");
+  const envRoot = await readFile5(join7(cwd, ".env"), "utf8").catch(() => "");
+  const envLocal = await readFile5(join7(cwd, ".env.local"), "utf8").catch(() => "");
   const merged = { ...parseEnv(envRoot), ...parseEnv(envLocal) };
   for (const secret of config.secrets ?? []) {
     if (merged[secret] !== void 0) continue;
@@ -2837,6 +3061,19 @@ var init_invoke = __esm({
   }
 });
 
+// packages/cli/src/builtin-deps.ts
+var LOCAL_STATE_OBJECTS_SPECIFIER, LOCAL_BUILTIN_DEPS;
+var init_builtin_deps = __esm({
+  "packages/cli/src/builtin-deps.ts"() {
+    "use strict";
+    LOCAL_STATE_OBJECTS_SPECIFIER = "@adep/runtime/state-objects";
+    LOCAL_BUILTIN_DEPS = [
+      "@adep/cf-compat",
+      LOCAL_STATE_OBJECTS_SPECIFIER
+    ];
+  }
+});
+
 // packages/cli/src/sim/boundary.ts
 var SIM_BOUNDARIES;
 var init_boundary = __esm({
@@ -2873,12 +3110,12 @@ var init_boundary = __esm({
 });
 
 // packages/cli/src/ts-config.ts
-import { stat as stat4, readFile as readFile5 } from "node:fs/promises";
-import { join as join7 } from "node:path";
+import { stat as stat5, readFile as readFile6 } from "node:fs/promises";
+import { join as join8 } from "node:path";
 async function loadAdepConfigModule(cwd) {
-  const configPath = join7(cwd, "adep.config.ts");
+  const configPath = join8(cwd, "adep.config.ts");
   try {
-    await stat4(configPath);
+    await stat5(configPath);
   } catch {
     return null;
   }
@@ -2890,7 +3127,7 @@ async function loadAdepConfigModule(cwd) {
       rawDefault = mod.default;
     } else {
       const { transform } = await import("esbuild");
-      const source = await readFile5(configPath, "utf8");
+      const source = await readFile6(configPath, "utf8");
       const { code } = await transform(source, {
         loader: "ts",
         format: "esm",
@@ -2920,7 +3157,1120 @@ ${result.errors.map((e) => `  - ${e}`).join("\n")}`;
 var init_ts_config = __esm({
   "packages/cli/src/ts-config.ts"() {
     "use strict";
-    init_adep_config();
+    init_adep_config();
+  }
+});
+
+// packages/runtime/src/state-objects/runtime.ts
+var StateObject, StateObjectError, StateObjectRuntime;
+var init_runtime2 = __esm({
+  "packages/runtime/src/state-objects/runtime.ts"() {
+    "use strict";
+    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);
+      }
+    };
+    StateObjectError = class extends Error {
+      code;
+      constructor(code, message) {
+        super(message);
+        this.name = "StateObjectError";
+        this.code = code;
+      }
+    };
+    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
+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
+      ]);
+    }
+  };
+}
+var STATE_OBJECTS_TABLE;
+var init_backend = __esm({
+  "packages/runtime/src/state-objects/backend.ts"() {
+    "use strict";
+    STATE_OBJECTS_TABLE = "_adep_state_objects";
+  }
+});
+
+// packages/runtime/src/state-objects/http.ts
+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" };
+  }
+}
+var STATE_PATH;
+var init_http = __esm({
+  "packages/runtime/src/state-objects/http.ts"() {
+    "use strict";
+    STATE_PATH = "state";
+  }
+});
+
+// packages/runtime/src/state-objects/demo.ts
+var DemoCounter, DemoChatRoom;
+var init_demo = __esm({
+  "packages/runtime/src/state-objects/demo.ts"() {
+    "use strict";
+    init_runtime2();
+    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 };
+      }
+    };
+    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/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;
+}
+var init_exports = __esm({
+  "packages/runtime/src/functions/runtime/exports.ts"() {
+    "use strict";
+  }
+});
+
+// packages/runtime/src/functions/runtime/sandbox.ts
+import vm from "node:vm";
+import * as nodeModule from "node:module";
+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);
+}
+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 };
+}
+var bunTranspiler, SANDBOX_BUILTIN_REJECTED;
+var init_sandbox = __esm({
+  "packages/runtime/src/functions/runtime/sandbox.ts"() {
+    "use strict";
+    init_exports();
+    SANDBOX_BUILTIN_REJECTED = "FN_SANDBOX_BUILTIN_BLOCKED";
+  }
+});
+
+// packages/runtime/src/state-objects/loader.ts
+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);
+}
+var STATE_OBJECTS_ENTRY, STATE_OBJECTS_SPECIFIER;
+var init_loader = __esm({
+  "packages/runtime/src/state-objects/loader.ts"() {
+    "use strict";
+    init_runtime2();
+    init_sandbox();
+    STATE_OBJECTS_ENTRY = "state-objects.ts";
+    STATE_OBJECTS_SPECIFIER = "@adep/runtime/state-objects";
+  }
+});
+
+// packages/runtime/src/state-objects/index.ts
+var init_state_objects = __esm({
+  "packages/runtime/src/state-objects/index.ts"() {
+    "use strict";
+    init_runtime2();
+    init_backend();
+    init_http();
+    init_demo();
+    init_loader();
+  }
+});
+
+// packages/runtime/src/functions/runtime/cloud-container.ts
+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;
+    }
+  };
+}
+var KNOWN_CAPABILITY_HINTS, CapabilityNotRegisteredError;
+var init_cloud_container = __esm({
+  "packages/runtime/src/functions/runtime/cloud-container.ts"() {
+    "use strict";
+    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"
+      }
+    };
+    CapabilityNotRegisteredError = class extends Error {
+      code;
+      constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "CapabilityNotRegisteredError";
+      }
+    };
+  }
+});
+
+// packages/runtime/src/functions/runtime/sandbox-fetch.ts
+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;
+  });
+}
+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;
+}
+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()))
+  };
+}
+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);
+    }
+  };
+}
+var SandboxFetchError, DEFAULT_MAX_RESPONSE_BYTES, defaultFetch, FORBIDDEN, TOO_LARGE, encoder, decoder;
+var init_sandbox_fetch = __esm({
+  "packages/runtime/src/functions/runtime/sandbox-fetch.ts"() {
+    "use strict";
+    SandboxFetchError = class extends Error {
+      code;
+      constructor(code, message) {
+        super(message);
+        this.name = "SandboxFetchError";
+        this.code = code;
+      }
+    };
+    DEFAULT_MAX_RESPONSE_BYTES = 100 * 1024 * 1024;
+    defaultFetch = (url, init) => (
+      // 真实 Response 与内部 ResponseLike 结构性一致；getReader 的多态签名差异属纯类型问题，运行语义等价。
+      globalThis.fetch(url, init)
+    );
+    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`
+    );
+    TOO_LARGE = new SandboxFetchError(
+      "FN_FETCH_TOO_LARGE",
+      "cloud.fetch \u54CD\u5E94\u4F53\u8D85\u8FC7\u4E0A\u9650\uFF08FN_FETCH_TOO_LARGE\uFF09"
+    );
+    encoder = new TextEncoder();
+    decoder = new TextDecoder();
+  }
+});
+
+// packages/runtime/src/functions/runtime/rpc-key.ts
+var init_rpc_key = __esm({
+  "packages/runtime/src/functions/runtime/rpc-key.ts"() {
+    "use strict";
+    init_capability_keys();
+  }
+});
+
+// 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((resolve13, reject) => {
+    const id = nextId();
+    pending.set(id, { resolve: resolve13, 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);
+}
+var init_chain = __esm({
+  "packages/runtime/src/functions/runtime/chain.ts"() {
+    "use strict";
+    init_capability_keys();
+    init_capability_keys();
+  }
+});
+
+// packages/runtime/src/functions/runtime/worker-entry.ts
+import { parentPort, workerData } from "node:worker_threads";
+import { createRequire as createRequire2 } from "node:module";
+import { join as join9 } from "node:path";
+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((resolve13, reject) => {
+            pending.set(id, { resolve: resolve13, 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 escapeRegExp2(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function firstUserFrame(stack, files) {
+  for (const key of Object.keys(files)) {
+    const match = new RegExp(
+      `(?<![\\w$/.])${escapeRegExp2(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 = createRequire2(import.meta.url);
+  const depsRequire = deps.dir === null ? null : createRequire2(join9(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;
+var init_worker_entry = __esm({
+  "packages/runtime/src/functions/runtime/worker-entry.ts"() {
+    "use strict";
+    init_cloud_container();
+    init_sandbox();
+    init_sandbox_fetch();
+    init_rpc_key();
+    init_chain();
+    init_sandbox();
+    init_manifest();
+    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);
+    }
   }
 });
 
@@ -2934,15 +4284,16 @@ __export(dev_exports, {
 });
 import { createServer } from "node:http";
 import { watch } from "node:fs";
-import { mkdir as mkdir5, readdir as readdir2, readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
-import { basename, join as join8, resolve as resolve3 } from "node:path";
+import { mkdir as mkdir6, readdir as readdir3, readFile as readFile7, writeFile as writeFile5 } from "node:fs/promises";
+import { basename as basename2, join as join10, resolve as resolve4 } from "node:path";
 async function loadConfig(cwd) {
-  const name = basename(resolve3(cwd));
+  const name = basename2(resolve4(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) {
@@ -2963,17 +4314,17 @@ async function collectFunctions(dir) {
   const walk = async (sub, prefix) => {
     let entries;
     try {
-      entries = await readdir2(sub, { withFileTypes: true });
+      entries = await readdir3(sub, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       const rel = prefix.length === 0 ? entry.name : `${prefix}/${entry.name}`;
-      const full = join8(sub, entry.name);
+      const full = join10(sub, entry.name);
       if (entry.isDirectory()) {
         await walk(full, rel);
       } else if (entry.isFile() && entry.name.endsWith(".ts")) {
-        files[rel] = await readFile6(full, "utf8");
+        files[rel] = await readFile7(full, "utf8");
       }
     }
   };
@@ -3036,25 +4387,27 @@ function printBoundaries(log) {
   }
 }
 async function ensureGitignore(cwd) {
-  const gitignorePath = join8(cwd, ".gitignore");
-  const existing = await readFile6(gitignorePath, "utf8").catch(() => "");
+  const gitignorePath = join10(cwd, ".gitignore");
+  const existing = await readFile7(gitignorePath, "utf8").catch(() => "");
   if (existing.split(/\r?\n/).includes(".adep/")) return;
-  await writeFile4(gitignorePath, `${existing.replace(/\n+$/, "")}
+  await writeFile5(gitignorePath, `${existing.replace(/\n+$/, "")}
 .adep/
 `, "utf8");
 }
 async function startDevServer(options) {
-  const cwd = resolve3(options.cwd);
+  const cwd = resolve4(options.cwd);
   const log = options.log ?? ((line) => process.stdout.write(`${line}
 `));
   const config = await loadConfig(cwd);
   if (options.prefix !== void 0) {
     config.functionsPrefix = options.prefix.replace(/^\/+|\/+$/g, "");
   }
-  const functionsDir = join8(cwd, config.functionsDir);
+  const functionsDir = join10(cwd, config.functionsDir);
   const coldStartAt = Date.now();
-  const executor = new WorkerFunctionExecutor();
-  await mkdir5(functionsDir, { recursive: true });
+  const executor = new WorkerFunctionExecutor({
+    deps: { rootDir: cwd, builtin: LOCAL_BUILTIN_DEPS }
+  });
+  await mkdir6(functionsDir, { recursive: true });
   const runtime = await createSimRuntime({
     cwd,
     projectId: "local",
@@ -3063,19 +4416,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),
-      readFile6(join8(cwd, ".env.local"), "utf8").catch(() => "")
+      readFile7(join10(cwd, ".env.local"), "utf8").catch(() => "")
     ]);
     files = nextFiles;
-    env = parseEnvFile(envText2);
+    env = { ...config.environment, ...parseEnvFile(envText2) };
   };
-  const envText = await readFile6(join8(cwd, ".env.local"), "utf8").catch(() => "");
-  env = parseEnvFile(envText);
+  const envText = await readFile7(join10(cwd, ".env.local"), "utf8").catch(() => "");
+  env = { ...config.environment, ...parseEnvFile(envText) };
   let debounceTimer;
   let watcher;
   try {
@@ -3135,6 +4560,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`);
@@ -3146,8 +4608,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);
@@ -3205,10 +4674,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()));
@@ -3221,12 +4692,16 @@ var init_dev = __esm({
   "packages/cli/src/dev.ts"() {
     "use strict";
     init_executor();
+    init_http_envelope();
     init_worker_executor();
     init_runtime();
     init_env();
     init_invoke();
+    init_builtin_deps();
     init_boundary();
     init_ts_config();
+    init_state_objects();
+    init_worker_entry();
   }
 });
 
@@ -3302,8 +4777,8 @@ __export(server_exports, {
 });
 import { createServer as createServer2 } from "node:http";
 import { watch as watch2 } from "node:fs";
-import { mkdir as mkdir6, readdir as readdir3, readFile as readFile7, stat as stat5 } from "node:fs/promises";
-import { join as join9, relative, resolve as resolve4 } from "node:path";
+import { mkdir as mkdir7, readdir as readdir4, readFile as readFile8, stat as stat6 } from "node:fs/promises";
+import { join as join11, relative as relative2, resolve as resolve5 } from "node:path";
 function envNumber(name) {
   const raw = process.env[name];
   if (raw === void 0 || raw.trim() === "") return void 0;
@@ -3319,17 +4794,17 @@ async function collectFunctions2(dir) {
   const walk = async (sub, prefix) => {
     let entries;
     try {
-      entries = await readdir3(sub, { withFileTypes: true });
+      entries = await readdir4(sub, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       const rel = prefix.length === 0 ? entry.name : `${prefix}/${entry.name}`;
-      const full = join9(sub, entry.name);
+      const full = join11(sub, entry.name);
       if (entry.isDirectory()) {
         await walk(full, rel);
       } else if (entry.isFile() && entry.name.endsWith(".ts")) {
-        files[rel] = await readFile7(full, "utf8");
+        files[rel] = await readFile8(full, "utf8");
       }
     }
   };
@@ -3364,27 +4839,27 @@ function contentTypeFor(path) {
   return MIME_TYPES[ext] ?? "application/octet-stream";
 }
 async function startServeServer(options) {
-  const cwd = resolve4(options.cwd);
+  const cwd = resolve5(options.cwd);
   const log = options.log ?? ((line) => process.stdout.write(`${line}
 `));
   const host = options.host ?? envString("HOST") ?? "127.0.0.1";
   const port = options.port ?? envNumber("PORT") ?? 8787;
-  const staticDir = resolve4(
+  const staticDir = resolve5(
     cwd,
     options.staticDir ?? envString("ADEP_SERVE_STATIC_DIR") ?? "public"
   );
   const config = await loadConfig(cwd);
-  const functionsDir = join9(cwd, config.functionsDir);
+  const functionsDir = join11(cwd, config.functionsDir);
   let hasStatic = false;
   try {
-    const publicStat = await stat5(staticDir);
+    const publicStat = await stat6(staticDir);
     hasStatic = publicStat.isDirectory();
   } catch {
     hasStatic = false;
   }
   let files = await collectFunctions2(functionsDir);
   let functionNames = listFunctionNames(files);
-  const envText = await readFile7(join9(cwd, ".env.local"), "utf8").catch(() => "");
+  const envText = await readFile8(join11(cwd, ".env.local"), "utf8").catch(() => "");
   let env = parseEnvFile(envText);
   let simEnv = await loadSimEnv(cwd).catch(() => ({}));
   const runtime = await createSimRuntime({
@@ -3393,7 +4868,9 @@ async function startServeServer(options) {
     baseUrl: `http://${host}:${port}`,
     log
   });
-  const executor = new WorkerFunctionExecutor();
+  const executor = new WorkerFunctionExecutor({
+    deps: { rootDir: cwd, builtin: LOCAL_BUILTIN_DEPS }
+  });
   const dbBundle = runtime.bundle;
   let invokeHandler = createSimInvokeHandler({ executor, files });
   let stopWatch;
@@ -3401,7 +4878,7 @@ async function startServeServer(options) {
     const reload = async () => {
       const [nextFiles, envLocalText] = await Promise.all([
         collectFunctions2(functionsDir),
-        readFile7(join9(cwd, ".env.local"), "utf8").catch(() => "")
+        readFile8(join11(cwd, ".env.local"), "utf8").catch(() => "")
       ]);
       files = nextFiles;
       env = parseEnvFile(envLocalText);
@@ -3418,7 +4895,7 @@ async function startServeServer(options) {
         void reload();
       }, 120);
     };
-    await mkdir6(functionsDir, { recursive: true }).catch(() => void 0);
+    await mkdir7(functionsDir, { recursive: true }).catch(() => void 0);
     try {
       watchers.push(watch2(functionsDir, { recursive: true }, scheduleReload));
     } catch {
@@ -3444,8 +4921,8 @@ async function startServeServer(options) {
       if (typeof value === "string") headers[key] = value;
     }
     const body = req.method === "GET" || req.method === "HEAD" ? void 0 : await bodyOf2(req);
-    const hasEnv = Object.keys(env).length > 0 || Object.keys(simEnv).length > 0;
-    const mergedEnv = { ...simEnv, ...env };
+    const hasEnv = Object.keys(env).length > 0 || Object.keys(simEnv).length > 0 || Object.keys(config.environment ?? {}).length > 0;
+    const mergedEnv = { ...config.environment, ...simEnv, ...env };
     return {
       project: { id: "local", slug: config.name },
       fn: { id: fnName, name: fnName },
@@ -3470,16 +4947,16 @@ async function startServeServer(options) {
   const serveStatic = async (pathname, res) => {
     if (!hasStatic) return false;
     const safePath = pathname.replace(/\.\.\//g, "").replace(/^\//, "");
-    const filePath = join9(staticDir, safePath);
-    const resolvedPath = safePath === "" || safePath === "/" ? join9(filePath, "index.html") : filePath;
+    const filePath = join11(staticDir, safePath);
+    const resolvedPath = safePath === "" || safePath === "/" ? join11(filePath, "index.html") : filePath;
     try {
-      const fileStat = await stat5(resolvedPath);
+      const fileStat = await stat6(resolvedPath);
       if (fileStat.isDirectory()) {
-        const indexPath = join9(resolvedPath, "index.html");
+        const indexPath = join11(resolvedPath, "index.html");
         try {
-          const indexStat = await stat5(indexPath);
+          const indexStat = await stat6(indexPath);
           if (indexStat.isFile()) {
-            const content2 = await readFile7(indexPath);
+            const content2 = await readFile8(indexPath);
             res.writeHead(200, { "content-type": contentTypeFor(indexPath) });
             res.end(content2);
             return true;
@@ -3488,7 +4965,7 @@ async function startServeServer(options) {
         }
         return false;
       }
-      const content = await readFile7(resolvedPath);
+      const content = await readFile8(resolvedPath);
       res.writeHead(200, { "content-type": contentTypeFor(resolvedPath) });
       res.end(content);
       return true;
@@ -3523,10 +5000,17 @@ async function startServeServer(options) {
       try {
         const result = await executor.execute(input);
         const durationMs = Math.round(performance.now() - startedAt);
-        log(`[serve] ${req.method ?? "GET"} ${pathname} -> 200 ${durationMs}ms`);
         if (options.watch === true) {
           for (const line of result.logs) log(`[serve]   ${line}`);
         }
+        if (isAdepHttpEnvelope(result.body)) {
+          log(
+            `[serve] ${req.method ?? "GET"} ${pathname} -> ${result.body.__adepHttp.status} ${durationMs}ms`
+          );
+          writeEnvelopeResponse(res, result.body);
+          return;
+        }
+        log(`[serve] ${req.method ?? "GET"} ${pathname} -> 200 ${durationMs}ms`);
         writeJson2(res, 200, result.body === void 0 ? null : result.body);
       } catch (error) {
         const durationMs = Math.round(performance.now() - startedAt);
@@ -3602,7 +5086,7 @@ async function startServeServer(options) {
     functions: functionNames,
     functionsPrefix: config.functionsPrefix,
     hasStatic,
-    staticDir: relative(cwd, staticDir).length > 0 ? relative(cwd, staticDir) : staticDir
+    staticDir: relative2(cwd, staticDir).length > 0 ? relative2(cwd, staticDir) : staticDir
   });
   log(banner);
   if (options.watch === true) {
@@ -3625,7 +5109,9 @@ var init_server = __esm({
   "packages/cli/src/serve/server.ts"() {
     "use strict";
     init_executor();
+    init_http_envelope();
     init_worker_executor();
+    init_builtin_deps();
     init_runtime();
     init_env();
     init_invoke();
@@ -3763,8 +5249,8 @@ __export(deploy_exports, {
   deploy: () => deploy
 });
 import { createHash as createHash2 } from "node:crypto";
-import { readdir as readdir4, readFile as readFile8 } from "node:fs/promises";
-import { join as join10, resolve as resolve5, basename as basename2 } from "node:path";
+import { readdir as readdir5, readFile as readFile9 } from "node:fs/promises";
+import { join as join12, resolve as resolve6, basename as basename3 } from "node:path";
 function functionUrlBase(prefix) {
   const raw = (prefix ?? "/api").trim();
   const normalized = raw === "/" ? "/" : raw.replace(/\/+$/, "");
@@ -3774,13 +5260,13 @@ async function collectEntries(functionsDir) {
   const entries = {};
   let names;
   try {
-    const dirents = await readdir4(functionsDir, { withFileTypes: true });
-    names = dirents.filter((entry) => entry.isFile() && entry.name.endsWith(".ts")).map((entry) => basename2(entry.name, ".ts")).toSorted();
+    const dirents = await readdir5(functionsDir, { withFileTypes: true });
+    names = dirents.filter((entry) => entry.isFile() && entry.name.endsWith(".ts")).map((entry) => basename3(entry.name, ".ts")).toSorted();
   } catch {
     return entries;
   }
   for (const name of names) {
-    entries[name] = await readFile8(join10(functionsDir, `${name}.ts`), "utf8");
+    entries[name] = await readFile9(join12(functionsDir, `${name}.ts`), "utf8");
   }
   return entries;
 }
@@ -3792,10 +5278,10 @@ async function deploy(paths, options) {
   const log = options.silent === true ? () => void 0 : options.log ?? ((line) => process.stdout.write(`${line}
 `));
   const client = await createClient(paths);
-  const cwd = resolve5(options.cwd);
+  const cwd = resolve6(options.cwd);
   const config = await loadConfig(cwd);
   const slug = options.slug ?? config.name;
-  const functionsDir = options.functionsDir === void 0 ? join10(cwd, config.functionsDir) : resolve5(cwd, options.functionsDir);
+  const functionsDir = options.functionsDir === void 0 ? join12(cwd, config.functionsDir) : resolve6(cwd, options.functionsDir);
   const local = await collectEntries(functionsDir);
   if (Object.keys(local).length === 0) {
     throw new CliError("NO_FUNCTIONS", `${functionsDir} \u4E0B\u6CA1\u6709\u51FD\u6570\u6587\u4EF6`);
@@ -3878,7 +5364,7 @@ var client_exports2 = {};
 __export(client_exports2, {
   createExportApiClient: () => createExportApiClient
 });
-import { writeFile as writeFile5 } from "node:fs/promises";
+import { writeFile as writeFile6 } from "node:fs/promises";
 function toExportJob(view) {
   return {
     id: view.id,
@@ -3929,7 +5415,7 @@ async function createExportApiClient(paths) {
       }
       const response = await client.download(download.downloadUrl, "EXPORT_DOWNLOAD_FAILED");
       const bytes = Buffer.from(await response.arrayBuffer());
-      await writeFile5(outputPath, bytes);
+      await writeFile6(outputPath, bytes);
       return { path: outputPath, size: bytes.length };
     }
   };
@@ -3949,7 +5435,7 @@ function zipRead(buf) {
   if (eocd < 0) throw new ZipFormatError("\u627E\u4E0D\u5230 EOCD \u7B7E\u540D");
   const total = r.u16(eocd + 10);
   const centralOffset = r.u32(eocd + 16);
-  const decoder = new TextDecoder();
+  const decoder2 = new TextDecoder();
   const out = /* @__PURE__ */ new Map();
   let cursor = centralOffset;
   for (let i = 0; i < total; i++) {
@@ -3963,7 +5449,7 @@ function zipRead(buf) {
     const commentLen = r.u16(cursor + 32);
     const localHeaderOffset = r.u32(cursor + 42);
     if (localHeaderOffset + 30 > buf.length) throw new ZipFormatError("\u672C\u5730\u5934\u504F\u79FB\u8D8A\u754C");
-    const name = decoder.decode(r.slice(cursor + 46, nameLen));
+    const name = decoder2.decode(r.slice(cursor + 46, nameLen));
     const localNameLen = r.u16(localHeaderOffset + 26);
     const localExtraLen = r.u16(localHeaderOffset + 28);
     const dataStart = localHeaderOffset + 30 + localNameLen + localExtraLen;
@@ -4026,33 +5512,33 @@ var fs_exports = {};
 __export(fs_exports, {
   createExportFileSystem: () => createExportFileSystem
 });
-import { mkdir as mkdir7, readFile as readFile9, rm as rm3, stat as stat6, writeFile as writeFile6 } from "node:fs/promises";
-import { dirname as dirname6, join as join11 } from "node:path";
+import { mkdir as mkdir8, readFile as readFile10, rm as rm3, stat as stat7, writeFile as writeFile7 } from "node:fs/promises";
+import { dirname as dirname7, join as join13 } from "node:path";
 function createExportFileSystem() {
   return {
-    readFile: (path) => readFile9(path),
-    writeFile: (path, content) => writeFile6(path, content),
+    readFile: (path) => readFile10(path),
+    writeFile: (path, content) => writeFile7(path, content),
     // 同时用于清理解压临时目录（${zip}.tmp 是个目录）——递归强制删除，缺失不报错。
     deleteFile: async (path) => {
       await rm3(path, { recursive: true, force: true });
     },
     fileExists: async (path) => {
       try {
-        await stat6(path);
+        await stat7(path);
         return true;
       } catch {
         return false;
       }
     },
     mkdir: async (path) => {
-      await mkdir7(path, { recursive: true });
+      await mkdir8(path, { recursive: true });
     },
     unzip: async (zipPath, targetDir) => {
-      const entries = zipRead(await readFile9(zipPath));
+      const entries = zipRead(await readFile10(zipPath));
       for (const [name, data] of entries) {
-        const dest = join11(targetDir, name);
-        await mkdir7(dirname6(dest), { recursive: true });
-        await writeFile6(dest, data);
+        const dest = join13(targetDir, name);
+        await mkdir8(dirname7(dest), { recursive: true });
+        await writeFile7(dest, data);
       }
     }
   };
@@ -4553,7 +6039,7 @@ ${detail}`);
        * @param ms 毫秒数
        */
       sleep(ms) {
-        return new Promise((resolve12) => setTimeout(resolve12, ms));
+        return new Promise((resolve13) => setTimeout(resolve13, ms));
       }
     };
   }
@@ -4571,10 +6057,10 @@ __export(db_exports, {
   dbStatus: () => dbStatus,
   dbStop: () => dbStop
 });
-import { resolve as resolve7 } from "node:path";
+import { resolve as resolve8 } from "node:path";
 async function open2(paths, options) {
   const client = await createClient(paths);
-  const project2 = await resolveSlug(resolve7(options.cwd), options.slug);
+  const project2 = await resolveSlug(resolve8(options.cwd), options.slug);
   return { client, project: project2 };
 }
 async function dbStart(paths, options) {
@@ -4648,11 +6134,11 @@ __export(storage_exports, {
   storageRemove: () => storageRemove,
   storageUpload: () => storageUpload
 });
-import { mkdir as mkdir8, readFile as readFile10, stat as stat7, writeFile as writeFile7 } from "node:fs/promises";
-import { basename as basename3, dirname as dirname7, extname, join as join12, resolve as resolve8 } from "node:path";
+import { mkdir as mkdir9, readFile as readFile11, stat as stat8, writeFile as writeFile8 } from "node:fs/promises";
+import { basename as basename4, dirname as dirname8, extname, join as join14, resolve as resolve9 } from "node:path";
 async function open3(paths, options) {
   const client = await createClient(paths);
-  const project2 = await resolveSlug(resolve8(options.cwd), options.slug);
+  const project2 = await resolveSlug(resolve9(options.cwd), options.slug);
   return { client, project: project2 };
 }
 function contentTypeOf(path) {
@@ -4685,20 +6171,20 @@ function contentTypeOf(path) {
 }
 async function storageUpload(paths, options) {
   const { client, project: project2 } = await open3(paths, options);
-  const local = resolve8(options.file);
-  const info = await stat7(local).catch(() => null);
+  const local = resolve9(options.file);
+  const info = await stat8(local).catch(() => null);
   if (info === null || !info.isFile()) {
     throw new CliError("FILE_NOT_FOUND", `\u672C\u5730\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${local}`);
   }
   const visibility = options.visibility ?? "private";
-  const bytes = await readFile10(local);
+  const bytes = await readFile11(local);
   const form = new FormData();
   form.set("path", options.path);
   form.set("visibility", visibility);
   form.set(
     "file",
     new Blob([bytes], { type: contentTypeOf(options.path) }),
-    basename3(local)
+    basename4(local)
   );
   const response = await client.upload(
     `/api/v1/projects/${project2}/files`,
@@ -4732,9 +6218,9 @@ async function storageDownload(paths, options) {
   const url = await resolveDownloadUrl(client, project2, options.path);
   const response = await client.download(url, "STORAGE_DOWNLOAD_FAILED");
   const bytes = Buffer.from(await response.arrayBuffer());
-  const output = resolve8(options.output ?? join12(resolve8(options.cwd), basename3(options.path)));
-  await mkdir8(dirname7(output), { recursive: true });
-  await writeFile7(output, bytes);
+  const output = resolve9(options.output ?? join14(resolve9(options.cwd), basename4(options.path)));
+  await mkdir9(dirname8(output), { recursive: true });
+  await writeFile8(output, bytes);
   return { path: options.path, output, size: bytes.length };
 }
 async function storageRemove(paths, options) {
@@ -4758,7 +6244,7 @@ __export(doctor_exports, {
   formatDoctorReport: () => formatDoctorReport,
   runDoctor: () => runDoctor
 });
-import { stat as stat8 } from "node:fs/promises";
+import { stat as stat9 } from "node:fs/promises";
 async function probeServer(server) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), SERVER_PROBE_TIMEOUT_MS);
@@ -4776,7 +6262,7 @@ async function probeServer(server) {
 }
 async function credentialMode(file) {
   try {
-    const info = await stat8(file);
+    const info = await stat9(file);
     return (info.mode & 511).toString(8).padStart(3, "0");
   } catch {
     return void 0;
@@ -4865,7 +6351,7 @@ __export(mcp_exports, {
   mcpPublish: () => mcpPublish,
   mcpUnpublish: () => mcpUnpublish
 });
-import { resolve as resolve9 } from "node:path";
+import { resolve as resolve10 } from "node:path";
 async function mcpPublish(paths, options) {
   const fn = requireFunctionName(options.fn);
   const client = await createClient(paths);
@@ -4946,7 +6432,7 @@ function requireFunctionName(fn) {
   return fn.trim();
 }
 async function resolveProject(client, options) {
-  const slug = await resolveSlug(resolve9(options.cwd), options.slug);
+  const slug = await resolveSlug(resolve10(options.cwd), options.slug);
   const listed = await client.request("/api/v1/projects", {}, "PROJECT_LIST_FAILED");
   const match = listed.projects.find((project2) => project2.slug === slug);
   if (match === void 0) {
@@ -5047,13 +6533,13 @@ __export(functions_exports, {
   functionsList: () => functionsList,
   functionsLogs: () => functionsLogs
 });
-import { resolve as resolve10 } from "node:path";
+import { resolve as resolve11 } from "node:path";
 async function functionsDeploy(paths, options) {
   const startedAt = Date.now();
   const result = await deploy(paths, {
     cwd: options.cwd,
     ...options.slug === void 0 ? {} : { slug: options.slug },
-    ...options.dir === void 0 ? {} : { functionsDir: resolve10(options.cwd, options.dir) },
+    ...options.dir === void 0 ? {} : { functionsDir: resolve11(options.cwd, options.dir) },
     silent: true
   });
   return { ...result, elapsedSeconds: (Date.now() - startedAt) / 1e3 };
@@ -5099,7 +6585,7 @@ async function functionsLogs(paths, options) {
   return { functionId: target.id, name: target.name, logs: result.logs };
 }
 async function resolveProject2(client, options) {
-  const slug = await resolveSlug(resolve10(options.cwd), options.slug);
+  const slug = await resolveSlug(resolve11(options.cwd), options.slug);
   const projects = await projectsListFrom(client);
   const match = projects.find((project2) => project2.slug === slug);
   if (match === void 0) {
@@ -5131,11 +6617,11 @@ __export(hosting_exports, {
   hostingInfo: () => hostingInfo,
   hostingPull: () => hostingPull
 });
-import { readdir as readdir5, readFile as readFile11, stat as stat9 } from "node:fs/promises";
-import { dirname as dirname8, join as join13, relative as relative2, resolve as resolve11, sep } from "node:path";
+import { readdir as readdir6, readFile as readFile12, stat as stat10 } from "node:fs/promises";
+import { dirname as dirname9, join as join15, relative as relative3, resolve as resolve12, sep } from "node:path";
 async function open4(paths, options) {
   const client = await createClient(paths);
-  const project2 = await resolveSlug(resolve11(options.cwd), options.slug);
+  const project2 = await resolveSlug(resolve12(options.cwd), options.slug);
   return { client, project: project2 };
 }
 async function hostingInfo(paths, options) {
@@ -5148,21 +6634,21 @@ async function hostingInfo(paths, options) {
   };
 }
 async function collectSiteFiles(dir) {
-  const root = resolve11(dir);
+  const root = resolve12(dir);
   const files = /* @__PURE__ */ new Map();
   const walk = async (sub) => {
     let entries;
     try {
-      entries = await readdir5(sub, { withFileTypes: true });
+      entries = await readdir6(sub, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = join13(sub, entry.name);
+      const full = join15(sub, entry.name);
       if (entry.isDirectory()) {
         await walk(full);
       } else if (entry.isFile()) {
-        const rel = relative2(root, full).split(sep).join("/");
+        const rel = relative3(root, full).split(sep).join("/");
         files.set(rel, full);
       }
     }
@@ -5176,13 +6662,13 @@ async function hostingDeploy(paths, options) {
 `));
   const files = await collectSiteFiles(options.dir);
   if (files.size === 0) {
-    throw new CliError("NO_SITE_FILES", `\u7AD9\u70B9\u76EE\u5F55\u4E3A\u7A7A\uFF1A${resolve11(options.dir)}`);
+    throw new CliError("NO_SITE_FILES", `\u7AD9\u70B9\u76EE\u5F55\u4E3A\u7A7A\uFF1A${resolve12(options.dir)}`);
   }
   const uploaded = [];
   for (const [rel, full] of files) {
     log(`[adep] \u4E0A\u4F20 site/${rel}`);
-    const info2 = await stat9(full);
-    const bytes = await readFile11(full);
+    const info2 = await stat10(full);
+    const bytes = await readFile12(full);
     const form = new FormData();
     form.set("path", `site/${rel}`);
     form.set("visibility", "public");
@@ -5209,8 +6695,8 @@ async function hostingPull(paths, options) {
   const log = options.log ?? ((line) => process.stdout.write(`${line}
 `));
   const info = await hostingInfo(paths, options);
-  const outputDir = resolve11(options.output ?? resolve11(options.cwd));
-  const { mkdir: mkdir9, writeFile: writeFile8 } = await import("node:fs/promises");
+  const outputDir = resolve12(options.output ?? resolve12(options.cwd));
+  const { mkdir: mkdir10, writeFile: writeFile9 } = await import("node:fs/promises");
   const files = [];
   for (const entry of info.files) {
     if (entry.visibility !== "public" || entry.path === HOSTING_CONFIG_PATH) continue;
@@ -5220,9 +6706,9 @@ async function hostingPull(paths, options) {
     const response = await client.download(url, "HOSTING_DOWNLOAD_FAILED");
     const bytes = Buffer.from(await response.arrayBuffer());
     const rel = entry.path.replace(/^site\//, "");
-    const target = join13(outputDir, ...rel.split("/"));
-    await mkdir9(dirname8(target), { recursive: true });
-    await writeFile8(target, bytes);
+    const target = join15(outputDir, ...rel.split("/"));
+    await mkdir10(dirname9(target), { recursive: true });
+    await writeFile9(target, bytes);
     files.push({ path: entry.path, size: bytes.length });
   }
   return { siteUrl: info.siteUrl, outputDir, files };
@@ -5252,7 +6738,7 @@ var init_hosting = __esm({
 // packages/cli/src/cli.ts
 init_config();
 import { Command } from "commander";
-import { createRequire as createRequire2 } from "node:module";
+import { createRequire as createRequire3 } from "node:module";
 
 // packages/cli/src/output.ts
 init_auth();
@@ -6163,6 +7649,760 @@ function registerInit(program2, ctx) {
   );
 }
 
+// packages/cli/src/import-cf.ts
+init_adep_config();
+import { copyFile, mkdir as mkdir3, readFile as readFile2, readdir, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
+import { basename, dirname as dirname3, join as join2, relative, resolve as resolve2 } from "node:path";
+var TomlSyntaxError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TomlSyntaxError";
+  }
+};
+function parseTomlValue(raw) {
+  const text = raw.trim();
+  if (text === "") throw new TomlSyntaxError("\u7A7A\u503C");
+  if (text.startsWith("[") && text.endsWith("]")) {
+    const inner = text.slice(1, -1).trim();
+    if (inner === "") return [];
+    return splitTopLevel(inner).map((part) => parseTomlValue(part));
+  }
+  if (text.startsWith("{") && text.endsWith("}")) {
+    const inner = text.slice(1, -1).trim();
+    const table = {};
+    if (inner !== "") {
+      for (const pair of splitTopLevel(inner)) {
+        const eq = pair.indexOf("=");
+        if (eq <= 0) throw new TomlSyntaxError(`\u5185\u8054\u8868\u6761\u76EE\u975E\u6CD5\uFF1A${pair}`);
+        const key = pair.slice(0, eq).trim().replace(/^"|"$/g, "");
+        table[key] = parseTomlValue(pair.slice(eq + 1));
+      }
+    }
+    return table;
+  }
+  if (text.startsWith('"') || text.startsWith("'")) {
+    return unquoteToml(text);
+  }
+  if (text === "true") return true;
+  if (text === "false") return false;
+  const number = Number(text);
+  if (text !== "" && !Number.isNaN(number) && /^-?\d+(\.\d+)?$/.test(text)) return number;
+  return text;
+}
+function splitTopLevel(text) {
+  const parts = [];
+  let depth = 0;
+  let quote = null;
+  let current = "";
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    if (quote !== null) {
+      current += ch;
+      if (ch === quote && text[i - 1] !== "\\") quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === "{" || ch === "[") depth += 1;
+    if (ch === "}" || ch === "]") depth -= 1;
+    if (ch === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (quote !== null) throw new TomlSyntaxError("\u5B57\u7B26\u4E32\u672A\u95ED\u5408");
+  parts.push(current);
+  return parts;
+}
+function unquoteToml(text) {
+  const quote = text[0];
+  const body = text.slice(1, -1);
+  if (quote === "'") return body;
+  return body.replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+}
+function parseWranglerToml(text) {
+  const root = {};
+  let current = { table: root };
+  const tableAt = (path) => {
+    let node = root;
+    for (const seg of path) {
+      const next = node[seg];
+      if (next === void 0) {
+        const created = {};
+        node[seg] = created;
+        node = created;
+      } else if (typeof next === "object" && next !== null && !Array.isArray(next)) {
+        node = next;
+      } else {
+        throw new TomlSyntaxError(`\u8DEF\u5F84\u51B2\u7A81\uFF1A${path.join(".")}\uFF08${seg} \u4E0D\u662F\u8868\uFF09`);
+      }
+    }
+    return node;
+  };
+  const lines = text.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i += 1) {
+    const rawLine = lines[i] ?? "";
+    const line = stripTomlComment(rawLine).trim();
+    if (line === "") continue;
+    const arrayHeader = /^\[\[([^\]]+)\]\]\s*$/.exec(line);
+    if (arrayHeader !== null) {
+      const path = (arrayHeader[1] ?? "").trim().split(".").filter(Boolean);
+      if (path.length === 0) throw new TomlSyntaxError(`\u7A7A\u6570\u7EC4\u8868\uFF1A${line}`);
+      const parent = path.length === 1 ? root : tableAt(path.slice(0, -1));
+      const key2 = path[path.length - 1] ?? "";
+      let arr = parent[key2];
+      if (arr === void 0) {
+        arr = [];
+        parent[key2] = arr;
+      }
+      if (!Array.isArray(arr)) throw new TomlSyntaxError(`\u8DEF\u5F84\u51B2\u7A81\uFF1A${key2} \u4E0D\u662F\u6570\u7EC4`);
+      const table = {};
+      arr.push(table);
+      current = { table };
+      continue;
+    }
+    const header = /^\[([^\]]+)\]\s*$/.exec(line);
+    if (header !== null) {
+      const path = (header[1] ?? "").trim().split(".").filter(Boolean);
+      if (path.length !== 1) throw new TomlSyntaxError(`\u4EC5\u652F\u6301\u5355\u6BB5\u8868\uFF1A${line}`);
+      current = { table: tableAt(path) };
+      continue;
+    }
+    const eq = line.indexOf("=");
+    if (eq <= 0) throw new TomlSyntaxError(`\u7B2C ${i + 1} \u884C\u65E0\u6CD5\u89E3\u6790\uFF1A${rawLine}`);
+    const key = line.slice(0, eq).trim().replace(/^"|"$/g, "");
+    let valueRaw = line.slice(eq + 1);
+    let depth = bracketDepth(valueRaw);
+    while (depth > 0) {
+      if (i + 1 >= lines.length) {
+        throw new TomlSyntaxError(`\u7B2C ${i + 1} \u884C\u503C\u672A\u95ED\u5408\uFF1A${key}`);
+      }
+      i += 1;
+      const next = stripTomlComment(lines[i] ?? "").trim();
+      valueRaw += ` ${next}`;
+      depth = bracketDepth(valueRaw);
+    }
+    const value = parseTomlValue(valueRaw);
+    current.table[key] = value;
+  }
+  return normalizeWranglerToml(root);
+}
+function stripTomlComment(line) {
+  const hash = line.indexOf("#");
+  if (hash === -1) return line;
+  return line.slice(0, hash);
+}
+function bracketDepth(text) {
+  let depth = 0;
+  let quote = null;
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    if (quote !== null) {
+      if (ch === quote && text[i - 1] !== "\\") quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "[" || ch === "{") depth += 1;
+    if (ch === "]" || ch === "}") depth -= 1;
+  }
+  return depth;
+}
+function tomlString(v) {
+  return typeof v === "string" ? v : void 0;
+}
+function tomlStringRecord(v) {
+  if (typeof v !== "object" || v === null || Array.isArray(v)) return void 0;
+  const out = {};
+  for (const [k, value] of Object.entries(v)) {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      out[k] = String(value);
+    }
+  }
+  return out;
+}
+function tomlBindingArray(v) {
+  if (!Array.isArray(v)) return void 0;
+  const out = [];
+  for (const item of v) {
+    if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+      const rec = {};
+      for (const [k, value] of Object.entries(item)) {
+        if (typeof value === "string" || typeof value === "number") rec[k] = String(value);
+      }
+      out.push(rec);
+    }
+  }
+  return out;
+}
+function normalizeWranglerToml(root) {
+  const name = tomlString(root.name);
+  const main = tomlString(root.main);
+  const vars = tomlStringRecord(root.vars);
+  const kv = tomlBindingArray(root.kv_namespaces);
+  const d1 = tomlBindingArray(root.d1_databases);
+  const r2 = tomlBindingArray(root.r2_buckets);
+  const triggersRaw = typeof root.triggers === "object" && root.triggers !== null ? root.triggers : void 0;
+  const crons = triggersRaw !== void 0 && Array.isArray(triggersRaw.crons) ? triggersRaw.crons.map(String) : void 0;
+  const assetsRaw = typeof root.assets === "object" && root.assets !== null ? root.assets : void 0;
+  const assetsDir = assetsRaw === void 0 ? void 0 : tomlString(assetsRaw.directory);
+  const siteRaw = typeof root.site === "object" && root.site !== null ? root.site : void 0;
+  const siteBucket = siteRaw === void 0 ? void 0 : tomlString(siteRaw.bucket);
+  const out = { raw: root };
+  if (name !== void 0) out.name = name;
+  if (main !== void 0) out.main = main;
+  if (vars !== void 0) out.vars = vars;
+  if (kv !== void 0) out.kv_namespaces = kv;
+  if (d1 !== void 0) out.d1_databases = d1;
+  if (r2 !== void 0) out.r2_buckets = r2;
+  if (crons !== void 0) out.triggers = { crons };
+  if (assetsDir !== void 0) out.assets = { directory: assetsDir };
+  if (siteBucket !== void 0) out.site = { bucket: siteBucket };
+  const doRaw = typeof root.durable_objects === "object" && root.durable_objects !== null ? root.durable_objects : void 0;
+  const doBindings = doRaw === void 0 ? void 0 : tomlBindingArray(doRaw.bindings);
+  if (doBindings !== void 0 && doBindings.length > 0) {
+    out.durable_objects = {
+      bindings: doBindings
+    };
+  }
+  return out;
+}
+var ImportCfError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ImportCfError";
+  }
+};
+function slugify(name, fallback) {
+  const slug = name.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
+  return slug.length > 0 ? slug : fallback;
+}
+var SKIP_COPY_NAMES = /* @__PURE__ */ new Set([
+  "wrangler.toml",
+  "wrangler.json",
+  "wrangler.jsonc",
+  ".dev.vars",
+  "package.json",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "bun.lockb",
+  "node_modules",
+  ".git",
+  "dist",
+  ".wrangler",
+  "test",
+  "tests"
+]);
+async function copyWorkerDir(sourceDir, targetDir, mainFile) {
+  const copied = [];
+  const renamedIndex = [];
+  const entries = await readdir(sourceDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const from = join2(sourceDir, entry.name);
+    const to = join2(targetDir, entry.name);
+    if (SKIP_COPY_NAMES.has(entry.name)) continue;
+    if (entry.isDirectory()) {
+      await mkdir3(to, { recursive: true });
+      const sub = await copyWorkerDir(from, to, "");
+      copied.push(...sub.copied);
+      renamedIndex.push(...sub.renamedIndex);
+      continue;
+    }
+    if (from === mainFile) continue;
+    if (entry.name === "index.ts") {
+      await copyFile(from, join2(targetDir, "_index.ts"));
+      renamedIndex.push("_index.ts");
+      continue;
+    }
+    await copyFile(from, to);
+    copied.push(relative(targetDir, to));
+  }
+  return { copied, renamedIndex };
+}
+async function readDevVars(sourceDir) {
+  try {
+    const text = await readFile2(join2(sourceDir, ".dev.vars"), "utf8");
+    const vars = {};
+    for (const line of text.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (trimmed === "" || trimmed.startsWith("#")) continue;
+      const eq = trimmed.indexOf("=");
+      if (eq <= 0) continue;
+      const key = trimmed.slice(0, eq).trim();
+      vars[key] = trimmed.slice(eq + 1).trim().replace(/^"|"$/g, "");
+    }
+    return vars;
+  } catch {
+    return {};
+  }
+}
+async function copyAssetsToWeb(sourceDir, assetsDir, outDir) {
+  const files = [];
+  const from = resolve2(sourceDir, assetsDir);
+  const target = join2(outDir, "web");
+  await mkdir3(target, { recursive: true });
+  const entries = await readdir(from, { withFileTypes: true });
+  for (const entry of entries) {
+    const src = join2(from, entry.name);
+    const dst = join2(target, entry.name);
+    if (entry.isDirectory()) {
+      await mkdir3(dst, { recursive: true });
+      const sub = await copyAssetsToWeb(src, ".", outDir);
+      files.push(...sub);
+      continue;
+    }
+    await copyFile(src, dst);
+    files.push(relative(outDir, dst));
+  }
+  return files;
+}
+function bindingsFromWrangler(config) {
+  const cfBindings = {};
+  const kv = config.kv_namespaces?.map((b) => ({
+    name: b.binding ?? "",
+    ...b.id === void 0 ? {} : { namespace: b.id }
+  }));
+  if (kv !== void 0 && kv.length > 0) cfBindings.kv = kv;
+  const d1 = config.d1_databases?.map((b) => ({
+    name: b.binding ?? "",
+    ...b.database_name === void 0 ? b.database_id === void 0 ? {} : { database: b.database_id } : { database: b.database_name }
+  }));
+  if (d1 !== void 0 && d1.length > 0) cfBindings.d1 = d1;
+  const r2 = config.r2_buckets?.map((b) => ({
+    name: b.binding ?? "",
+    ...b.bucket_name === void 0 ? {} : { bucket: b.bucket_name }
+  }));
+  if (r2 !== void 0 && r2.length > 0) cfBindings.r2 = r2;
+  const isEmpty = cfBindings.kv === void 0 && cfBindings.d1 === void 0 && cfBindings.r2 === void 0;
+  return {
+    cfBindings: isEmpty ? void 0 : cfBindings,
+    environment: config.vars
+  };
+}
+function collectDurableObjectBindings(config) {
+  return (config.durable_objects?.bindings ?? []).filter((b) => b.class_name !== void 0).map((b) => ({ name: b.name, className: b.class_name }));
+}
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function findClosingBrace(text, openIdx) {
+  let depth = 0;
+  let i = openIdx;
+  let quote = null;
+  while (i < text.length) {
+    const ch = text[i];
+    if (quote !== null) {
+      if (ch === "\\") {
+        i += 2;
+        continue;
+      }
+      if (ch === quote) quote = null;
+      i += 1;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      quote = ch;
+      i += 1;
+      continue;
+    }
+    if (ch === "/" && text[i + 1] === "/") {
+      const nl = text.indexOf("\n", i);
+      i = nl === -1 ? text.length : nl + 1;
+      continue;
+    }
+    if (ch === "/" && text[i + 1] === "*") {
+      const end = text.indexOf("*/", i + 2);
+      i = end === -1 ? text.length : end + 2;
+      continue;
+    }
+    if (ch === "{") depth += 1;
+    else if (ch === "}") {
+      depth -= 1;
+      if (depth === 0) return i;
+    }
+    i += 1;
+  }
+  return -1;
+}
+function stripDurableObjectClasses(workerText, classNames) {
+  let text = workerText;
+  const removed = [];
+  for (const className of classNames) {
+    const pattern = new RegExp(
+      `export\\s+class\\s+${escapeRegExp(className)}\\s+extends\\s+DurableObject`
+    );
+    const match = pattern.exec(text);
+    if (match === null) continue;
+    const startLine = text.lastIndexOf("\n", match.index) + 1;
+    const braceIdx = text.indexOf("{", match.index);
+    if (braceIdx === -1) continue;
+    const endIdx = findClosingBrace(text, braceIdx);
+    if (endIdx === -1) continue;
+    let removeEnd = endIdx + 1;
+    if (text[removeEnd] === "\n") removeEnd += 1;
+    removed.push({ className, source: text.slice(startLine, endIdx + 1).trim() });
+    text = text.slice(0, startLine) + text.slice(removeEnd);
+  }
+  text = text.replace(/^[ \t]*import[ \t][^\n]*from[ \t]['"]cloudflare:workers['"][^\n]*\n/gm, "");
+  return { text, removed };
+}
+function extractMethodNames(source) {
+  const names = [];
+  const re = /(?:^|\n)[ \t]*(?:async[ \t]+)?([A-Za-z_$][\w$]*)[ \t]*\(/g;
+  const CONTROL = /* @__PURE__ */ new Set(["if", "for", "while", "switch", "catch", "function", "with"]);
+  let m;
+  while ((m = re.exec(source)) !== null) {
+    const name = m[1];
+    if (CONTROL.has(name) || name === "constructor" || name === "super" || names.includes(name)) {
+      continue;
+    }
+    names.push(name);
+  }
+  return names;
+}
+function renderStateObjectDeclaration(bindings, removed) {
+  const lines = [
+    "/**",
+    " * \u7531 `adep import cf` \u751F\u6210\uFF08CF-039\uFF09\uFF1Awrangler [[durable_objects.bindings]] \u2192 \u72B6\u6001\u5BF9\u8C61\u58F0\u660E\u3002",
+    " * \u539F DurableObject \u7C7B\u6E90\u7801\u4FDD\u7559\u5728 durable-objects/<ClassName>.ts\uFF08AI \u8FC1\u79FB\u53C2\u8003\uFF09\u3002",
+    " * \u8C03\u7528\u9762\uFF1AHTTP POST /api/state/<Type>/<id>/<method> \xB7 MCP state.invoke \xB7 WS state:<Type>:<id>",
+    " */",
+    "import { StateObject } from '@adep/runtime/state-objects'",
+    ""
+  ];
+  for (const { className } of bindings) {
+    const removedSrc = removed.find((r) => r.className === className);
+    const methods = extractMethodNames(removedSrc?.source ?? "");
+    lines.push("/**", ` * \u8FC1\u79FB\u81EA DurableObject \u7C7B \`${className}\`\u3002`);
+    if (methods.length > 0) {
+      lines.push(
+        ` * \u539F\u65B9\u6CD5\uFF08AI \u8FC1\u79FB\uFF1A\u628A fetch \u5165\u53E3\u8DEF\u7531\u62C6\u6210 StateObject \u65B9\u6CD5\uFF09\uFF1A${methods.join(", ")}`
+      );
+    } else {
+      lines.push(` * \u539F\u7C7B\u6E90\u7801\u89C1 durable-objects/${className}.ts\u3002`);
+    }
+    lines.push(" */");
+    lines.push(`export class ${className} extends StateObject<Record<string, unknown>> {`);
+    lines.push(`  static typeName = '${className}'`);
+    lines.push("");
+    lines.push("  protected initialState(): Record<string, unknown> {");
+    lines.push(
+      "    // TODO\uFF1A\u4ECE\u539F DurableObject \u7684 this.state \u8FC1\u79FB\u521D\u59CB\u72B6\u6001\uFF08\u89C1 durable-objects/\uFF09\u3002"
+    );
+    lines.push("    return {}");
+    lines.push("  }");
+    lines.push("}");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function unsupportedFromWrangler(config) {
+  const out = [];
+  const raw = config.raw;
+  if (raw.queues !== void 0) {
+    out.push("queues\uFF08\u961F\u5217\uFF09\u2192 \u66FF\u4EE3\uFF1Acron \u89E6\u53D1\u5668 + \u6570\u636E\u5E93\u4EFB\u52A1\u8868\u8F6E\u8BE2");
+  }
+  if (raw.email_bindings !== void 0) {
+    out.push("email_bindings \u2192 \u66FF\u4EE3\uFF1A\u7B2C\u4E09\u65B9\u90AE\u4EF6 API\uFF08\u5982 Resend/Mailgun\uFF09");
+  }
+  if (raw.services !== void 0) {
+    out.push("services\uFF08service bindings\uFF09\u2192 \u66FF\u4EE3\uFF1A\u51FD\u6570\u95F4\u7ECF HTTP \u6216\u4E91\u6570\u636E\u5E93\u5171\u4EAB\u8C03\u7528");
+  }
+  if (raw.assets === void 0 && raw.site === void 0 && raw["_ssr"] !== void 0) {
+    out.push("SSR\uFF08\u524D\u7AEF\u6E32\u67D3\uFF09\u2192 adep web/ \u4E3A\u9759\u6001\u6258\u7BA1\uFF0CSSR \u9700\u81EA\u884C\u5728\u51FD\u6570\u5185\u5B9E\u73B0");
+  }
+  return out;
+}
+function renderFunctionEntry(workerImport, bindings) {
+  const bindingsLine = bindings === void 0 ? "" : `, { bindings: ${JSON.stringify(bindings, null, 2).replace(/\n/g, "\n  ")} }`;
+  return `/**
+ * \u7531 \`adep import cf\` \u751F\u6210\uFF08CF-015\uFF09\uFF1A\u628A Cloudflare Workers \u6A21\u5757\u683C\u5F0F\u5305\u88C5\u4E3A adep \u4E91\u51FD\u6570\u3002
+ * \u7ED1\u5B9A\u58F0\u660E\u6765\u81EA wrangler.toml\uFF1B\u672A\u652F\u6301\u9879\u4E0E\u66FF\u4EE3\u6A21\u5F0F\u89C1 MIGRATION.md\u3002
+ *
+ * \u6CE8\u610F\uFF1Aadep \u6C99\u7BB1\u628A \`import x from './x'\` \u8F6C\u8BD1\u4E3A \`require('./x')\`\uFF08\u8FD4\u56DE\u6A21\u5757\u5BF9\u8C61\uFF09\uFF0C
+ * \u56E0\u6B64\u8FD9\u91CC\u5BF9 default \u4E0E\u5177\u540D\u4E24\u79CD worker \u5BFC\u51FA\u5F62\u6001\u90FD\u505A\u517C\u5BB9\u3002
+ */
+import { createAdepFunction } from '@adep/cf-compat'
+import workerModule from './${workerImport}'
+
+const worker = (workerModule as { default?: unknown }).default ?? workerModule
+
+export default createAdepFunction(worker as never${bindingsLine})
+`;
+}
+function renderMigrationReport(config, result) {
+  const lines = [
+    `# \u8FC1\u79FB\u62A5\u544A\uFF1A${config.name ?? "worker"}\uFF08\u7531 adep import cf \u751F\u6210\uFF09`,
+    "",
+    "## \u6620\u5C04\u6E05\u5355",
+    "",
+    `- worker\uFF1A\`${config.main ?? "(\u65E0 main)"}\` \u2192 \`functions/${result.workerName}/\``,
+    `- vars\uFF1A${result.mapping.vars} \u4E2A \u2192 adep.config.ts environment`,
+    result.mapping.secretsFromDevVars ? "- secrets\uFF08.dev.vars\uFF09\u2192 environment\uFF08\u5EFA\u8BAE\u4E0A\u7EBF\u524D\u8FC1\u5230\u5E73\u53F0 env \u7BA1\u7406\uFF09" : "",
+    `- KV \u7ED1\u5B9A\uFF1A${result.mapping.kv} \u4E2A`,
+    `- D1 \u7ED1\u5B9A\uFF1A${result.mapping.d1} \u4E2A`,
+    `- R2 \u7ED1\u5B9A\uFF1A${result.mapping.r2} \u4E2A`,
+    result.mapping.crons.length > 0 ? `- cron \u89E6\u53D1\u5668\uFF1A${result.mapping.crons.join(", ")}\uFF08adep \u4FA7\u5728\u63A7\u5236\u53F0/MCP \u914D\u7F6E\u89E6\u53D1\u5668\uFF1BcreateAdepFunction \u5DF2\u652F\u6301 scheduled \u6D3E\u53D1\uFF09` : "",
+    result.mapping.assets ? "- \u9759\u6001\u8D44\u6E90 assets \u2192 web/\uFF08adep \u524D\u7AEF\u6258\u7BA1\uFF09" : "",
+    result.mapping.dos > 0 ? `- Durable Objects \u7ED1\u5B9A\uFF1A${result.mapping.dos} \u4E2A\uFF08class_name \u2192 functions/${result.workerName}/state-objects.ts \u58F0\u660E\u9AA8\u67B6\uFF1B\u539F\u7C7B\u4FDD\u7559 durable-objects/\uFF09` : "",
+    "",
+    "## \u672A\u652F\u6301\u9879\u4E0E\u66FF\u4EE3\u6A21\u5F0F",
+    "",
+    ...result.unsupported.length > 0 ? result.unsupported.map((item) => `- ${item}`) : ["- \uFF08\u65E0\uFF09"],
+    "",
+    "## AI \u8FC1\u79FB\u63D0\u793A",
+    "",
+    "- `ctx`\uFF08adep\uFF09\u2194 Workers `Request`\uFF1A`ctx.req` \u5373 Request \u5F62\u72B6\uFF0C`ctx.body`/`ctx.query`/`ctx.headers` \u5DF2\u63D0\u4F9B",
+    "- `env.XXX` \u7ED1\u5B9A\u5728\u51FD\u6570\u5185\u7ECF cfEnv \u7EC4\u88C5\uFF08vars=process.env\u3001KV/D1/R2 \u4E3A shim \u5B9E\u4F8B\uFF09",
+    "- Response \u8FD4\u56DE\u7ECF `__adepHttp` \u4FE1\u5C01\uFF0Cstatus/headers/body \u5168\u4FDD\u7559",
+    "- \u591A\u6587\u4EF6 worker\uFF1A\u4F9D\u8D56\u6A21\u5757\u5DF2\u968F\u76EE\u5F55\u590D\u5236\u8FDB\u51FD\u6570\u76EE\u5F55\uFF0C\u4FDD\u6301\u76F8\u5BF9 import \u5373\u53EF",
+    "- \u4E91\u51FD\u6570\u9ED8\u8BA4\u540C\u6B65\u6267\u884C\u6A21\u578B\uFF1A`ctx.waitUntil` \u4E3A\u7A7A\u5B9E\u73B0\uFF08v1\uFF09",
+    "",
+    "## Durable Objects \u8FC1\u79FB\u8981\u70B9\uFF08CF-039\uFF09",
+    "",
+    "- `this.state`\uFF08DO storage\uFF09\u2192 StateObject \u76F4\u63A5\u8BFB\u5199 `this.state` \u5B57\u6BB5 + `await this.flush()` \u6301\u4E45\u5316",
+    "- `this.ctx.storage.setAlarm(t)` \u2192 `this.setAlarm(t)`\uFF1B`this.ctx.storage.getAlarm()` \u2192 alarm \u67E5\u8BE2\u9762\uFF08CF-037\uFF09",
+    "- `this.ctx.waitUntil(p)` \u2192 adep \u540C\u6B65\u6267\u884C\u6A21\u578B\uFF0C\u7A7A\u5B9E\u73B0\uFF08v1\uFF09",
+    "- `stub.fetch(req)` \u8C03\u7528\u65B9 \u2192 `fetch('/api/state/<ClassName>/<id>/<path>')` \u6216 WS `state:<ClassName>:<id>` \u6216 MCP `state.invoke`",
+    "- `env.<BINDING>.idFromName(name)` \u2192 \u5BF9\u8C61 id \u5373\u8C03\u7528\u8DEF\u5F84\u7684 `<id>` \u6BB5",
+    "- `[[migrations]]` \u4E3A CF \u7AEF DO \u7248\u672C\u7BA1\u7406\uFF0Cadep \u65E0\u5BF9\u5E94\u6982\u5FF5\uFF08\u5FFD\u7565\uFF09"
+  ];
+  return `${lines.filter((line) => line !== "").join("\n")}
+`;
+}
+function renderImportPackageJson(name) {
+  return `${JSON.stringify(
+    {
+      name,
+      private: true,
+      scripts: {
+        dev: "adep dev",
+        serve: "adep serve",
+        deploy: "adep deploy",
+        doctor: "adep doctor"
+      },
+      dependencies: {
+        "@adep/cli": "latest",
+        "@adep/cf-compat": "latest"
+      }
+    },
+    null,
+    2
+  )}
+`;
+}
+async function importCfProject(cwd, sourceDir, options = {}) {
+  let tomlText;
+  try {
+    tomlText = await readFile2(join2(sourceDir, "wrangler.toml"), "utf8");
+  } catch {
+    throw new ImportCfError(
+      "NO_WRANGLER",
+      `\u627E\u4E0D\u5230 ${join2(sourceDir, "wrangler.toml")}\uFF1A\u9700\u5728 Cloudflare \u9879\u76EE\u6839\u6267\u884C\u5BFC\u5165`
+    );
+  }
+  let config;
+  try {
+    config = parseWranglerToml(tomlText);
+  } catch (error) {
+    throw new ImportCfError(
+      "TOML_PARSE",
+      `wrangler.toml \u89E3\u6790\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const workerName = slugify(config.name ?? basename(sourceDir), "worker");
+  const outDir = resolve2(cwd, options.out ?? `imported-${workerName}`);
+  try {
+    await stat3(outDir);
+    throw new ImportCfError("DIR_EXISTS", `\u8F93\u51FA\u76EE\u5F55 ${outDir} \u5DF2\u5B58\u5728\uFF1A\u8BF7\u6362 --out \u6216\u5148\u5220\u9664`);
+  } catch (error) {
+    if (error instanceof ImportCfError) throw error;
+  }
+  const { cfBindings, environment } = bindingsFromWrangler(config);
+  const devVars = await readDevVars(sourceDir);
+  const mergedEnv = environment === void 0 && Object.keys(devVars).length === 0 ? void 0 : { ...environment, ...devVars };
+  const files = [];
+  const warnings = [];
+  const adepConfig = {
+    name: workerName,
+    functionsDir: "functions",
+    functions_prefix: "/api",
+    ...mergedEnv === void 0 ? {} : { environment: mergedEnv },
+    ...cfBindings === void 0 ? {} : { cfBindings }
+  };
+  const configText = renderAdepConfig(adepConfig, {
+    header: "// \u7531 adep import cf \u751F\u6210\uFF08CF-015\uFF09\uFF1A\u7ED1\u5B9A\u58F0\u660E\u4E0E wrangler.toml \u5BF9\u5E94"
+  });
+  await mkdir3(outDir, { recursive: true });
+  await writeFile2(join2(outDir, "adep.config.ts"), configText, "utf8");
+  files.push("adep.config.ts");
+  await writeFile2(join2(outDir, "package.json"), renderImportPackageJson(workerName), "utf8");
+  files.push("package.json");
+  let mainCopied = false;
+  if (config.main !== void 0) {
+    const mainAbs = resolve2(sourceDir, config.main);
+    let mainStat;
+    try {
+      mainStat = await stat3(mainAbs);
+    } catch {
+      throw new ImportCfError("MAIN_MISSING", `main \u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${config.main}`);
+    }
+    if (!mainStat.isFile()) {
+      throw new ImportCfError("MAIN_NOT_FILE", `main \u4E0D\u662F\u6587\u4EF6\uFF1A${config.main}`);
+    }
+    const fnDir = join2(outDir, "functions", workerName);
+    await mkdir3(fnDir, { recursive: true });
+    await copyFile(mainAbs, join2(fnDir, "worker.ts"));
+    files.push(`functions/${workerName}/worker.ts`);
+    mainCopied = true;
+    const mainDir = dirname3(mainAbs);
+    const { copied, renamedIndex } = await copyWorkerDir(mainDir, fnDir, mainAbs);
+    if (renamedIndex.length > 0) {
+      warnings.push(
+        `\u51FD\u6570\u76EE\u5F55\u539F\u6709 index.ts \u5DF2\u6539\u540D\u4E3A _index.ts\uFF08\u5165\u53E3\u88AB\u5305\u88C5\u5360\u7528\uFF09\uFF1A${renamedIndex.join(", ")}`
+      );
+    }
+    files.push(...copied.map((f) => `functions/${workerName}/${f}`));
+    if (copied.length > 0) {
+      warnings.push(`\u5DF2\u590D\u5236\u540C\u76EE\u5F55\u4F9D\u8D56\u6A21\u5757 ${copied.length} \u4E2A\uFF08\u4FDD\u6301\u76F8\u5BF9 import\uFF09`);
+    }
+    await writeFile2(join2(fnDir, "index.ts"), renderFunctionEntry("worker", cfBindings), "utf8");
+    files.push(`functions/${workerName}/index.ts`);
+  }
+  let dosMigrated = 0;
+  if (mainCopied) {
+    const doBindings = collectDurableObjectBindings(config);
+    const noClassName = (config.durable_objects?.bindings ?? []).filter(
+      (b) => b.class_name === void 0
+    );
+    if (noClassName.length > 0) {
+      warnings.push(
+        `durable_objects \u7ED1\u5B9A\u7F3A\u5C11 class_name\uFF08\u65E0\u6CD5\u751F\u6210\u58F0\u660E\uFF09\uFF1A${noClassName.map((b) => b.name).join(", ")}`
+      );
+    }
+    if (doBindings.length > 0) {
+      const fnDir = join2(outDir, "functions", workerName);
+      const workerPath = join2(fnDir, "worker.ts");
+      const workerText = await readFile2(workerPath, "utf8");
+      const { text: stripped, removed } = stripDurableObjectClasses(
+        workerText,
+        doBindings.map((b) => b.className)
+      );
+      await writeFile2(workerPath, stripped, "utf8");
+      if (removed.length > 0) {
+        await mkdir3(join2(fnDir, "durable-objects"), { recursive: true });
+        await Promise.all(
+          removed.map(async (r) => {
+            await writeFile2(
+              join2(fnDir, "durable-objects", `${r.className}.ts`),
+              `${r.source}
+`,
+              "utf8"
+            );
+            files.push(`functions/${workerName}/durable-objects/${r.className}.ts`);
+          })
+        );
+      }
+      if (removed.length > 0) {
+        await writeFile2(
+          join2(fnDir, "state-objects.ts"),
+          renderStateObjectDeclaration(doBindings, removed),
+          "utf8"
+        );
+        files.push(`functions/${workerName}/state-objects.ts`);
+        dosMigrated = removed.length;
+      }
+      if (removed.length < doBindings.length) {
+        warnings.push(
+          `\u4EE5\u4E0B DO \u7C7B\u672A\u5728 main \u6587\u4EF6\u4E2D\u627E\u5230\uFF08\u53EF\u80FD\u5728\u5176\u4ED6\u6A21\u5757\uFF0C\u9700\u624B\u52A8\u8FC1\u79FB\uFF09\uFF1A${doBindings.filter((b) => !removed.some((r) => r.className === b.className)).map((b) => b.className).join(", ")}`
+        );
+      }
+    }
+  }
+  let assetsCopied = false;
+  const assetsDir = config.assets?.directory ?? config.site?.bucket;
+  if (assetsDir !== void 0) {
+    try {
+      const copied = await copyAssetsToWeb(sourceDir, assetsDir, outDir);
+      assetsCopied = true;
+      files.push(...copied);
+    } catch (error) {
+      warnings.push(
+        `\u9759\u6001\u8D44\u6E90\u76EE\u5F55 ${assetsDir} \u590D\u5236\u5931\u8D25\uFF08${error instanceof Error ? error.message : String(error)}\uFF09\uFF0C\u8DF3\u8FC7`
+      );
+    }
+  }
+  const mapping = {
+    vars: Object.keys(mergedEnv ?? {}).length,
+    kv: config.kv_namespaces?.length ?? 0,
+    d1: config.d1_databases?.length ?? 0,
+    r2: config.r2_buckets?.length ?? 0,
+    dos: dosMigrated,
+    crons: config.triggers?.crons ?? [],
+    assets: assetsCopied,
+    secretsFromDevVars: Object.keys(devVars).length > 0
+  };
+  const unsupported = unsupportedFromWrangler(config);
+  const migration = renderMigrationReport(config, {
+    outDir,
+    workerName,
+    mapping,
+    unsupported,
+    warnings
+  });
+  await writeFile2(join2(outDir, "MIGRATION.md"), migration, "utf8");
+  files.push("MIGRATION.md");
+  if (!mainCopied) {
+    warnings.push("wrangler.toml \u672A\u58F0\u660E main\uFF1A\u672A\u751F\u6210\u51FD\u6570\uFF0C\u4EC5\u751F\u6210\u914D\u7F6E\u4E0E\u62A5\u544A");
+  }
+  return { outDir, workerName, mapping, unsupported, files, warnings };
+}
+
+// packages/cli/src/commands/import.ts
+function registerImport(program2, ctx) {
+  const importCmd = program2.command("import").description("\u8FC1\u79FB\u5DE5\u5177\uFF1A\u4ECE Cloudflare / \u5176\u4ED6\u5E73\u53F0\u5BFC\u5165\u9879\u76EE\uFF08\u5F53\u524D\u652F\u6301 cf\uFF09");
+  const cfCmd = importCmd.command("cf").description("\u4ECE Cloudflare Workers \u9879\u76EE\u751F\u6210 adep \u9AA8\u67B6\uFF08wrangler.toml \u2192 \u51FD\u6570 + \u7ED1\u5B9A\u58F0\u660E\uFF09");
+  cfCmd.argument("<sourceDir>", "Cloudflare \u9879\u76EE\u6839\uFF08\u542B wrangler.toml\uFF09").option("-o, --out <dir>", "\u8F93\u51FA\u76EE\u5F55\uFF08\u7F3A\u7701 cwd/imported-<workerName>\uFF09").action(async (sourceDir, flags) => {
+    const command = ctx.io("import cf");
+    await command.run(async () => {
+      const options = {};
+      if (flags.out !== void 0) options.out = flags.out;
+      const result = await importCfProject(ctx.cwd, sourceDir, options);
+      command.ok(
+        {
+          outDir: result.outDir,
+          workerName: result.workerName,
+          mapping: result.mapping,
+          unsupported: result.unsupported,
+          warnings: result.warnings,
+          files: result.files
+        },
+        (data) => {
+          const d = data;
+          const lines = [
+            `\u5DF2\u5BFC\u5165 ${d.workerName} \u2192 ${d.outDir}`,
+            `\u6620\u5C04\uFF1Avars ${d.mapping.vars} \xB7 KV ${d.mapping.kv} \xB7 D1 ${d.mapping.d1} \xB7 R2 ${d.mapping.r2}` + (d.mapping.crons.length > 0 ? ` \xB7 cron ${d.mapping.crons.join(",")}` : "") + (d.mapping.assets ? " \xB7 assets\u2192web/" : ""),
+            ...d.unsupported.length > 0 ? [`\u672A\u652F\u6301\uFF1A${d.unsupported.length} \u9879\uFF08\u8BE6\u89C1 MIGRATION.md\uFF09`, ...d.unsupported] : [],
+            ...d.warnings.map((w) => `\u63D0\u793A\uFF1A${w}`),
+            `\u8FC1\u79FB\u62A5\u544A\uFF1A${d.outDir}/MIGRATION.md`
+          ];
+          return lines.join("\n");
+        }
+      );
+    });
+  });
+}
+
 // packages/cli/src/commands/dev.ts
 function registerDevServers(program2, ctx) {
   program2.command("dev").description("\u672C\u5730\u8C03\u8BD5\uFF1A\u76D1\u542C functions/ \u70ED\u91CD\u8F7D\uFF0Chttp://localhost:<port>/<fnName>").option("-p, --port <port>", "\u76D1\u542C\u7AEF\u53E3\uFF08\u7F3A\u7701 8787\uFF09", "8787").action(async (flags) => {
@@ -6205,9 +8445,9 @@ function registerDevServers(program2, ctx) {
 init_auth();
 init_client();
 init_deploy();
-import { resolve as resolve6 } from "node:path";
+import { resolve as resolve7 } from "node:path";
 async function resolveProjectId(client, cwd, slug) {
-  const resolvedSlug = await resolveSlug(resolve6(cwd), slug);
+  const resolvedSlug = await resolveSlug(resolve7(cwd), slug);
   const listed = await client.request("/api/v1/projects", {}, "PROJECT_LIST_FAILED");
   const match = listed.projects.find((project2) => project2.slug === resolvedSlug);
   if (match === void 0) {
@@ -6858,7 +9098,7 @@ function registerHosting(program2, ctx) {
 }
 
 // packages/cli/src/cli.ts
-var requireJson2 = createRequire2(import.meta.url);
+var requireJson2 = createRequire3(import.meta.url);
 var APP_VERSION = requireJson2("../package.json").version;
 function buildProgram(options = {}) {
   const output = options.output ?? ((line) => process.stdout.write(`${line}
@@ -6871,6 +9111,7 @@ function buildProgram(options = {}) {
   const jsonMode = () => program2.opts()["json"] === true;
   const ctx = createCliContext({ output, paths, cwd, json: jsonMode });
   registerInit(program2, ctx);
+  registerImport(program2, ctx);
   registerDevServers(program2, ctx);
   registerPublish(program2, ctx);
   registerExport(program2, ctx);