@adep/cli 0.0.1

package/dist/index.js

@@ -0,0 +1,4411 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// packages/cli/src/credentials.ts
+import { mkdir, open, readFile, rm, stat } from "node:fs/promises";
+import { dirname } from "node:path";
+async function saveCredentials(paths, credentials) {
+  await mkdir(dirname(paths.credentialsFile), { recursive: true });
+  const handle = await open(paths.credentialsFile, "w", 384);
+  try {
+    await handle.writeFile(JSON.stringify(credentials, null, 2));
+  } finally {
+    await handle.close();
+  }
+  await chmodStrict(paths.credentialsFile);
+}
+async function chmodStrict(file) {
+  const info = await stat(file);
+  const mode = info.mode & 511;
+  if (mode !== 384) {
+    const { chmod } = await import("node:fs/promises");
+    await chmod(file, 384);
+  }
+}
+async function loadCredentials(paths) {
+  try {
+    const raw = await readFile(paths.credentialsFile, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed["server"] !== "string" || typeof parsed["email"] !== "string" || typeof parsed["encodedToken"] !== "string") {
+      return null;
+    }
+    return {
+      server: parsed["server"],
+      email: parsed["email"],
+      encodedToken: parsed["encodedToken"]
+    };
+  } catch {
+    return null;
+  }
+}
+async function clearCredentials(paths) {
+  await rm(paths.credentialsFile, { force: true });
+}
+function encodeToken(token) {
+  return Buffer.from(token, "utf8").toString("base64");
+}
+function decodeToken(encoded) {
+  return Buffer.from(encoded, "base64").toString("utf8");
+}
+var init_credentials = __esm({
+  "packages/cli/src/credentials.ts"() {
+    "use strict";
+  }
+});
+
+// packages/cli/src/auth.ts
+function sessionCookieOf(setCookie) {
+  const line = setCookie.find(
+    (entry) => entry.startsWith("better-auth.session_token=") && !/max-age=0/i.test(entry)
+  );
+  if (line === void 0) {
+    throw new CliError("LOGIN_FAILED", "\u767B\u5F55\u6210\u529F\u4F46\u672A\u8FD4\u56DE\u4F1A\u8BDD token\uFF0C\u8BF7\u68C0\u67E5\u5E73\u53F0\u7248\u672C");
+  }
+  return line.split(";")[0];
+}
+async function login(paths, input) {
+  const server = input.server.replace(/\/+$/, "");
+  let response;
+  try {
+    response = await fetch(`${server}/api/auth/sign-in/email`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ email: input.email, password: input.password })
+    });
+  } catch (error) {
+    throw new CliError(
+      "SERVER_UNREACHABLE",
+      `\u65E0\u6CD5\u8FDE\u63A5\u5E73\u53F0 ${server}\uFF1A${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (response.status !== 200) {
+    throw new CliError("LOGIN_FAILED", "\u767B\u5F55\u5931\u8D25\uFF1A\u90AE\u7BB1\u6216\u5BC6\u7801\u4E0D\u6B63\u786E\uFF08\u6216\u8BE5\u8D26\u53F7\u672A\u6CE8\u518C\uFF09");
+  }
+  const token = sessionCookieOf(response.headers.getSetCookie());
+  await saveCredentials(paths, {
+    server,
+    email: input.email,
+    encodedToken: encodeToken(token)
+  });
+  return { email: input.email };
+}
+async function whoami(paths) {
+  const credentials = await loadCredentials(paths);
+  if (credentials === null) {
+    throw new CliError("NOT_LOGGED_IN", "\u672A\u767B\u5F55\uFF1A\u8BF7\u5148\u6267\u884C adep login");
+  }
+  const response = await fetch(`${credentials.server}/api/auth/get-session`, {
+    headers: { cookie: `better-auth.session_token=${decodeToken(credentials.encodedToken)}` }
+  });
+  if (response.status !== 200) {
+    throw new CliError("SESSION_EXPIRED", "\u4F1A\u8BDD\u5DF2\u5931\u6548\uFF1A\u8BF7\u91CD\u65B0\u6267\u884C adep login");
+  }
+  const body = await response.json();
+  const email = body?.user?.email;
+  if (typeof email !== "string") {
+    throw new CliError("SESSION_EXPIRED", "\u4F1A\u8BDD\u5DF2\u5931\u6548\uFF1A\u8BF7\u91CD\u65B0\u6267\u884C adep login");
+  }
+  return { server: credentials.server, email };
+}
+async function logout(paths) {
+  const credentials = await loadCredentials(paths);
+  if (credentials !== null) {
+    try {
+      await fetch(`${credentials.server}/api/auth/sign-out`, {
+        method: "POST",
+        headers: { cookie: `better-auth.session_token=${decodeToken(credentials.encodedToken)}` }
+      });
+    } catch {
+    }
+    await clearCredentials(paths);
+  }
+}
+var CliError;
+var init_auth = __esm({
+  "packages/cli/src/auth.ts"() {
+    "use strict";
+    init_credentials();
+    CliError = class extends Error {
+      constructor(code, message, exitCode = 1) {
+        super(message);
+        this.code = code;
+        this.exitCode = exitCode;
+        this.name = "CliError";
+      }
+    };
+  }
+});
+
+// packages/cli/src/widget/build.ts
+import { createHash } from "node:crypto";
+import { join as join2, resolve as resolve2 } from "node:path";
+import { build as esbuildBuild } from "esbuild";
+async function buildWidget(options) {
+  const root = resolve2(options.cwd);
+  const entry = join2(root, options.entry ?? "src/index.ts");
+  const result = await esbuildBuild({
+    entryPoints: [entry],
+    bundle: true,
+    write: false,
+    format: "esm",
+    target: ["es2020"],
+    logLevel: "error",
+    loader: { ".ts": "ts", ".tsx": "tsx", ".js": "js", ".jsx": "jsx" },
+    ...options.framework === "react" ? { jsx: "automatic", jsxImportSource: "react" } : {}
+  });
+  const text = result.outputFiles?.[0]?.text ?? "";
+  if (text.length === 0) {
+    throw new WidgetError("EMPTY_BUILD", "\u6784\u5EFA\u4EA7\u7269\u4E3A\u7A7A\uFF1A\u8BF7\u68C0\u67E5 widget \u5165\u53E3\u662F\u5426\u6B63\u786E");
+  }
+  const hash = createHash("sha256").update(text).digest("hex");
+  return { text, hash };
+}
+var WidgetError;
+var init_build = __esm({
+  "packages/cli/src/widget/build.ts"() {
+    "use strict";
+    WidgetError = class extends Error {
+      constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "WidgetError";
+      }
+    };
+  }
+});
+
+// packages/cli/src/widget/templates.ts
+function vue3Files(name) {
+  return {
+    ...TS_BASE(),
+    "manifest.json": MANIFEST(name, "vue3"),
+    "package.json": `{
+  "name": "${name}",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "dev": "adep widget dev",
+    "widget:publish": "adep widget publish -p"
+  },
+  "dependencies": {
+    "vue": "^3.5.0",
+    "@adep/types": "workspace:*"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.0"
+  }
+}
+`,
+    "src/theme.css": THEME_CSS,
+    "src/App.ts": `import { defineComponent, h } from 'vue'
+
+/** \u7EC4\u4EF6 props \u4E0E manifest.json \u7684 props schema \u5BF9\u9F50\uFF08contracts/ \u6821\u9A8C\u5B57\u6BB5\u5B50\u96C6\uFF09\u3002 */
+export const App = defineComponent({
+  name: 'HelloVue',
+  props: {
+    title: { type: String, default: 'Hello' },
+  },
+  setup(props) {
+    return () =>
+      h('div', { style: { padding: 'var(--adep-space-4)' } }, [
+        h('h2', { style: { color: 'var(--adep-color-accent)' } }, props.title),
+        h(
+          'p',
+          { style: { color: 'var(--adep-color-text-secondary)' } },
+          'Vue 3 \u6E32\u67D3\u51FD\u6570\u7EC4\u4EF6\u3002\u4E3B\u9898\u53D8\u91CF\u4E0E\u9274\u6743 token \u7531\u5BBF\u4E3B\u6CE8\u5165\u3002'
+        ),
+      ])
+  },
+})
+`,
+    "src/index.ts": `// Widget \u8FD0\u884C\u65F6\u5165\u53E3\uFF08FE-002\uFF09\u3002\u5BFC\u51FA HarnessWidgetRuntime \u4E09\u4EF6\u5957\uFF1A
+// __harness / mount(host, ctx) / unmount(host)\u3002
+// \u7EC4\u4EF6\u4EE5\u6E32\u67D3\u51FD\u6570\u7F16\u5199\uFF08\u975E SFC\uFF09\uFF0Cesbuild \u514D\u63D2\u4EF6\u76F4\u7F16\uFF08M3 MVP\uFF1B.vue SFC \u8D70 Vite \u5C5E\u4E8C\u671F\uFF09\u3002
+import { createApp, type App as VueApp } from 'vue'
+import type { HarnessMountHost, HarnessWidgetContext } from '@adep/types'
+import { App } from './App'
+
+// \u5BBF\u4E3B \u2192 \u6302\u8F7D\u7684 app \u5F15\u7528\uFF0Cunmount \u65F6\u7528\u5B8C\u91CA\u653E\uFF08WeakMap \u4E0D\u963B\u6B62\u5BBF\u4E3B\u56DE\u6536\uFF09\u3002
+const mounted = new WeakMap<object, { app: VueApp; root: HTMLElement }>()
+
+export const __harness = true as const
+
+export function mount(host: HarnessMountHost, ctx: HarnessWidgetContext): void {
+  const root = document.createElement('div')
+  host.appendChild(root)
+  const app = createApp(App, ctx.props as never)
+  app.mount(root)
+  mounted.set(host, { app, root })
+}
+
+export function unmount(host: HarnessMountHost): void {
+  const entry = mounted.get(host)
+  if (entry === undefined) return
+  entry.app.unmount()
+  host.removeChild(entry.root)
+  mounted.delete(host)
+}
+`,
+    "src/mock-props.json": MOCK_PROPS
+  };
+}
+function reactFiles(name) {
+  return {
+    ...TS_BASE(),
+    "manifest.json": MANIFEST(name, "react"),
+    "package.json": `{
+  "name": "${name}",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "dev": "adep widget dev",
+    "widget:publish": "adep widget publish -p"
+  },
+  "dependencies": {
+    "react": "^18.3.0",
+    "react-dom": "^18.3.0",
+    "@adep/types": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.0",
+    "@types/react-dom": "^18.3.0",
+    "typescript": "^5.5.0"
+  }
+}
+`,
+    "src/theme.css": THEME_CSS,
+    "src/App.tsx": `import type { CSSProperties } from 'react'
+
+/** \u7EC4\u4EF6 props \u4E0E manifest.json \u7684 props schema \u5BF9\u9F50\uFF08contracts/ \u6821\u9A8C\u5B57\u6BB5\u5B50\u96C6\uFF09\u3002 */
+export interface WidgetProps {
+  title: string
+}
+
+const styleRoot: CSSProperties = { padding: 'var(--adep-space-4)' }
+const styleTitle: CSSProperties = { color: 'var(--adep-color-accent)', margin: 0 }
+const styleDesc: CSSProperties = { color: 'var(--adep-color-text-secondary)' }
+
+export default function App(props: WidgetProps): React.JSX.Element {
+  return (
+    <div style={styleRoot}>
+      <h2 style={styleTitle}>{props.title}</h2>
+      <p style={styleDesc}>React 18 \u7EC4\u4EF6\u3002\u4E3B\u9898\u53D8\u91CF\u4E0E\u9274\u6743 token \u7531\u5BBF\u4E3B\u6CE8\u5165\u3002</p>
+    </div>
+  )
+}
+`,
+    "src/index.tsx": `// Widget \u8FD0\u884C\u65F6\u5165\u53E3\uFF08FE-002\uFF09\u3002\u5BFC\u51FA HarnessWidgetRuntime \u4E09\u4EF6\u5957\uFF1A
+// __harness / mount(host, ctx) / unmount(host)\u3002
+import { createRoot, type Root } from 'react-dom/client'
+import type { HarnessMountHost, HarnessWidgetContext } from '@adep/types'
+import App from './App'
+
+const mounted = new WeakMap<object, { root: Root; host: HTMLElement }>()
+
+export const __harness = true as const
+
+export function mount(host: HarnessMountHost, ctx: HarnessWidgetContext): void {
+  const container = document.createElement('div')
+  host.appendChild(container)
+  const root = createRoot(container)
+  root.render(<App {...(ctx.props as never)} />)
+  mounted.set(host, { root, host: container })
+}
+
+export function unmount(host: HarnessMountHost): void {
+  const entry = mounted.get(host)
+  if (entry === undefined) return
+  entry.root.unmount()
+  host.removeChild(entry.host)
+  mounted.delete(host)
+}
+`,
+    "src/mock-props.json": MOCK_PROPS
+  };
+}
+function widgetTemplateFiles(name, template) {
+  return template === "react-ts" ? reactFiles(name) : vue3Files(name);
+}
+var WIDGET_TEMPLATES, TS_BASE, MANIFEST, THEME_CSS, MOCK_PROPS;
+var init_templates = __esm({
+  "packages/cli/src/widget/templates.ts"() {
+    "use strict";
+    WIDGET_TEMPLATES = ["vue3-ts", "react-ts"];
+    TS_BASE = () => ({
+      "tsconfig.json": `{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "jsx": "react-jsx",
+    "skipLibCheck": true,
+    "noEmit": true
+  },
+  "include": ["src"]
+}
+`,
+      "README.md": `# <widget>
+
+AgentDeploy \u5FAE\u524D\u7AEF\u7EC4\u4EF6\uFF08widget\uFF09\u3002
+
+- \`adep widget dev\`\uFF1A\u672C\u5730\u5BBF\u4E3B\u6C99\u7BB1\uFF08\u4E3B\u9898\u53D8\u91CF + mock props + token \u6CE8\u5165 + \u70ED\u66F4\u65B0\uFF09
+- \`adep widget publish -p <project-slug>\`\uFF1A\u6309\u6846\u67B6\u6784\u5EFA \u2192 \u4E0A\u4F20\u5E73\u53F0\u9759\u6001\u8D44\u6E90 \u2192 \u7248\u672C\u5316\u8F93\u51FA URL
+
+> \u7EC4\u4EF6\u5165\u53E3\u5BFC\u51FA \`__harness\` / \`mount(host, ctx)\` / \`unmount(host)\`\uFF0C\u5951\u7EA6\u89C1
+> \`@adep/types\` \u7684 HarnessWidgetRuntime\uFF1B\u5BBF\u4E3B\u7528 \`<RemoteWidget>\` \u6309\u9700\u62C9\u53D6\u3002
+`,
+      ".gitignore": "node_modules/\n.adep/\ndist/\n"
+    });
+    MANIFEST = (name, framework) => `{
+  "name": "${name}",
+  "framework": "${framework}",
+  "props": {
+    "type": "object",
+    "properties": {
+      "title": { "type": "string" }
+    },
+    "required": ["title"]
+  },
+  "entry": "../dist/index.js"
+}
+`;
+    THEME_CSS = `/* \u8BBE\u8BA1\u7CFB\u7EDF\u4E3B\u9898\u53D8\u91CF\uFF1A\u5BBF\u4E3B\u7ECF CSS Variables \u6CE8\u5165\uFF08FE-002 widget dev\uFF09\u3002
+   \u672C\u5730\u6C99\u7BB1\u7F3A\u7701\u4EE5\u4E0B\u503C\uFF1B\u90E8\u7F72\u540E\u7531 Web IDE / \u5BBF\u4E3B\u4FA7\u6CE8\u5165\u540C\u540D\u5B57\u7684\u53D8\u91CF\u8986\u76D6\u3002 */
+:root {
+  --adep-color-accent: #3370ff;
+  --adep-color-text: #1f2329;
+  --adep-color-text-secondary: #4c5561;
+  --adep-space-4: 16px;
+}
+`;
+    MOCK_PROPS = `{
+  "title": "Hello from mock props"
+}
+`;
+  }
+});
+
+// packages/cli/src/widget/init.ts
+var init_exports = {};
+__export(init_exports, {
+  WIDGET_TEMPLATES: () => WIDGET_TEMPLATES,
+  WidgetInitError: () => WidgetInitError,
+  initWidget: () => initWidget
+});
+import { mkdir as mkdir3, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname3, join as join3, resolve as resolve3 } from "node:path";
+async function initWidget(cwd, name, template) {
+  if (!WIDGET_NAME_RE.test(name)) {
+    throw new WidgetInitError(
+      "INVALID_NAME",
+      `widget \u540D "${name}" \u4E0D\u5408\u6CD5\uFF1A\u9700\u4EE5\u5C0F\u5199\u5B57\u6BCD\u5F00\u5934\uFF0C\u4EC5\u542B\u5C0F\u5199\u5B57\u6BCD / \u6570\u5B57 / \u8FDE\u5B57\u7B26`
+    );
+  }
+  if (!WIDGET_TEMPLATES.includes(template)) {
+    throw new WidgetInitError("INVALID_TEMPLATE", `\u672A\u77E5\u6A21\u677F "${template}"\uFF1A\u53EF\u9009 vue3-ts | react-ts`);
+  }
+  const projectPath = resolve3(cwd, name);
+  let existing;
+  try {
+    existing = await stat3(projectPath);
+  } catch {
+    existing = null;
+  }
+  if (existing !== null) {
+    throw new WidgetInitError("DIR_EXISTS", `\u76EE\u5F55 ${projectPath} \u5DF2\u5B58\u5728\uFF1A\u8BF7\u6362\u4E00\u4E2A\u540D\u5B57\u6216\u5148\u5220\u9664`);
+  }
+  const files = widgetTemplateFiles(name, template);
+  await mkdir3(projectPath, { recursive: true });
+  await Promise.all(
+    Object.entries(files).map(async ([rel, content]) => {
+      const target = join3(projectPath, rel);
+      await mkdir3(dirname3(target), { recursive: true });
+      await writeFile2(target, content);
+    })
+  );
+  return { projectPath, files: Object.keys(files).toSorted() };
+}
+var WidgetInitError, WIDGET_NAME_RE;
+var init_init = __esm({
+  "packages/cli/src/widget/init.ts"() {
+    "use strict";
+    init_templates();
+    WidgetInitError = class extends Error {
+      constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "WidgetInitError";
+      }
+    };
+    WIDGET_NAME_RE = /^[a-z][a-z0-9-]{0,62}$/;
+  }
+});
+
+// packages/cli/src/prompt.ts
+var prompt_exports = {};
+__export(prompt_exports, {
+  createPrompt: () => createPrompt
+});
+import { createInterface } from "node:readline/promises";
+import { Writable } from "node:stream";
+function createPrompt(input = process.stdin) {
+  const rl = createInterface({ input, output: process.stdout, terminal: true });
+  let muted = null;
+  return {
+    async ask(question) {
+      const answer = await rl.question(question);
+      return answer.trim();
+    },
+    async askHidden(question) {
+      muted = createInterface({ input, output: new MutedStream(), terminal: true });
+      const answer = await muted.question(question);
+      muted.close();
+      muted = null;
+      process.stdout.write("\n");
+      return answer.trim();
+    },
+    close() {
+      muted?.close();
+      rl.close();
+    }
+  };
+}
+var MutedStream;
+var init_prompt = __esm({
+  "packages/cli/src/prompt.ts"() {
+    "use strict";
+    MutedStream = class extends Writable {
+      write(_chunk, ...rest) {
+        void rest;
+        return true;
+      }
+    };
+  }
+});
+
+// packages/runtime/src/shared/capability-keys.ts
+var RPC_CAPABILITY_KEY, CHAIN_CAPABILITY_KEY, DB_RPC;
+var init_capability_keys = __esm({
+  "packages/runtime/src/shared/capability-keys.ts"() {
+    "use strict";
+    RPC_CAPABILITY_KEY = "__adepRpc";
+    CHAIN_CAPABILITY_KEY = "__adepChain";
+    DB_RPC = {
+      /** 直通方法（如 query）：`(method=query, args=[sql, params])`。 */
+      query: "query",
+      /** 读取 owned 表变更流（DB-006）：`(method=changes, args=[table, query])`。 */
+      changes: "changes",
+      /** 开启事务：`begin → txId`。 */
+      begin: "begin",
+      /** 提交事务：`commit, args=[txId]`。 */
+      commit: "commit",
+      /** 回滚事务：`rollback, args=[txId]`。 */
+      rollback: "rollback",
+      /** 执行一条链：`chain, args=[ChainRequest]`。 */
+      chain: "chain"
+    };
+  }
+});
+
+// packages/runtime/src/shared/executor-runtime.ts
+function isHttpStatus(status) {
+  return typeof status === "number" && Number.isInteger(status) && status >= 400 && status <= 599;
+}
+function normalizeHttpStatus(status) {
+  return isHttpStatus(status) ? status : 500;
+}
+var ExecutorError, TIMEOUT_CODE, OOM_CODE, DEFAULT_TIMEOUT_MS, DEFAULT_MEMORY_LIMIT_MB;
+var init_executor_runtime = __esm({
+  "packages/runtime/src/shared/executor-runtime.ts"() {
+    "use strict";
+    ExecutorError = class extends Error {
+      constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "ExecutorError";
+      }
+    };
+    TIMEOUT_CODE = "FN_EXEC_TIMEOUT";
+    OOM_CODE = "FN_EXEC_OOM";
+    DEFAULT_TIMEOUT_MS = 1e4;
+    DEFAULT_MEMORY_LIMIT_MB = 128;
+  }
+});
+
+// packages/runtime/src/functions/runtime/executor.ts
+var init_executor = __esm({
+  "packages/runtime/src/functions/runtime/executor.ts"() {
+    "use strict";
+    init_executor_runtime();
+  }
+});
+
+// packages/runtime/src/functions/domain.ts
+var MAX_TOTAL_SOURCE_BYTES, FnError;
+var init_domain = __esm({
+  "packages/runtime/src/functions/domain.ts"() {
+    "use strict";
+    MAX_TOTAL_SOURCE_BYTES = 256 * 1024;
+    FnError = class extends Error {
+      status;
+      code;
+      constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "FnError";
+      }
+    };
+  }
+});
+
+// packages/runtime/src/functions/deps/manifest.ts
+import { createHash as createHash2 } from "node:crypto";
+function isVersionRangeSpec(spec) {
+  if (spec === "*" || spec === "latest") return true;
+  const unions = spec.split("||");
+  return unions.every((union) => {
+    const trimmed = union.trim();
+    if (trimmed.length === 0) return false;
+    const hyphen = trimmed.split(" - ");
+    if (hyphen.length === 2) {
+      return COMPARATOR_PATTERN.test(hyphen[0].trim()) && COMPARATOR_PATTERN.test(hyphen[1].trim());
+    }
+    return trimmed.split(/\s+/).every((part) => COMPARATOR_PATTERN.test(part));
+  });
+}
+function parseManifestDependencies(content) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    throw new FnError(400, "DEP_INVALID_MANIFEST", "package.json \u4E0D\u662F\u5408\u6CD5 JSON");
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new FnError(400, "DEP_INVALID_MANIFEST", "package.json \u9876\u5C42\u5FC5\u987B\u662F\u5BF9\u8C61");
+  }
+  const raw = parsed["dependencies"];
+  if (raw === void 0) return {};
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new FnError(400, "DEP_INVALID_MANIFEST", "dependencies \u5FC5\u987B\u662F { \u5305\u540D: \u7248\u672C\u8303\u56F4 } \u5BF9\u8C61");
+  }
+  const entries = Object.entries(raw);
+  if (entries.length > MANIFEST_MAX_DEPS) {
+    throw new FnError(
+      400,
+      "DEP_INVALID_MANIFEST",
+      `\u4F9D\u8D56\u6761\u76EE\u8D85\u8FC7\u4E0A\u9650\uFF08${MANIFEST_MAX_DEPS} \u4E2A\uFF0C\u5F53\u524D ${entries.length} \u4E2A\uFF09`
+    );
+  }
+  const dependencies = {};
+  for (const [name, spec] of entries) {
+    if (!PACKAGE_NAME_PATTERN.test(name)) {
+      throw new FnError(
+        400,
+        "DEP_INVALID_MANIFEST",
+        `\u975E\u6CD5\u4F9D\u8D56\u540D "${name}"\uFF1A\u987B\u4E3A npm \u5305\u540D\uFF08scoped \u5F62\u5982 @scope/name\uFF09`
+      );
+    }
+    if (typeof spec !== "string" || !isVersionRangeSpec(spec)) {
+      throw new FnError(
+        400,
+        "DEP_SPEC_REJECTED",
+        `\u4F9D\u8D56 "${name}" \u7684\u7248\u672C\u58F0\u660E "${String(spec)}" \u4E0D\u88AB\u63A5\u53D7\uFF1A\u53EA\u652F\u6301\u8BED\u4E49\u5316\u7248\u672C\u8303\u56F4\uFF08^/~/>=/\u7CBE\u786E\uFF09\uFF0CURL\u3001git\u3001file\u3001workspace \u53D6\u5305\u88AB registry \u767D\u540D\u5355\u62D2\u7EDD`
+      );
+    }
+    dependencies[name] = spec;
+  }
+  return dependencies;
+}
+function tryParseManifestDependencies(content) {
+  if (content === void 0) return {};
+  try {
+    return parseManifestDependencies(content);
+  } catch {
+    return {};
+  }
+}
+function classifyDependencies(dependencies, builtin) {
+  const builtinDeps = {};
+  const customDeps = {};
+  for (const [name, spec] of Object.entries(dependencies)) {
+    if (builtin.includes(name)) builtinDeps[name] = spec;
+    else customDeps[name] = spec;
+  }
+  return { builtinDeps, customDeps };
+}
+function depsKeyOf(dependencies) {
+  const canonical = Object.entries(dependencies).map(([name, version]) => `${name}@${version}`).toSorted().join("\n");
+  return createHash2("sha256").update(canonical).digest("hex").slice(0, 16);
+}
+var PACKAGE_NAME_PATTERN, COMPARATOR_PATTERN, MANIFEST_MAX_DEPS;
+var init_manifest = __esm({
+  "packages/runtime/src/functions/deps/manifest.ts"() {
+    "use strict";
+    init_domain();
+    PACKAGE_NAME_PATTERN = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-._~]+$/;
+    COMPARATOR_PATTERN = /^(?:\^|~|>=|<=|>|<|=)?\d+(?:\.(?:\d+|x|X|\*)){0,2}(?:-[\w.-]+)?(?:\+[\w.-]+)?$/;
+    MANIFEST_MAX_DEPS = 100;
+  }
+});
+
+// packages/runtime/src/functions/deps/resolve.ts
+import { resolve as resolve4 } 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 : resolve4(config.rootDir, projectId, depsKeyOf(customDeps)),
+    builtin: [...config.builtin],
+    custom
+  };
+}
+var init_resolve = __esm({
+  "packages/runtime/src/functions/deps/resolve.ts"() {
+    "use strict";
+    init_manifest();
+  }
+});
+
+// packages/runtime/src/functions/runtime/worker-executor.ts
+import { readFileSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { dirname as dirname4, join as join4 } from "node:path";
+import { Worker } from "node:worker_threads";
+function resolveWorkerEntry(baseDir = fileURLToPath(new URL(".", import.meta.url))) {
+  const candidates = [
+    join4(baseDir, "worker-entry.js"),
+    join4(baseDir, "worker-entry.ts"),
+    join4(baseDir, "domains/functions/runtime/worker-entry.js"),
+    join4(baseDir, "domains/functions/runtime/worker-entry.ts")
+  ];
+  let current = baseDir;
+  for (let depth = 0; depth < 8; depth += 1) {
+    candidates.push(
+      join4(current, "packages/runtime/src/functions/runtime/worker-entry.js"),
+      join4(current, "packages/runtime/src/functions/runtime/worker-entry.ts")
+    );
+    const parent = dirname4(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  for (const candidate of candidates) {
+    try {
+      readFileSync(candidate);
+      return pathToFileURL(candidate);
+    } catch {
+      continue;
+    }
+  }
+  throw new Error("\u65E0\u6CD5\u5B9A\u4F4D worker \u5165\u53E3\uFF08worker-entry.ts / worker-entry.js\uFF09");
+}
+function rpcReply(worker, id, ok, payload) {
+  worker.postMessage({
+    type: "rpc-response",
+    id,
+    ok,
+    ...payload?.result === void 0 ? {} : { result: payload.result },
+    ...payload?.error === void 0 ? {} : { error: payload.error }
+  });
+}
+var WorkerFunctionExecutor;
+var init_worker_executor = __esm({
+  "packages/runtime/src/functions/runtime/worker-executor.ts"() {
+    "use strict";
+    init_executor();
+    init_resolve();
+    WorkerFunctionExecutor = class {
+      depsConfig;
+      fetchConfig;
+      constructor(options = {}) {
+        this.depsConfig = options.deps;
+        this.fetchConfig = options.fetch;
+      }
+      async execute(input) {
+        const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const memoryLimitMb = input.memoryLimitMb ?? DEFAULT_MEMORY_LIMIT_MB;
+        const entry = input.entry ?? "index.ts";
+        const deps = this.depsConfig === void 0 ? void 0 : resolveExecutionDeps(this.depsConfig, input.project.id, input.files["package.json"]);
+        const logs = [];
+        return new Promise((resolve12, reject) => {
+          let worker;
+          try {
+            worker = new Worker(resolveWorkerEntry(), {
+              workerData: {
+                files: input.files,
+                entry,
+                request: input.request,
+                capabilities: input.capabilities ?? [],
+                ...input.env === void 0 ? {} : { env: input.env },
+                ...deps === void 0 ? {} : { deps },
+                ...this.fetchConfig === void 0 ? {} : { fetch: this.fetchConfig }
+              },
+              resourceLimits: { maxOldGenerationSizeMb: memoryLimitMb }
+            });
+          } catch (error) {
+            reject(
+              new ExecutorError(
+                500,
+                "FN_EXEC_ERROR",
+                error instanceof Error ? error.message : "worker \u6784\u9020\u5931\u8D25"
+              )
+            );
+            return;
+          }
+          const timer = setTimeout(() => {
+            void worker.terminate();
+            reject(
+              new ExecutorError(504, TIMEOUT_CODE, `\u51FD\u6570\u6267\u884C\u8D85\u8FC7 ${timeoutMs}ms \u9650\u5236\uFF0Cworker \u5DF2\u88AB\u56DE\u6536`)
+            );
+          }, timeoutMs);
+          worker.on(
+            "message",
+            (message) => {
+              if (message.type === "rpc") {
+                const handler = input.rpcHandlers?.[message.capability ?? ""];
+                if (handler === void 0) {
+                  rpcReply(worker, message.id, false, {
+                    error: `RPC \u80FD\u529B "${message.capability ?? ""}" \u672A\u6CE8\u518C`
+                  });
+                  return;
+                }
+                const rpcArgs = Array.isArray(message.args) ? message.args : [];
+                void (async () => {
+                  try {
+                    const result = await handler(message.method ?? "", rpcArgs);
+                    rpcReply(worker, message.id, true, { result });
+                  } catch (error) {
+                    rpcReply(worker, message.id, false, {
+                      error: error instanceof Error ? error.message : String(error)
+                    });
+                  }
+                })();
+                return;
+              }
+              if (message.type === "log") {
+                logs.push(`[${message.level ?? "log"}] ${message.message ?? ""}`);
+                return;
+              }
+              if (message.type === "result") {
+                clearTimeout(timer);
+                void worker.terminate();
+                resolve12({ body: message.body, logs });
+                return;
+              }
+              if (message.type === "error") {
+                clearTimeout(timer);
+                void worker.terminate();
+                const isOom = typeof message.message === "string" && /allocation\s+(failed|error)|out\s+of\s+memory|\bOOM\b/i.test(message.message);
+                reject(
+                  isOom ? new ExecutorError(500, OOM_CODE, "\u51FD\u6570\u5185\u5B58\u8D85\u9650\uFF0C\u6267\u884C\u5DF2\u4E2D\u6B62") : (
+                    // FN-011：函数抛错携带的 status 透传落 ExecutorError.status（非法/缺失 → 500 兼容旧形态）。
+                    new ExecutorError(
+                      normalizeHttpStatus(message.status),
+                      message.code ?? "FN_EXEC_ERROR",
+                      message.message ?? "\u51FD\u6570\u6267\u884C\u5931\u8D25"
+                    )
+                  )
+                );
+              }
+            }
+          );
+          worker.on("error", (error) => {
+            clearTimeout(timer);
+            const isOom = /allocation\s+(failed|error)|out\s+of\s+memory|\bOOM\b/i.test(error.message);
+            reject(
+              isOom ? new ExecutorError(500, OOM_CODE, "\u51FD\u6570\u5185\u5B58\u8D85\u9650\uFF0C\u6267\u884C\u5DF2\u4E2D\u6B62") : new ExecutorError(500, "FN_EXEC_ERROR", error.message)
+            );
+          });
+        });
+      }
+      async dispose() {
+      }
+    };
+  }
+});
+
+// packages/runtime/src/database/builder/dialect.ts
+function dialectFor(driver) {
+  return driver.engine === "pg" ? postgresDialect : sqliteDialect;
+}
+var sqliteDialect, postgresDialect;
+var init_dialect = __esm({
+  "packages/runtime/src/database/builder/dialect.ts"() {
+    "use strict";
+    sqliteDialect = {
+      name: "sqlite",
+      placeholder: () => "?",
+      quote: (identifier) => `"${identifier.replace(/"/g, '""')}"`,
+      lastInsertIdClause: () => "",
+      upsertConflictClause: (columns) => ` ON CONFLICT (${columns.map((column) => `"${column.replace(/"/g, '""')}"`).join(", ")}) DO NOTHING`
+    };
+    postgresDialect = {
+      name: "postgres",
+      placeholder: (index) => `$${index + 1}`,
+      quote: (identifier) => `"${identifier.replace(/"/g, '""')}"`,
+      lastInsertIdClause: () => " RETURNING id",
+      upsertConflictClause: (columns) => ` ON CONFLICT (${columns.map((column) => `"${column.replace(/"/g, '""')}"`).join(", ")}) DO NOTHING`
+    };
+  }
+});
+
+// packages/runtime/src/database/provision/identifier.ts
+function assertIdentifier(name) {
+  if (!IDENTIFIER_PATTERN.test(name)) {
+    throw new DbError(
+      400,
+      "DB_UNSAFE_OP",
+      `\u975E\u6CD5\u6807\u8BC6\u7B26 "${name.slice(0, 32)}"\uFF1A\u4EC5\u5141\u8BB8\u5B57\u6BCD / \u4E0B\u5212\u7EBF\u5F00\u5934\u7684\u5B57\u6BCD\u6570\u5B57\u4E0B\u5212\u7EBF\u7EC4\u5408`
+    );
+  }
+}
+function quoteIdentifier(name) {
+  assertIdentifier(name);
+  return `"${name.replace(/"/g, '""')}"`;
+}
+var DbError, IDENTIFIER_PATTERN;
+var init_identifier = __esm({
+  "packages/runtime/src/database/provision/identifier.ts"() {
+    "use strict";
+    DbError = class extends Error {
+      constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "DbError";
+      }
+    };
+    IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]{0,62}$/;
+  }
+});
+
+// packages/runtime/src/database/builder/guards.ts
+function unsafeOperation(message) {
+  return new DbError(400, "DB_UNSAFE_OP", message);
+}
+function stripLiterals(sql) {
+  return sql.replace(/'[^']*(?:''[^']*)*'/g, "").replace(/"[^"]*(?:""[^"]*)*"/g, "").replace(/--[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+}
+function assertReadOnlyQuery(sql) {
+  const stripped = stripLiterals(sql);
+  if (stripped.includes(";")) {
+    throw unsafeOperation("\u4EC5\u5141\u8BB8\u5355\u6761\u8BED\u53E5\uFF0C\u7981\u6B62\u591A\u8BED\u53E5\u5806\u53E0");
+  }
+  const head = stripped.trim().replace(/^\(+/, "").trim().toUpperCase();
+  if (!head.startsWith("SELECT") && !head.startsWith("WITH")) {
+    throw unsafeOperation("cloud.db.query \u4EC5\u5141\u8BB8\u53EA\u8BFB\u67E5\u8BE2\uFF08SELECT / WITH\uFF09");
+  }
+  if (/ATTACH|DETACH/.test(stripped.toUpperCase())) {
+    throw unsafeOperation("\u7981\u6B62\u8DE8\u5E93\u64CD\u4F5C\uFF08ATTACH / DETACH\uFF09");
+  }
+  if (/SQLITE_\w+/i.test(stripped)) {
+    throw unsafeOperation("\u7981\u6B62\u8BBF\u95EE\u7CFB\u7EDF\u8868\uFF08sqlite_*\uFF09");
+  }
+}
+var init_guards = __esm({
+  "packages/runtime/src/database/builder/guards.ts"() {
+    "use strict";
+    init_identifier();
+  }
+});
+
+// packages/runtime/src/database/builder/owned.ts
+function changeLogTable(table) {
+  const name = `${CHANGE_LOG_PREFIX}${table}`;
+  assertIdentifier(name);
+  return name;
+}
+function assertUserColumn(name) {
+  assertIdentifier(name);
+  if (name.startsWith("__") && name !== OWNED_OWNER_KEY) {
+    throw new DbError(400, "DB_UNSAFE_OP", `\u4FDD\u7559\u524D\u7F00 "__" \u7684\u5217\u540D\u4E0D\u88AB\u5141\u8BB8\uFF1A${name.slice(0, 32)}`);
+  }
+  if (name.startsWith("_adep_")) {
+    throw new DbError(
+      400,
+      "DB_UNSAFE_OP",
+      `\u5E73\u53F0\u4FDD\u7559\u6BB5 "_adep_" \u7684\u5217\u540D\u4E0D\u88AB\u5141\u8BB8\uFF1A${name.slice(0, 32)}`
+    );
+  }
+}
+async function hasChangeLog(driver, table) {
+  if (driver.engine === "pg") {
+    return await driver.get(
+      "SELECT 1 FROM information_schema.tables WHERE table_schema = current_schema() AND table_name = $1",
+      [changeLogTable(table)]
+    ) !== null;
+  }
+  return await driver.get("SELECT 1 AS x FROM sqlite_master WHERE type = ? AND name = ?", [
+    "table",
+    changeLogTable(table)
+  ]) !== null;
+}
+async function assertOwned(driver, table) {
+  if (!await hasChangeLog(driver, table)) {
+    throw unsafeOperation(`\u8868 "${table}" \u4E0D\u662F owned \u8868\uFF08\u7F3A\u5C11\u53D8\u66F4\u6D41\u8868 ${changeLogTable(table)}\uFF09`);
+  }
+}
+async function appendChange(driver, table, op, id, ownerKey, before, after) {
+  const ph = dialectFor(driver).placeholder;
+  await driver.run(
+    `INSERT INTO ${quoteIdentifier(changeLogTable(table))} ("ts","op","id","__owner_key","before","after") VALUES (${ph(0)},${ph(1)},${ph(2)},${ph(3)},${ph(4)},${ph(5)})`,
+    [
+      (/* @__PURE__ */ new Date()).toISOString(),
+      op,
+      id,
+      ownerKey,
+      before === null ? null : JSON.stringify(before),
+      after === null ? null : JSON.stringify(after)
+    ]
+  );
+}
+async function runOwnedWrite(driver, fn) {
+  await driver.run("SAVEPOINT _adep_change");
+  try {
+    await fn(driver);
+    await driver.run("RELEASE SAVEPOINT _adep_change");
+  } catch (error) {
+    await driver.run("ROLLBACK TO SAVEPOINT _adep_change");
+    await driver.run("RELEASE SAVEPOINT _adep_change");
+    throw error;
+  }
+}
+function parseChange(row) {
+  const before = row["before"];
+  const after = row["after"];
+  return {
+    seq: Number(row["seq"]),
+    ts: String(row["ts"]),
+    op: row["op"],
+    id: String(row["id"]),
+    ownerKey: row["__owner_key"] === null || row["__owner_key"] === void 0 ? null : String(row["__owner_key"]),
+    before: before === null || before === void 0 ? null : JSON.parse(String(before)),
+    after: after === null || after === void 0 ? null : JSON.parse(String(after))
+  };
+}
+async function readChanges(driver, table, query = {}) {
+  await assertOwned(driver, table);
+  const ph = dialectFor(driver).placeholder;
+  const params = [];
+  const conditions = [];
+  if (query.afterSeq !== void 0) {
+    if (!Number.isInteger(query.afterSeq) || query.afterSeq < 0) {
+      throw unsafeOperation("afterSeq \u5FC5\u987B\u662F\u975E\u8D1F\u6574\u6570");
+    }
+    conditions.push(`"seq" > ${ph(params.length)}`);
+    params.push(query.afterSeq);
+  }
+  if (query.ownerKey !== void 0) {
+    if (query.ownerKey === null) {
+      conditions.push('"__owner_key" IS NULL');
+    } else {
+      conditions.push(`"__owner_key" = ${ph(params.length)}`);
+      params.push(query.ownerKey);
+    }
+  }
+  if (query.limit !== void 0) {
+    if (!Number.isInteger(query.limit) || query.limit < 0) {
+      throw unsafeOperation("limit \u5FC5\u987B\u662F\u975E\u8D1F\u6574\u6570");
+    }
+  }
+  let sql = `SELECT "seq","ts","op","id","__owner_key","before","after" FROM ` + quoteIdentifier(changeLogTable(table));
+  if (conditions.length > 0) sql += ` WHERE ${conditions.join(" AND ")}`;
+  sql += ' ORDER BY "seq" ASC';
+  if (query.limit !== void 0) {
+    sql += ` LIMIT ${ph(params.length)}`;
+    params.push(query.limit);
+  }
+  const rows = await driver.all(sql, params);
+  return rows.map(parseChange);
+}
+var OWNED_PK, OWNED_OWNER_KEY, CHANGE_LOG_PREFIX;
+var init_owned = __esm({
+  "packages/runtime/src/database/builder/owned.ts"() {
+    "use strict";
+    init_identifier();
+    init_dialect();
+    init_guards();
+    OWNED_PK = "id";
+    OWNED_OWNER_KEY = "__owner_key";
+    CHANGE_LOG_PREFIX = "_adep_changes_";
+  }
+});
+
+// packages/runtime/src/database/builder/ulid.ts
+import { randomFillSync } from "node:crypto";
+function encodeTime(now) {
+  let ts = Math.trunc(now);
+  let out = "";
+  for (let i = 0; i < TIME_LEN; i++) {
+    out = ENCODING[ts % 32] + out;
+    ts = Math.floor(ts / 32);
+  }
+  return out;
+}
+function encodeRandom(bytes) {
+  let out = "";
+  let buffer = 0;
+  let bits = 0;
+  for (const byte of bytes) {
+    buffer = buffer << 8 | byte;
+    bits += 8;
+    while (bits >= 5) {
+      out += ENCODING[buffer >>> bits - 5 & 31];
+      bits -= 5;
+    }
+  }
+  return out.slice(0, RANDOM_LEN);
+}
+function incrBase32(prev) {
+  const chars = prev.split("");
+  for (let i = chars.length - 1; i >= 0; i--) {
+    const idx = ENCODING.indexOf(chars[i]);
+    if (idx < 31) {
+      chars[i] = ENCODING[idx + 1];
+      return chars.join("");
+    }
+    chars[i] = ENCODING[0];
+  }
+  return chars.join("");
+}
+function ulid(now = Date.now()) {
+  const time = encodeTime(now);
+  let random;
+  if (now === lastTime) {
+    random = incrBase32(lastRandom);
+  } else {
+    lastTime = now;
+    const bytes = new Uint8Array(10);
+    randomFillSync(bytes);
+    random = encodeRandom(bytes);
+  }
+  lastRandom = random;
+  return time + random;
+}
+var ENCODING, TIME_LEN, RANDOM_LEN, lastTime, lastRandom;
+var init_ulid = __esm({
+  "packages/runtime/src/database/builder/ulid.ts"() {
+    "use strict";
+    ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+    TIME_LEN = 10;
+    RANDOM_LEN = 16;
+    lastTime = 0;
+    lastRandom = "";
+  }
+});
+
+// packages/runtime/src/database/builder/table.ts
+function pushParam(params, dialect, value) {
+  params.push(value);
+  return dialect.placeholder(params.length - 1);
+}
+function assertHasWhere(state) {
+  if (state.wheres.length === 0) {
+    throw unsafeOperation("update / delete \u5FC5\u987B\u5148\u6307\u5B9A where\uFF08\u9632\u6B62\u5168\u8868\u8BEF\u6539 / \u8BEF\u5220\uFF09");
+  }
+}
+async function resolveOwned(state, driver) {
+  if (state.owned === true) {
+    await assertOwned(driver, state.table);
+    return true;
+  }
+  return state.owned ?? await hasChangeLog(driver, state.table);
+}
+function toOwnerKey(row) {
+  const value = row[OWNED_OWNER_KEY];
+  return value === null || value === void 0 ? null : String(value);
+}
+function ownedInsertRow(row) {
+  const effective = { ...row };
+  if (effective[OWNED_PK] === void 0) {
+    effective[OWNED_PK] = ulid();
+  }
+  return effective;
+}
+async function captureBeforeRows(state, dialect, driver) {
+  const select = compileSelect({ ...state, columns: [] }, dialect);
+  return driver.all(select.sql, select.params);
+}
+function compileWhere(wheres, dialect, params) {
+  return wheres.map((where) => {
+    const quoted = dialect.quote(where.column);
+    if (LIST_OPERATORS.has(where.operator)) {
+      const values = where.value;
+      if (values.length === 0) {
+        throw unsafeOperation(`${where.operator.toUpperCase()} \u81F3\u5C11\u9700\u8981\u4E00\u4E2A\u503C`);
+      }
+      const marks = values.map((value2) => pushParam(params, dialect, value2));
+      return `${quoted} ${where.operator.toUpperCase()} (${marks.join(", ")})`;
+    }
+    const value = where.value;
+    if (value === null) {
+      if (where.operator === "=") return `${quoted} IS NULL`;
+      if (where.operator === "!=") return `${quoted} IS NOT NULL`;
+    }
+    const mark = pushParam(params, dialect, value);
+    return `${quoted} ${where.operator} ${mark}`;
+  }).join(" AND ");
+}
+function compileSelect(state, dialect) {
+  const params = [];
+  const columns = state.columns.length > 0 ? state.columns.map((column) => dialect.quote(column)).join(", ") : "*";
+  let sql = `SELECT ${columns} FROM ${dialect.quote(state.table)}`;
+  if (state.wheres.length > 0) {
+    sql += ` WHERE ${compileWhere(state.wheres, dialect, params)}`;
+  }
+  if (state.orderBys.length > 0) {
+    sql += ` ORDER BY ${state.orderBys.map((order) => `${dialect.quote(order.column)} ${order.direction.toUpperCase()}`).join(", ")}`;
+  }
+  if (state.limit !== void 0) sql += ` LIMIT ${pushParam(params, dialect, state.limit)}`;
+  if (state.offset !== void 0) sql += ` OFFSET ${pushParam(params, dialect, state.offset)}`;
+  return { sql, params };
+}
+function compileCount(state, dialect) {
+  const params = [];
+  let sql = `SELECT count(*) AS n FROM ${dialect.quote(state.table)}`;
+  if (state.wheres.length > 0) {
+    sql += ` WHERE ${compileWhere(state.wheres, dialect, params)}`;
+  }
+  return { sql, params };
+}
+function compileInsert(table, row, dialect) {
+  const entries = Object.entries(row);
+  if (entries.length === 0) {
+    throw unsafeOperation("insert \u81F3\u5C11\u9700\u8981\u4E00\u4E2A\u5B57\u6BB5");
+  }
+  const params = [];
+  const columns = entries.map(([name]) => {
+    assertUserColumn(name);
+    return dialect.quote(name);
+  }).join(", ");
+  const marks = entries.map(([, value]) => pushParam(params, dialect, value));
+  return {
+    sql: `INSERT INTO ${dialect.quote(table)} (${columns}) VALUES (${marks.join(", ")})`,
+    params
+  };
+}
+function compileInsertMany(table, rows, dialect) {
+  if (rows.length === 0) {
+    throw unsafeOperation("insertMany \u81F3\u5C11\u9700\u8981\u4E00\u884C");
+  }
+  const columns = [...new Set(rows.flatMap((row) => Object.keys(row)))];
+  if (columns.length === 0) {
+    throw unsafeOperation("insertMany \u81F3\u5C11\u9700\u8981\u4E00\u4E2A\u5B57\u6BB5");
+  }
+  columns.forEach(assertUserColumn);
+  const params = [];
+  const quoted = columns.map((column) => dialect.quote(column)).join(", ");
+  const valueGroups = rows.map((row) => {
+    const marks = columns.map((column) => pushParam(params, dialect, row[column] ?? null));
+    return `(${marks.join(", ")})`;
+  });
+  return {
+    sql: `INSERT INTO ${dialect.quote(table)} (${quoted}) VALUES ${valueGroups.join(", ")}`,
+    params
+  };
+}
+function compileUpdate(table, wheres, values, dialect) {
+  const entries = Object.entries(values);
+  if (entries.length === 0) {
+    throw unsafeOperation("update \u81F3\u5C11\u9700\u8981\u4E00\u4E2A\u5B57\u6BB5");
+  }
+  const params = [];
+  const sets = entries.map(([name, value]) => {
+    assertUserColumn(name);
+    return `${dialect.quote(name)} = ${pushParam(params, dialect, value)}`;
+  }).join(", ");
+  const where = compileWhere(wheres, dialect, params);
+  return { sql: `UPDATE ${dialect.quote(table)} SET ${sets} WHERE ${where}`, params };
+}
+function compileDelete(table, wheres, dialect) {
+  const params = [];
+  const where = compileWhere(wheres, dialect, params);
+  return { sql: `DELETE FROM ${dialect.quote(table)} WHERE ${where}`, params };
+}
+function createTableBuilder(table, driver, dialect, options = {}) {
+  assertIdentifier(table);
+  const guardWrite = options.guardWrite ?? (() => void 0);
+  const initialState = {
+    table,
+    columns: [],
+    wheres: [],
+    orderBys: [],
+    limit: void 0,
+    offset: void 0
+  };
+  const build = (state) => {
+    const derived = (patch) => build({ ...state, ...patch });
+    return {
+      select(...columns) {
+        columns.forEach(assertUserColumn);
+        return derived({ columns });
+      },
+      owned() {
+        return derived({ owned: true });
+      },
+      where(column, operatorOrValue, maybeValue) {
+        assertUserColumn(column);
+        let operator;
+        let value;
+        if (maybeValue !== void 0) {
+          operator = operatorOrValue;
+          if (!OPERATORS.has(operator)) {
+            throw unsafeOperation(`\u4E0D\u652F\u6301\u7684\u64CD\u4F5C\u7B26 "${operator}"`);
+          }
+          if (LIST_OPERATORS.has(operator) && !Array.isArray(maybeValue)) {
+            throw unsafeOperation(`${operator.toUpperCase()} \u9700\u8981\u6570\u7EC4\u503C`);
+          }
+          value = maybeValue;
+        } else {
+          operator = "=";
+          value = operatorOrValue;
+        }
+        return derived({ wheres: [...state.wheres, { column, operator, value }] });
+      },
+      orderBy(column, direction = "asc") {
+        assertUserColumn(column);
+        if (direction !== "asc" && direction !== "desc") {
+          throw unsafeOperation("orderBy \u65B9\u5411\u4EC5\u652F\u6301 asc / desc");
+        }
+        return derived({ orderBys: [...state.orderBys, { column, direction }] });
+      },
+      limit(n) {
+        if (!Number.isInteger(n) || n < 0) {
+          throw unsafeOperation("limit \u5FC5\u987B\u662F\u975E\u8D1F\u6574\u6570");
+        }
+        return derived({ limit: n });
+      },
+      offset(n) {
+        if (!Number.isInteger(n) || n < 0) {
+          throw unsafeOperation("offset \u5FC5\u987B\u662F\u975E\u8D1F\u6574\u6570");
+        }
+        return derived({ offset: n });
+      },
+      async get() {
+        const compiled = compileSelect(state, dialect);
+        return driver.all(compiled.sql, compiled.params);
+      },
+      async first() {
+        const compiled = compileSelect({ ...state, limit: 1 }, dialect);
+        return driver.get(compiled.sql, compiled.params);
+      },
+      async count() {
+        const compiled = compileCount(state, dialect);
+        const row = await driver.get(compiled.sql, compiled.params);
+        return row === null ? 0 : Number(row["n"]);
+      },
+      async insert(row) {
+        guardWrite();
+        Object.keys(row).forEach(assertUserColumn);
+        if (await resolveOwned(state, driver)) {
+          const effective = ownedInsertRow(row);
+          const ownerKey = toOwnerKey(effective);
+          const compiled2 = compileInsert(state.table, effective, dialect);
+          await runOwnedWrite(driver, async (d) => {
+            await d.run(compiled2.sql, compiled2.params);
+            await appendChange(
+              d,
+              state.table,
+              "insert",
+              String(effective[OWNED_PK]),
+              ownerKey,
+              null,
+              effective
+            );
+          });
+          return;
+        }
+        const compiled = compileInsert(state.table, row, dialect);
+        await driver.run(compiled.sql, compiled.params);
+      },
+      async insertMany(rows) {
+        guardWrite();
+        const insertColumns = [...new Set(rows.flatMap((row) => Object.keys(row)))];
+        insertColumns.forEach(assertUserColumn);
+        if (await resolveOwned(state, driver)) {
+          const effectiveRows = rows.map(ownedInsertRow);
+          const compiled2 = compileInsertMany(state.table, effectiveRows, dialect);
+          await runOwnedWrite(driver, async (d) => {
+            await d.run(compiled2.sql, compiled2.params);
+            for (const effective of effectiveRows) {
+              await appendChange(
+                d,
+                state.table,
+                "insert",
+                String(effective[OWNED_PK]),
+                toOwnerKey(effective),
+                null,
+                effective
+              );
+            }
+          });
+          return;
+        }
+        const compiled = compileInsertMany(state.table, rows, dialect);
+        await driver.run(compiled.sql, compiled.params);
+      },
+      async update(values) {
+        guardWrite();
+        assertHasWhere(state);
+        Object.keys(values).forEach(assertUserColumn);
+        if (await resolveOwned(state, driver)) {
+          const before = await captureBeforeRows(state, dialect, driver);
+          const compiled2 = compileUpdate(state.table, state.wheres, values, dialect);
+          await runOwnedWrite(driver, async (d) => {
+            await d.run(compiled2.sql, compiled2.params);
+            for (const row of before) {
+              const after = { ...row, ...values };
+              await appendChange(
+                d,
+                state.table,
+                "update",
+                String(row[OWNED_PK]),
+                toOwnerKey(row),
+                row,
+                after
+              );
+            }
+          });
+          return before.length;
+        }
+        const compiled = compileUpdate(state.table, state.wheres, values, dialect);
+        return (await driver.run(compiled.sql, compiled.params)).changes;
+      },
+      async delete() {
+        guardWrite();
+        assertHasWhere(state);
+        if (await resolveOwned(state, driver)) {
+          const before = await captureBeforeRows(state, dialect, driver);
+          const compiled2 = compileDelete(state.table, state.wheres, dialect);
+          await runOwnedWrite(driver, async (d) => {
+            await d.run(compiled2.sql, compiled2.params);
+            for (const row of before) {
+              await appendChange(
+                d,
+                state.table,
+                "delete",
+                String(row[OWNED_PK]),
+                toOwnerKey(row),
+                row,
+                null
+              );
+            }
+          });
+          return before.length;
+        }
+        const compiled = compileDelete(state.table, state.wheres, dialect);
+        return (await driver.run(compiled.sql, compiled.params)).changes;
+      }
+    };
+  };
+  return build(initialState);
+}
+var OPERATORS, LIST_OPERATORS;
+var init_table = __esm({
+  "packages/runtime/src/database/builder/table.ts"() {
+    "use strict";
+    init_identifier();
+    init_guards();
+    init_owned();
+    init_ulid();
+    OPERATORS = /* @__PURE__ */ new Set([
+      "=",
+      "!=",
+      ">",
+      ">=",
+      "<",
+      "<=",
+      "like",
+      "in",
+      "not in"
+    ]);
+    LIST_OPERATORS = /* @__PURE__ */ new Set(["in", "not in"]);
+  }
+});
+
+// packages/runtime/src/database/builder/index.ts
+function createCloudDb(driver, options = {}) {
+  const dialect = options.dialect ?? dialectFor(driver);
+  let txState = TX_STATES.get(driver);
+  if (txState === void 0) {
+    txState = { inTransaction: false };
+    TX_STATES.set(driver, txState);
+  }
+  const makeHandle = (handleOptions) => {
+    const guardWrite = () => {
+      if (txState !== void 0 && txState.inTransaction && !handleOptions.allowWriteDuringTx) {
+        throw unsafeOperation("\u4E8B\u52A1\u8FDB\u884C\u4E2D\uFF1A\u7981\u6B62\u5728\u4E8B\u52A1\u5916\u5BF9\u540C\u4E00\u9879\u76EE\u5E93\u6267\u884C\u5199\u64CD\u4F5C");
+      }
+    };
+    const handle = {
+      table(name) {
+        return createTableBuilder(name, driver, dialect, { guardWrite });
+      },
+      async transaction(fn) {
+        if (txState !== void 0 && txState.inTransaction) {
+          throw unsafeOperation("\u4E0D\u5141\u8BB8\u5D4C\u5957\u4E8B\u52A1\uFF1A\u4E8B\u52A1\u5185\u7981\u6B62\u518D\u6B21\u8C03\u7528 transaction()");
+        }
+        txState.inTransaction = true;
+        await driver.run("BEGIN");
+        const txHandle = makeHandle({ allowWriteDuringTx: true });
+        try {
+          const result = await fn(txHandle);
+          await driver.run("COMMIT");
+          return result;
+        } catch (error) {
+          await driver.run("ROLLBACK");
+          throw error;
+        } finally {
+          txState.inTransaction = false;
+        }
+      },
+      async query(sql, params) {
+        if (!Array.isArray(params)) {
+          throw unsafeOperation("query \u7684 params \u5FC5\u987B\u63D0\u4F9B\uFF08\u65E0\u53C2\u4F20 []\uFF09");
+        }
+        guardWrite();
+        assertReadOnlyQuery(sql);
+        return driver.all(sql, params);
+      },
+      async changes(table, query = {}) {
+        return readChanges(driver, table, query);
+      }
+    };
+    return handle;
+  };
+  return makeHandle({ allowWriteDuringTx: false });
+}
+var TX_STATES;
+var init_builder = __esm({
+  "packages/runtime/src/database/builder/index.ts"() {
+    "use strict";
+    init_dialect();
+    init_guards();
+    init_owned();
+    init_table();
+    TX_STATES = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// packages/runtime/src/database/sdk/cloud.ts
+import { randomUUID } from "node:crypto";
+function errorWithCode(error) {
+  const code = typeof error === "object" && error !== null && typeof error.code === "string" ? error.code : void 0;
+  if (code !== void 0 && error instanceof Error) {
+    return new Error(`[${code}] ${error.message}`);
+  }
+  return error;
+}
+function createDbCapability(driver, options = {}) {
+  const db = createCloudDb(driver);
+  const activeTxs = /* @__PURE__ */ new Map();
+  const guardTxWrite = (txId, terminal) => {
+    if (txId === void 0) {
+      if (activeTxs.size > 0 && WRITE_TERMINALS.has(terminal)) {
+        throw unsafeOperation("\u4E8B\u52A1\u8FDB\u884C\u4E2D\uFF1A\u7981\u6B62\u5728\u4E8B\u52A1\u5916\u5BF9\u540C\u4E00\u9879\u76EE\u5E93\u6267\u884C\u5199\u64CD\u4F5C");
+      }
+      return;
+    }
+    if (!activeTxs.has(txId)) {
+      throw unsafeOperation("\u5F15\u7528\u7684\u4E8B\u52A1\u5DF2\u7ED3\u675F\u6216\u4E0D\u5B58\u5728");
+    }
+  };
+  const runChain = async (request) => {
+    const tableName = request.rootArgs[0];
+    if (typeof tableName !== "string" && typeof tableName !== "number") {
+      throw unsafeOperation("table \u9700\u8981\u8868\u540D\u5B57\u7B26\u4E32");
+    }
+    let builder = db.table(String(tableName));
+    for (const step of request.steps) {
+      const invoke = builder[step.method];
+      if (typeof invoke !== "function") {
+        throw unsafeOperation(`\u4E91\u6570\u636E\u5E93\u4E0D\u652F\u6301\u94FE\u5F0F\u65B9\u6CD5 "${String(step.method)}"`);
+      }
+      builder = invoke(...step.args);
+    }
+    guardTxWrite(request.txId, request.terminal);
+    if (WRITE_TERMINALS.has(request.terminal) && options.beforeWrite !== void 0) {
+      await options.beforeWrite(driver);
+    }
+    const terminal = builder[request.terminal];
+    if (typeof terminal !== "function") {
+      throw unsafeOperation(`\u4E91\u6570\u636E\u5E93\u4E0D\u652F\u6301\u7EC8\u503C\u65B9\u6CD5 "${request.terminal}"`);
+    }
+    return terminal(...request.terminalArgs);
+  };
+  const handler = async (method, args) => {
+    try {
+      switch (method) {
+        case DB_RPC.query: {
+          const [sql, params] = args;
+          return await db.query(sql, params);
+        }
+        case DB_RPC.changes: {
+          const [table, query] = args;
+          return await db.changes(table, query);
+        }
+        case DB_RPC.begin: {
+          if (activeTxs.size > 0) throw unsafeOperation("\u4E0D\u5141\u8BB8\u5D4C\u5957\u4E8B\u52A1");
+          await driver.run("BEGIN");
+          const txId = randomUUID();
+          activeTxs.set(txId, true);
+          return txId;
+        }
+        case DB_RPC.commit: {
+          const [txId] = args;
+          if (!activeTxs.has(txId)) throw unsafeOperation("\u5F15\u7528\u7684\u4E8B\u52A1\u5DF2\u7ED3\u675F\u6216\u4E0D\u5B58\u5728");
+          activeTxs.delete(txId);
+          await driver.run("COMMIT");
+          return void 0;
+        }
+        case DB_RPC.rollback: {
+          const [txId] = args;
+          if (activeTxs.has(txId)) {
+            activeTxs.delete(txId);
+            await driver.run("ROLLBACK");
+          }
+          return void 0;
+        }
+        case DB_RPC.chain: {
+          const request = args[0];
+          return await runChain(request);
+        }
+        default:
+          throw new Error(`\u672A\u77E5\u7684 cloud.db \u65B9\u6CD5 "${String(method)}"`);
+      }
+    } catch (error) {
+      throw errorWithCode(error);
+    }
+  };
+  return {
+    capabilities: [{ name: "db", value: { [CHAIN_CAPABILITY_KEY]: CLOUD_DB_SPEC } }],
+    rpcHandlers: { db: handler }
+  };
+}
+var CLOUD_DB_SPEC, WRITE_TERMINALS;
+var init_cloud = __esm({
+  "packages/runtime/src/database/sdk/cloud.ts"() {
+    "use strict";
+    init_capability_keys();
+    init_builder();
+    init_guards();
+    CLOUD_DB_SPEC = {
+      kind: "cloud-db",
+      rootMethod: "table",
+      stepMethods: ["select", "where", "orderBy", "limit", "offset"],
+      terminalMethods: ["get", "first", "count", "insert", "insertMany", "update", "delete"],
+      directMethods: ["query", "changes"],
+      transactionMethod: "transaction"
+    };
+    WRITE_TERMINALS = /* @__PURE__ */ new Set(["insert", "insertMany", "update", "delete"]);
+  }
+});
+
+// packages/cli/src/sim/sql-engine.ts
+function ident(raw) {
+  return raw.trim().replace(/^"|"$/g, "").trim();
+}
+function toNumber(raw) {
+  const t = raw.trim();
+  if (t === "?") return null;
+  const n = Number(t);
+  return Number.isNaN(n) ? null : n;
+}
+function stripQuotes(raw) {
+  const t = raw.trim();
+  if (/^'.*'$/.test(t)) return t.slice(1, -1);
+  if (/^".*"$/.test(t)) return t.slice(1, -1);
+  return t;
+}
+function parseCreateTable(ddl) {
+  const m = /^CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?((?:"[^"]+")|([A-Za-z_][A-Za-z0-9_]*))\s*\(([\s\S]*)\)$/i.exec(
+    ddl.trim()
+  );
+  if (m === null) return null;
+  const name = ident(m[1]);
+  const body = m[2];
+  const columns = [];
+  for (const part of body.split(",")) {
+    const tokens = part.trim().split(/\s+/);
+    const colName = ident(tokens[0] ?? "");
+    const type = (tokens[1] ?? "TEXT").toUpperCase();
+    const primaryKey = tokens.includes("PRIMARY") && tokens.includes("KEY");
+    const autoincrement = primaryKey && tokens.includes("AUTOINCREMENT");
+    columns.push({ name: colName, type, primaryKey, autoincrement });
+  }
+  return { name, columns };
+}
+function parseWhereClauses(whereRaw, cursor) {
+  const clauses = [];
+  for (const part of whereRaw.split(/\s+AND\s+/i)) {
+    const t = part.trim();
+    if (t.length === 0) continue;
+    if (/\bIS\s+NULL\b/i.test(t)) {
+      const col2 = ident(t.split(/\s+IS\s+NULL\b/i)[0] ?? "");
+      clauses.push({ column: col2, operator: "IS NULL", value: null, list: false });
+      continue;
+    }
+    if (/\bIS\s+NOT\s+NULL\b/i.test(t)) {
+      const col2 = ident(t.split(/\s+IS\s+NOT\s+NULL\b/i)[0] ?? "");
+      clauses.push({ column: col2, operator: "IS NOT NULL", value: null, list: false });
+      continue;
+    }
+    const opMatch = /^\s*((?:"[^"]+")|([A-Za-z_][A-Za-z0-9_]*))\s*(=|!=|>=|<=|>|<|like|in|not\s+in)\s*(.+)$/i.exec(
+      t
+    );
+    if (opMatch === null) continue;
+    const col = ident(opMatch[1] ?? "");
+    const op = (opMatch[3] ?? opMatch[2] ?? "").toLowerCase();
+    const rhs = (opMatch[4] ?? "").trim();
+    if (op === "in" || op === "not in") {
+      const inner = rhs.replace(/^\(|\)$/g, "");
+      const items = splitListItems(inner);
+      const list = items.map((item) => {
+        if (item.trim() === "?") return cursor.take();
+        return stripQuotes(item);
+      });
+      clauses.push({ column: col, operator: op, value: list, list: true });
+      continue;
+    }
+    let value;
+    if (rhs === "?") {
+      value = cursor.take();
+    } else {
+      value = stripQuotes(rhs);
+    }
+    clauses.push({ column: col, operator: op, value, list: false });
+  }
+  return clauses;
+}
+function matchWhere(clauses, row) {
+  return clauses.every((c) => matchValue(row[c.column], c));
+}
+function splitListItems(inner) {
+  const items = [];
+  let depth = 0;
+  let buffer = "";
+  for (let i = 0; i < inner.length; i += 1) {
+    const ch = inner[i];
+    if (ch === "(") depth += 1;
+    else if (ch === ")") depth -= 1;
+    if (ch === "," && depth === 0) {
+      items.push(buffer);
+      buffer = "";
+    } else {
+      buffer += ch;
+    }
+  }
+  items.push(buffer);
+  return items;
+}
+function matchValue(value, clause) {
+  const op = clause.operator;
+  if (op === "IS NULL") return value === null || value === void 0;
+  if (op === "IS NOT NULL") return value !== null && value !== void 0;
+  if (op === "in") return clause.value.some((item) => value === item);
+  if (op === "not in") return !clause.value.some((item) => value === item);
+  if (op === "like") {
+    if (typeof value !== "string") return false;
+    const pattern = String(clause.value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/%/g, ".*").replace(/_/g, ".");
+    return new RegExp(`^${pattern}$`, "s").test(value);
+  }
+  const left = value;
+  const right = clause.value;
+  switch (op) {
+    case "=":
+      return left === right;
+    case "!=":
+      return left !== right;
+    case ">":
+      return left !== null && right !== null && left > right;
+    case ">=":
+      return left !== null && right !== null && left >= right;
+    case "<":
+      return left !== null && right !== null && left < right;
+    case "<=":
+      return left !== null && right !== null && left <= right;
+    default:
+      return false;
+  }
+}
+function assertReadOnly(sql) {
+  const stripped = sql.replace(/'[^']*(?:''[^']*)*'/g, "").replace(/"[^"]*(?:""[^"]*)*"/g, "").replace(/--[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+  if (stripped.includes(";")) throw new SimDbError("DB_UNSAFE_OP", "\u4EC5\u5141\u8BB8\u5355\u6761\u8BED\u53E5\uFF0C\u7981\u6B62\u591A\u8BED\u53E5\u5806\u53E0");
+  const head = stripped.trim().replace(/^\(+/, "").trim().toUpperCase();
+  if (!head.startsWith("SELECT") && !head.startsWith("WITH")) {
+    throw new SimDbError("DB_UNSAFE_OP", "cloud.db.query \u4EC5\u5141\u8BB8\u53EA\u8BFB\u67E5\u8BE2\uFF08SELECT / WITH\uFF09");
+  }
+  if (/ATTACH|DETACH/.test(stripped.toUpperCase())) {
+    throw new SimDbError("DB_UNSAFE_OP", "\u7981\u6B62\u8DE8\u5E93\u64CD\u4F5C\uFF08ATTACH / DETACH\uFF09");
+  }
+  if (/SQLITE_\w+/i.test(stripped) && !/SQLITE_MASTER\b/i.test(stripped)) {
+    throw new SimDbError("DB_UNSAFE_OP", "\u7981\u6B62\u8BBF\u95EE\u7CFB\u7EDF\u8868\uFF08sqlite_*\uFF09");
+  }
+}
+function indexAfter(start, matches, tail) {
+  const candidates = matches.filter((x) => x !== null && x.index > start).map((x) => x.index);
+  const end = candidates.length === 0 ? -1 : Math.min(...candidates);
+  return end === -1 ? tail.length : end;
+}
+function project(rows, selectRaw) {
+  if (/^count\s*\(\s*\*/i.test(selectRaw) || /^count\s*\(\s*1\)/i.test(selectRaw)) {
+    const alias = selectRaw.match(/\bAS\s+([A-Za-z_][A-Za-z0-9_]*)/i)?.[1] ?? "n";
+    return [{ [alias]: rows.length }];
+  }
+  const constMatch = /^(\d+)\s+AS\s+([A-Za-z_][A-Za-z0-9_]*)/i.exec(selectRaw);
+  if (constMatch !== null) {
+    return [{ [constMatch[2]]: Number(constMatch[1]) }];
+  }
+  if (selectRaw.trim() === "*") return rows;
+  const cols = selectRaw.split(",").map((s) => ident(s.trim()));
+  return rows.map((row) => {
+    const out = {};
+    for (const col of cols) out[col] = row[col];
+    return out;
+  });
+}
+var SimDbError, ParamCursor, SimSqlEngine;
+var init_sql_engine = __esm({
+  "packages/cli/src/sim/sql-engine.ts"() {
+    "use strict";
+    SimDbError = class extends Error {
+      constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "SimDbError";
+      }
+    };
+    ParamCursor = class {
+      constructor(params) {
+        this.params = params;
+      }
+      index = 0;
+      take() {
+        const v = this.params[this.index];
+        this.index += 1;
+        return v ?? null;
+      }
+    };
+    SimSqlEngine = class {
+      tables = {};
+      storage;
+      memoryOnly;
+      savepointDepth = 0;
+      txSnapshot = null;
+      constructor(options = {}) {
+        this.storage = options.storage ?? { load: async () => null, save: async () => void 0 };
+        this.memoryOnly = options.memoryOnly ?? false;
+      }
+      async load() {
+        if (this.memoryOnly) return;
+        const persisted = await this.storage.load();
+        if (persisted !== null) this.tables = persisted;
+      }
+      async persist() {
+        if (this.memoryOnly) return;
+        await this.storage.save(this.tables);
+      }
+      ensureTable(name) {
+        let table = this.tables[name];
+        if (table === void 0) {
+          table = { columns: [], rows: [], nextAutoincrement: 1 };
+          this.tables[name] = table;
+        }
+        return table;
+      }
+      applyAutoincrement(table, row) {
+        const pk = table.columns.find((c) => c.primaryKey && c.autoincrement);
+        if (pk === void 0) return;
+        const val = row[pk.name];
+        if (val !== null && val !== void 0) {
+          const n = Number(val);
+          if (Number.isInteger(n) && n >= table.nextAutoincrement) table.nextAutoincrement = n + 1;
+          return;
+        }
+        row[pk.name] = table.nextAutoincrement;
+        table.nextAutoincrement += 1;
+      }
+      catalog() {
+        const out = [];
+        for (const [name] of Object.entries(this.tables)) {
+          out.push({ type: "table", name, tbl_name: name });
+        }
+        return out;
+      }
+      async run(sql, params = []) {
+        const stmt = sql.trim();
+        if (/^BEGIN\s*$/i.test(stmt)) {
+          this.txSnapshot = structuredClone(this.tables);
+          return { changes: 0 };
+        }
+        if (/^COMMIT\s*$/i.test(stmt)) {
+          this.txSnapshot = null;
+          await this.persist();
+          return { changes: 0 };
+        }
+        if (/^ROLLBACK\s*$/i.test(stmt)) {
+          if (this.txSnapshot !== null) {
+            this.tables = this.txSnapshot;
+            this.txSnapshot = null;
+          }
+          await this.persist();
+          return { changes: 0 };
+        }
+        if (/^SAVEPOINT\s+/i.test(stmt)) {
+          this.savepointDepth += 1;
+          return { changes: 0 };
+        }
+        if (/^RELEASE\s+SAVEPOINT\s+/i.test(stmt)) {
+          this.savepointDepth = Math.max(0, this.savepointDepth - 1);
+          return { changes: 0 };
+        }
+        if (/^ROLLBACK\s+TO\s+SAVEPOINT\s+/i.test(stmt)) return { changes: 0 };
+        if (/^CREATE\s+TABLE/i.test(stmt)) {
+          const parsed = parseCreateTable(stmt);
+          if (parsed === null) throw new SimDbError("DB_UNSAFE_OP", `\u65E0\u6CD5\u89E3\u6790\u5EFA\u8868\u8BED\u53E5`);
+          if (this.tables[parsed.name] === void 0) {
+            this.tables[parsed.name] = { columns: parsed.columns, rows: [], nextAutoincrement: 1 };
+            await this.persist();
+          }
+          return { changes: 0 };
+        }
+        if (/^INSERT\s+INTO/i.test(stmt)) return this.execInsert(stmt, params);
+        if (/^UPDATE\s+/i.test(stmt)) return this.execUpdate(stmt, params);
+        if (/^DELETE\s+FROM/i.test(stmt)) return this.execDelete(stmt, params);
+        throw new SimDbError("DB_UNSAFE_OP", `sim SQL \u5F15\u64CE\u4E0D\u652F\u6301\u8BE5\u8BED\u53E5`);
+      }
+      execInsert(sql, params) {
+        const match = /^INSERT\s+INTO\s+((?:"[^"]+")|([A-Za-z_][A-Za-z0-9_]*))\s*\(([^)]*)\)\s*VALUES\s*([\s\S]+)$/i.exec(
+          sql
+        );
+        if (match === null) throw new SimDbError("DB_UNSAFE_OP", "\u65E0\u6CD5\u89E3\u6790 INSERT");
+        const tableName = ident(match[1]);
+        const cols = match[3].split(",").map(ident);
+        const valueBody = match[4].trim();
+        const cursor = new ParamCursor(params);
+        const table = this.ensureTable(tableName);
+        let inserted = 0;
+        for (const group of splitListItems(valueBody)) {
+          const inner = group.trim().replace(/^\(|\)$/g, "");
+          const values = splitListItems(inner).map(
+            (item) => item.trim() === "?" ? cursor.take() : stripQuotes(item)
+          );
+          const row = {};
+          cols.forEach((col, i) => {
+            row[col] = values[i] ?? null;
+          });
+          this.applyAutoincrement(table, row);
+          table.rows.push(row);
+          inserted += 1;
+        }
+        void this.persist();
+        return { changes: inserted };
+      }
+      execUpdate(sql, params) {
+        const match = /^UPDATE\s+((?:"[^"]+")|([A-Za-z_][A-Za-z0-9_]*))\s+SET\s+([\s\S]+?)\s+WHERE\s+([\s\S]+)$/i.exec(
+          sql
+        );
+        if (match === null) throw new SimDbError("DB_UNSAFE_OP", "UPDATE \u5FC5\u987B\u5E26 WHERE");
+        const tableName = ident(match[1]);
+        const setRaw = match[3];
+        const whereRaw = match[4];
+        const cursor = new ParamCursor(params);
+        const sets = splitListItems(setRaw).map((part) => {
+          const [col, , mark] = part.trim().split(/\s+/);
+          return { col: ident(col ?? ""), mark: mark ?? "?" };
+        });
+        const table = this.ensureTable(tableName);
+        const boundSets = sets.map((set) => ({
+          col: set.col,
+          value: set.mark === "?" ? cursor.take() : stripQuotes(set.mark)
+        }));
+        const whereClauses = parseWhereClauses(whereRaw, cursor);
+        let changes = 0;
+        for (const row of table.rows) {
+          if (!matchWhere(whereClauses, row)) continue;
+          for (const set of boundSets) {
+            row[set.col] = set.value;
+          }
+          changes += 1;
+        }
+        void this.persist();
+        return { changes };
+      }
+      execDelete(sql, params) {
+        const match = /^DELETE\s+FROM\s+((?:"[^"]+")|([A-Za-z_][A-Za-z0-9_]*))\s+WHERE\s+([\s\S]+)$/i.exec(sql);
+        if (match === null) throw new SimDbError("DB_UNSAFE_OP", "DELETE \u5FC5\u987B\u5E26 WHERE");
+        const tableName = ident(match[1]);
+        const whereRaw = match[3];
+        const cursor = new ParamCursor(params);
+        const table = this.ensureTable(tableName);
+        const whereClauses = parseWhereClauses(whereRaw, cursor);
+        const keep = [];
+        let changes = 0;
+        for (const row of table.rows) {
+          if (!matchWhere(whereClauses, row)) keep.push(row);
+          else changes += 1;
+        }
+        table.rows = keep;
+        void this.persist();
+        return { changes };
+      }
+      select(sql, params) {
+        const m = /^SELECT\s+([\s\S]+?)\s+FROM\s+((?:"[^"]+")|([A-Za-z_][A-Za-z0-9_]*))([\s\S]*)$/i.exec(
+          sql.trim()
+        );
+        if (m === null) throw new SimDbError("DB_UNSAFE_OP", "\u65E0\u6CD5\u89E3\u6790 SELECT");
+        const selectRaw = m[1].trim();
+        const tableName = ident(m[2]);
+        const tail = m[4] ?? "";
+        const cursor = new ParamCursor(params);
+        if (tableName.toLowerCase() === "sqlite_master") {
+          return project(this.catalog(), selectRaw);
+        }
+        const table = this.ensureTable(tableName);
+        const whereMatch = /\bWHERE\b/i.exec(tail);
+        const orderMatch = /\bORDER\s+BY\b/i.exec(tail);
+        const limitMatch = /\bLIMIT\b/i.exec(tail);
+        const offsetMatch = /\bOFFSET\b/i.exec(tail);
+        const whereRaw = whereMatch === null ? "" : tail.slice(
+          whereMatch.index + whereMatch[0].length,
+          indexAfter(whereMatch.index, [orderMatch, limitMatch, offsetMatch], tail)
+        );
+        let rows = table.rows;
+        if (whereRaw.trim().length > 0) {
+          const clauses = parseWhereClauses(whereRaw, cursor);
+          rows = rows.filter((row) => matchWhere(clauses, row));
+        }
+        if (orderMatch !== null) {
+          const orderRaw = tail.slice(
+            orderMatch.index + orderMatch[0].length,
+            indexAfter(orderMatch.index, [limitMatch, offsetMatch], tail)
+          );
+          const oc = /^\s*((?:"[^"]+")|([A-Za-z_][A-Za-z0-9_]*))\s+(asc|desc)/i.exec(orderRaw);
+          if (oc !== null) {
+            const col = ident(oc[1]);
+            const dir = oc[3].toLowerCase();
+            rows = [...rows].toSorted((a, b) => {
+              const av = a[col];
+              const bv = b[col];
+              const cmp = av === bv ? 0 : av === null ? -1 : bv === null ? 1 : av > bv ? 1 : -1;
+              return dir === "desc" ? -cmp : cmp;
+            });
+          }
+        }
+        if (limitMatch !== null) {
+          const limRaw = tail.slice(
+            limitMatch.index + limitMatch[0].length,
+            indexAfter(limitMatch.index, [offsetMatch], tail)
+          );
+          const lim = limRaw.trim() === "?" ? cursor.take() : toNumber(limRaw);
+          if (typeof lim === "number") rows = rows.slice(0, lim);
+        }
+        if (offsetMatch !== null) {
+          const offRaw = tail.slice(
+            offsetMatch.index + offsetMatch[0].length,
+            indexAfter(offsetMatch.index, [limitMatch], tail)
+          );
+          const off = offRaw.trim() === "?" ? cursor.take() : toNumber(offRaw);
+          if (typeof off === "number") rows = rows.slice(off);
+        }
+        return project(rows, selectRaw);
+      }
+      async all(sql, params = []) {
+        assertReadOnly(sql);
+        return this.select(sql, params);
+      }
+      async get(sql, params = []) {
+        assertReadOnly(sql);
+        return this.select(sql, params)[0] ?? null;
+      }
+      async close() {
+        void this.savepointDepth;
+      }
+    };
+  }
+});
+
+// packages/cli/src/sim/db.ts
+function toProjectDriver(engine) {
+  return {
+    engine: "sqlite",
+    run: (sql, params = []) => engine.run(sql, params),
+    all: (sql, params = []) => engine.all(sql, params),
+    get: (sql, params = []) => engine.get(sql, params),
+    close: () => engine.close()
+  };
+}
+function createSimDbCapability(options = {}) {
+  const engine = new SimSqlEngine({
+    storage: options.storage ?? { load: async () => null, save: async () => void 0 },
+    memoryOnly: options.storage === void 0
+  });
+  const driver = toProjectDriver(engine);
+  const bundle = createDbCapability(driver);
+  return { bundle, engine, driver };
+}
+var init_db = __esm({
+  "packages/cli/src/sim/db.ts"() {
+    "use strict";
+    init_cloud();
+    init_sql_engine();
+  }
+});
+
+// packages/runtime/src/storage/driver.ts
+function assertSafeStoragePath(path) {
+  if (typeof path !== "string" || path.length === 0) {
+    throw new StorageError(400, STORAGE_CODES.invalidPath, "\u5B58\u50A8\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  if (path.length > 1024) {
+    throw new StorageError(400, STORAGE_CODES.invalidPath, "\u5B58\u50A8\u8DEF\u5F84\u8FC7\u957F\uFF08\u4E0A\u9650 1024 \u5B57\u7B26\uFF09");
+  }
+  if (path.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path) || /[\0\r\n]/.test(path)) {
+    throw new StorageError(400, STORAGE_CODES.invalidPath, "\u5B58\u50A8\u8DEF\u5F84\u5FC5\u987B\u662F\u9879\u76EE\u6876\u5185\u7684\u76F8\u5BF9\u8DEF\u5F84");
+  }
+  const segments = path.split("/");
+  for (const segment of segments) {
+    if (segment === "" || segment === "." || segment === "..") {
+      throw new StorageError(
+        400,
+        STORAGE_CODES.invalidPath,
+        `\u5B58\u50A8\u8DEF\u5F84\u542B\u975E\u6CD5\u6BB5 "${segment}"\uFF08\u7981\u6B62\u7A7A\u6BB5 / . / .. \u7A7F\u8D8A\uFF09`
+      );
+    }
+    if (/[\\]/.test(segment)) {
+      throw new StorageError(400, STORAGE_CODES.invalidPath, "\u5B58\u50A8\u8DEF\u5F84\u7981\u6B62\u53CD\u659C\u6760");
+    }
+  }
+  return path;
+}
+var PROJECT_QUOTA_BYTES, StorageError, STORAGE_CODES;
+var init_driver = __esm({
+  "packages/runtime/src/storage/driver.ts"() {
+    "use strict";
+    PROJECT_QUOTA_BYTES = 1024 * 1024 * 1024;
+    StorageError = class extends Error {
+      constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "StorageError";
+      }
+    };
+    STORAGE_CODES = {
+      invalidPath: "STORAGE_INVALID_PATH",
+      notFound: "STORAGE_NOT_FOUND",
+      quotaExceeded: "STORAGE_QUOTA_EXCEEDED"
+    };
+  }
+});
+
+// packages/runtime/src/storage/signature.ts
+import { createHmac, timingSafeEqual } from "node:crypto";
+function sign(secret, projectId, path, expires) {
+  const payload = `${projectId}|${path}|${expires}`;
+  return createHmac("sha256", secret).update(payload).digest("hex");
+}
+function signDownloadUrl(config, projectId, path, ttlSeconds = DEFAULT_SIGN_TTL_SECONDS) {
+  const expires = Math.floor(Date.now() / 1e3) + ttlSeconds;
+  const base = `${config.baseUrl}/api/v1/projects/${encodeURIComponent(projectId)}/files/${encodeURIComponent(path)}`;
+  const signature = sign(config.secret, projectId, path, expires);
+  return `${base}?${SIGN_EXPIRES_KEY}=${expires}&${SIGN_SIGNATURE_KEY}=${signature}`;
+}
+var DEFAULT_SIGN_TTL_SECONDS, SIGN_EXPIRES_KEY, SIGN_SIGNATURE_KEY;
+var init_signature = __esm({
+  "packages/runtime/src/storage/signature.ts"() {
+    "use strict";
+    DEFAULT_SIGN_TTL_SECONDS = 15 * 60;
+    SIGN_EXPIRES_KEY = "x-expires";
+    SIGN_SIGNATURE_KEY = "x-signature";
+  }
+});
+
+// packages/runtime/src/storage/cloud.ts
+function asBytes(data) {
+  if (typeof data === "string") return new TextEncoder().encode(data);
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (data instanceof Uint8Array) return data;
+  const candidate = data;
+  if (candidate.data instanceof Uint8Array) return candidate.data;
+  throw new StorageError(400, STORAGE_CODES.invalidPath, "\u4E0D\u652F\u6301\u7684\u5B58\u50A8\u6570\u636E\u7C7B\u578B");
+}
+function toStoredFile(meta) {
+  return {
+    path: meta.path,
+    size: meta.size,
+    visibility: meta.visibility,
+    ...meta.contentType === void 0 ? {} : { contentType: meta.contentType },
+    ...meta.updatedAt === void 0 ? {} : { updatedAt: meta.updatedAt }
+  };
+}
+function createStorageCapability(driver, signer, projectId) {
+  const handler = async (method, args) => {
+    switch (method) {
+      case "upload": {
+        const [path, data] = args;
+        return toStoredFile(
+          await driver.put(projectId, path, asBytes(data), { visibility: DEFAULT_VISIBILITY })
+        );
+      }
+      case "get": {
+        const [path] = args;
+        return (await driver.get(projectId, path)).data;
+      }
+      case "remove": {
+        const [path] = args;
+        await driver.remove(projectId, path);
+        return void 0;
+      }
+      case "list": {
+        const [prefix] = args;
+        return (await driver.list(projectId, prefix)).map(toStoredFile);
+      }
+      case "getSignedUrl": {
+        const [path, ttlSeconds] = args;
+        return signDownloadUrl(signer, projectId, path, ttlSeconds);
+      }
+      default:
+        throw new StorageError(
+          400,
+          "STORAGE_INVALID_METHOD",
+          `\u672A\u77E5\u7684 cloud.storage \u65B9\u6CD5 "${method}"`
+        );
+    }
+  };
+  return {
+    capabilities: [{ name: "storage", value: { [RPC_CAPABILITY_KEY]: true } }],
+    rpcHandlers: { storage: handler }
+  };
+}
+var DEFAULT_VISIBILITY;
+var init_cloud2 = __esm({
+  "packages/runtime/src/storage/cloud.ts"() {
+    "use strict";
+    init_capability_keys();
+    init_driver();
+    init_signature();
+    DEFAULT_VISIBILITY = "private";
+  }
+});
+
+// packages/runtime/src/storage/driver/local.ts
+import { mkdir as mkdir4, readFile as readFile2, readdir, rm as rm2, stat as stat4, unlink, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname5, join as join5 } from "node:path";
+function createLocalStorageDriver(options) {
+  const quotaBytes = options.quotaBytes ?? PROJECT_QUOTA_BYTES;
+  const bucketDir = (projectId) => join5(options.dir, projectId);
+  const objectPath = (projectId, path) => join5(bucketDir(projectId), path);
+  const metaPath = (projectId, path) => join5(dirname5(objectPath(projectId, path)), `${path.split("/").pop() ?? ""}${META_SUFFIX}`);
+  const readStoredMeta = async (projectId, path) => {
+    const raw = await readFile2(metaPath(projectId, path), "utf8");
+    return JSON.parse(raw);
+  };
+  const writeStoredMeta = async (projectId, path, meta) => {
+    const payload = {
+      visibility: meta.visibility,
+      size: meta.size,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...meta.contentType === void 0 ? {} : { contentType: meta.contentType }
+    };
+    await writeFile3(metaPath(projectId, path), JSON.stringify(payload), "utf8");
+  };
+  const totalSize = async (projectId) => {
+    const root = bucketDir(projectId);
+    let total = 0;
+    const walk = async (dir) => {
+      let entries;
+      try {
+        entries = await readdir(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      const tasks = [];
+      for (const entry of entries) {
+        const full = join5(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 stat4(full);
+                total += info.size;
+              } catch {
+              }
+            })()
+          );
+        }
+      }
+      await Promise.all(tasks);
+    };
+    await walk(root);
+    return total;
+  };
+  return {
+    async put(projectId, path, data, putOptions) {
+      assertSafeStoragePath(path);
+      if (!(data instanceof Uint8Array)) {
+        throw new StorageError(400, "STORAGE_INVALID_PAYLOAD", "\u5199\u5165\u5185\u5BB9\u5FC5\u987B\u662F\u5B57\u8282\u6570\u7EC4");
+      }
+      const used = await totalSize(projectId);
+      let existingSize = 0;
+      try {
+        existingSize = (await stat4(objectPath(projectId, path))).size;
+      } catch {
+        existingSize = 0;
+      }
+      const projected = used - existingSize + data.byteLength;
+      if (options.quotaCheck !== void 0) {
+        await options.quotaCheck(projectId, projected);
+      } else if (projected > quotaBytes) {
+        throw new StorageError(
+          413,
+          STORAGE_CODES.quotaExceeded,
+          `\u9879\u76EE\u5B58\u50A8\u7A7A\u95F4\u4E0D\u8DB3\uFF1A\u914D\u989D ${quotaBytes} \u5B57\u8282\u5DF2\u7528\u5C3D\uFF08STORAGE_QUOTA_EXCEEDED\uFF09`
+        );
+      }
+      const dest = objectPath(projectId, path);
+      await mkdir4(dirname5(dest), { recursive: true });
+      await writeFile3(dest, data);
+      await writeStoredMeta(projectId, path, {
+        visibility: putOptions.visibility,
+        size: data.byteLength,
+        ...putOptions.contentType === void 0 ? {} : { contentType: putOptions.contentType }
+      });
+      const meta = await readStoredMeta(projectId, path);
+      return {
+        path,
+        size: meta.size,
+        visibility: meta.visibility,
+        updatedAt: meta.updatedAt,
+        ...meta.contentType === void 0 ? {} : { contentType: meta.contentType }
+      };
+    },
+    async get(projectId, path) {
+      assertSafeStoragePath(path);
+      let meta;
+      try {
+        meta = await readStoredMeta(projectId, path);
+      } catch {
+        throw new StorageError(404, STORAGE_CODES.notFound, `\u6587\u4EF6 "${path}" \u4E0D\u5B58\u5728`);
+      }
+      const data = await readFile2(objectPath(projectId, path));
+      const result = {
+        path,
+        size: meta.size,
+        visibility: meta.visibility,
+        updatedAt: meta.updatedAt,
+        ...meta.contentType === void 0 ? {} : { contentType: meta.contentType }
+      };
+      return { data, meta: result };
+    },
+    async getMeta(projectId, path) {
+      assertSafeStoragePath(path);
+      let meta;
+      try {
+        meta = await readStoredMeta(projectId, path);
+      } catch {
+        throw new StorageError(404, STORAGE_CODES.notFound, `\u6587\u4EF6 "${path}" \u4E0D\u5B58\u5728`);
+      }
+      const result = {
+        path,
+        size: meta.size,
+        visibility: meta.visibility,
+        updatedAt: meta.updatedAt,
+        ...meta.contentType === void 0 ? {} : { contentType: meta.contentType }
+      };
+      return result;
+    },
+    async remove(projectId, path) {
+      assertSafeStoragePath(path);
+      let exists = true;
+      try {
+        await stat4(objectPath(projectId, path));
+      } catch {
+        exists = false;
+      }
+      if (!exists) {
+        throw new StorageError(404, STORAGE_CODES.notFound, `\u6587\u4EF6 "${path}" \u4E0D\u5B58\u5728`);
+      }
+      await rm2(objectPath(projectId, path), { force: true });
+      await unlink(metaPath(projectId, path)).catch(() => void 0);
+    },
+    async list(projectId, prefix) {
+      if (prefix !== void 0 && prefix !== "") {
+        const segments = prefix.split("/");
+        if (prefix.startsWith("/") || /[\\]/.test(prefix) || segments.some((segment) => segment === "..")) {
+          throw new StorageError(
+            400,
+            STORAGE_CODES.invalidPath,
+            `\u975E\u6CD5\u524D\u7F00 "${prefix}"\uFF08\u7981\u6B62 / \u5F00\u5934\u3001\u53CD\u659C\u6760\u6216 .. \u7A7F\u8D8A\uFF09`
+          );
+        }
+      }
+      const root = bucketDir(projectId);
+      const metas = [];
+      const walk = async (dir, relative2) => {
+        let entries;
+        try {
+          entries = await readdir(dir, { withFileTypes: true });
+        } catch {
+          return;
+        }
+        const tasks = [];
+        for (const entry of entries) {
+          if (entry.name.endsWith(META_SUFFIX)) continue;
+          const full = join5(dir, entry.name);
+          const rel = relative2 === "" ? entry.name : `${relative2}/${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")
+                  );
+                  metas.push({
+                    path: rel,
+                    size: payload.size,
+                    visibility: payload.visibility,
+                    updatedAt: payload.updatedAt,
+                    ...payload.contentType === void 0 ? {} : { contentType: payload.contentType }
+                  });
+                } catch {
+                }
+              })()
+            );
+          } else if (entry.isDirectory()) {
+            if (prefix !== void 0 && !rel.startsWith(prefix)) {
+              const subIncluded = prefix.startsWith(rel + "/") || rel.startsWith(prefix);
+              if (!subIncluded) continue;
+            }
+            tasks.push(walk(full, rel));
+          }
+        }
+        await Promise.all(tasks);
+      };
+      await walk(root, "");
+      metas.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+      return metas;
+    },
+    async usage(projectId) {
+      return totalSize(projectId);
+    }
+  };
+}
+var META_SUFFIX;
+var init_local = __esm({
+  "packages/runtime/src/storage/driver/local.ts"() {
+    "use strict";
+    init_driver();
+    META_SUFFIX = ".adep-meta.json";
+  }
+});
+
+// packages/cli/src/sim/storage.ts
+import { join as join6 } from "node:path";
+function createSimStorageCapability(options) {
+  const dir = join6(options.cwd, ".adep", "sim", "storage");
+  const driver = createLocalStorageDriver({ dir });
+  const signer = {
+    secret: options.secret ?? "adep-sim-secret",
+    baseUrl: options.baseUrl ?? "http://127.0.0.1:8787"
+  };
+  const bundle = createStorageCapability(driver, signer, options.projectId ?? "sim-project");
+  return { bundle, driver };
+}
+var init_storage = __esm({
+  "packages/cli/src/sim/storage.ts"() {
+    "use strict";
+    init_cloud2();
+    init_local();
+  }
+});
+
+// packages/cli/src/sim/realtime.ts
+var SimRealtime;
+var init_realtime = __esm({
+  "packages/cli/src/sim/realtime.ts"() {
+    "use strict";
+    SimRealtime = class {
+      seq = 0;
+      subscribers = /* @__PURE__ */ new Map();
+      /** 向某 channel 广播一条消息；返回被投递的连接数（单进程内）。 */
+      publish(channel, data, publisher) {
+        this.seq += 1;
+        const message = {
+          channel,
+          seq: this.seq,
+          data,
+          publishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          ...publisher === void 0 ? {} : { publisher }
+        };
+        const set = this.subscribers.get(channel);
+        if (set === void 0) return { delivered: 0 };
+        let delivered = 0;
+        for (const listener of set) {
+          listener(message);
+          delivered += 1;
+        }
+        return { delivered };
+      }
+      /** 订阅某 channel；返回退订函数。 */
+      subscribe(channel, listener) {
+        let set = this.subscribers.get(channel);
+        if (set === void 0) {
+          set = /* @__PURE__ */ new Set();
+          this.subscribers.set(channel, set);
+        }
+        set.add(listener);
+        return () => {
+          set?.delete(listener);
+        };
+      }
+      /** 当前有订阅者的 channel 数（调试用）。 */
+      channelCount() {
+        return this.subscribers.size;
+      }
+    };
+  }
+});
+
+// packages/cli/src/sim/runtime.ts
+import { mkdir as mkdir5, readFile as readFile3, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname6, join as join7 } from "node:path";
+function simDir(cwd) {
+  return join7(cwd, ".adep", "sim");
+}
+function mergeBundles(bundles) {
+  const capabilities = [];
+  const byName = /* @__PURE__ */ new Map();
+  for (const bundle of bundles) {
+    for (const cap of bundle.capabilities) {
+      const existing = byName.get(cap.name);
+      if (existing !== void 0) capabilities.splice(capabilities.indexOf(existing), 1);
+      byName.set(cap.name, cap);
+      capabilities.push(cap);
+    }
+  }
+  const rpcHandlers = {};
+  for (const bundle of bundles) {
+    for (const [name, handler] of Object.entries(bundle.rpcHandlers)) {
+      rpcHandlers[name] = handler;
+    }
+  }
+  return { capabilities, rpcHandlers };
+}
+function jsonStorage(cwd) {
+  const file = join7(simDir(cwd), "db.json");
+  return {
+    async load() {
+      try {
+        const raw = await readFile3(file, "utf8");
+        return JSON.parse(raw);
+      } catch {
+        return null;
+      }
+    },
+    async save(tables) {
+      await mkdir5(dirname6(file), { recursive: true });
+      await writeFile4(file, JSON.stringify(tables), "utf8");
+    }
+  };
+}
+async function createSimRuntime(options) {
+  const db = createSimDbCapability({
+    storage: options.dbStorage ?? jsonStorage(options.cwd),
+    ...options.log === void 0 ? {} : { log: options.log }
+  });
+  const storage = createSimStorageCapability({
+    cwd: options.cwd,
+    ...options.baseUrl === void 0 ? {} : { baseUrl: options.baseUrl },
+    projectId: options.projectId ?? "local"
+  });
+  const realtime = new SimRealtime();
+  const bundle = mergeBundles([db.bundle, storage.bundle]);
+  await db.engine.load();
+  return {
+    bundle,
+    realtime,
+    db,
+    dispose: async () => {
+      await db.driver.close();
+    }
+  };
+}
+var init_runtime = __esm({
+  "packages/cli/src/sim/runtime.ts"() {
+    "use strict";
+    init_db();
+    init_storage();
+    init_realtime();
+  }
+});
+
+// packages/cli/src/sim/env.ts
+import { readFile as readFile4 } from "node:fs/promises";
+import { join as join8 } from "node:path";
+function parseEnv(content) {
+  const env = {};
+  for (const raw of content.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line.length === 0 || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq === -1) continue;
+    const key = line.slice(0, eq).trim();
+    if (key.length === 0) continue;
+    env[key] = line.slice(eq + 1).trim();
+  }
+  return env;
+}
+async function loadSimEnv(cwd, config = {}) {
+  const envRoot = await readFile4(join8(cwd, ".env"), "utf8").catch(() => "");
+  const envLocal = await readFile4(join8(cwd, ".env.local"), "utf8").catch(() => "");
+  const merged = { ...parseEnv(envRoot), ...parseEnv(envLocal) };
+  for (const secret of config.secrets ?? []) {
+    if (merged[secret] !== void 0) continue;
+    if (process.env[secret] !== void 0) {
+      merged[secret] = process.env[secret];
+      continue;
+    }
+    throw new Error(
+      `secret "${secret}" \u672A\u914D\u7F6E\uFF1A\u8BF7\u5728 .env.local \u6DFB\u52A0 ${secret}=<value>\uFF0C\u6216\u7528\u73AF\u5883\u53D8\u91CF\u5BFC\u51FA\u540E\u91CD\u8BD5 adep dev\uFF08\u6A21\u62DF\u73AF\u5883\u6C38\u4E0D\u843D\u76D8\u8BE5\u503C\uFF09`
+    );
+  }
+  return merged;
+}
+var init_env = __esm({
+  "packages/cli/src/sim/env.ts"() {
+    "use strict";
+  }
+});
+
+// packages/cli/src/sim/invoke.ts
+function createSimInvokeHandler(options) {
+  return async (method, args) => {
+    if (method !== "invoke") {
+      throw new Error(`\u672A\u77E5\u7684 cloud.invoke \u65B9\u6CD5 "${method}"`);
+    }
+    const input = args[0];
+    if (typeof input?.name !== "string" || input.name.length === 0) {
+      throw new Error("cloud.invoke \u9700\u8981\u76EE\u6807\u51FD\u6570\u540D\uFF08InvokeInput.name\uFF09");
+    }
+    const targetEntry = `${input.name}.ts`;
+    const executeInput = {
+      project: { id: "local", slug: "local" },
+      fn: { id: input.name, name: input.name },
+      files: options.files,
+      entry: targetEntry,
+      request: {
+        method: "POST",
+        path: `/${input.name}`,
+        query: input.query ?? {},
+        headers: {},
+        ...input.body === void 0 ? {} : { body: input.body }
+      },
+      timeoutMs: 1e4,
+      ...options.env === void 0 ? {} : { env: options.env }
+    };
+    const result = await options.executor.execute(executeInput);
+    return result.body;
+  };
+}
+var init_invoke = __esm({
+  "packages/cli/src/sim/invoke.ts"() {
+    "use strict";
+  }
+});
+
+// packages/cli/src/sim/boundary.ts
+var SIM_BOUNDARIES;
+var init_boundary = __esm({
+  "packages/cli/src/sim/boundary.ts"() {
+    "use strict";
+    SIM_BOUNDARIES = [
+      {
+        kind: "capability",
+        title: "\u89E6\u53D1\u5668\u4E0D\u81EA\u52A8\u6267\u884C",
+        detail: "\u5B9A\u65F6 / \u4E8B\u4EF6\u89E6\u53D1\u5668\u53EA\u767B\u8BB0\uFF0C\u4E0D\u7531\u6A21\u62DF\u5668\u81EA\u52A8\u89E6\u53D1\uFF08\u672C\u5730\u4EE5\u624B\u5DE5 HTTP \u8C03\u7528\u66FF\u4EE3\uFF09\u3002"
+      },
+      {
+        kind: "diff",
+        title: "\u65E0\u8DE8\u5B9E\u4F8B\u5E7F\u64AD",
+        detail: "realtime \u4E3A\u5355\u8FDB\u7A0B\u5185\u5B58\u5E7F\u64AD\uFF1A\u4E0D\u652F\u6301\u8DE8\u8FDB\u7A0B / \u8DE8\u5B9E\u4F8B\uFF0C\u7EBF\u4E0A\u591A\u5B9E\u4F8B\u8BED\u4E49\u4E0D\u540C\u3002"
+      },
+      {
+        kind: "capability",
+        title: "\u65E0\u9650\u989D\u7B49\u4EF7",
+        detail: "\u672C\u5730\u4E0D\u6267\u884C\u8BA1\u91CF / \u914D\u989D\u95E8\u7981\uFF08\u4E0D\u6309\u51FD\u6570\u8C03\u7528\u3001\u6D41\u91CF\u3001\u63A8\u9001\u8BA1\u6570\uFF09\uFF0C\u9650\u989D\u8BED\u4E49\u4EC5\u7EBF\u4E0A\u751F\u6548\u3002"
+      },
+      {
+        kind: "diff",
+        title: "\u4E0D\u8BA1\u91CF",
+        detail: "\u672C\u6A21\u62DF\u8FD0\u884C\u65F6\u4E0D\u4EA7\u51FA\u8BA1\u91CF\u4E8B\u4EF6\uFF0C\u4E5F\u4E0D\u5199 billing\uFF1B\u79BB\u7EBF\u5F00\u53D1\u4E0D\u8BA1\u8D39\u3002"
+      }
+    ];
+  }
+});
+
+// packages/cli/src/dev.ts
+var dev_exports = {};
+__export(dev_exports, {
+  loadConfig: () => loadConfig,
+  parseEnvFile: () => parseEnvFile,
+  startDevServer: () => startDevServer
+});
+import { createServer } from "node:http";
+import { watch } from "node:fs";
+import { mkdir as mkdir6, readdir as readdir2, readFile as readFile5, stat as stat5, writeFile as writeFile5 } from "node:fs/promises";
+import { basename, join as join9, resolve as resolve5 } from "node:path";
+async function loadConfig(cwd) {
+  const name = basename(resolve5(cwd));
+  const configPath = join9(cwd, "adep.config.ts");
+  try {
+    await stat5(configPath);
+  } catch {
+    return { name, functionsDir: "functions" };
+  }
+  const bun = globalThis.Bun;
+  if (bun === void 0) return { name, functionsDir: "functions" };
+  try {
+    const mod = await import(configPath);
+    return {
+      name: mod.default?.name ?? name,
+      functionsDir: mod.default?.functionsDir ?? "functions"
+    };
+  } catch {
+    return { name, functionsDir: "functions" };
+  }
+}
+function parseEnvFile(content) {
+  const env = {};
+  for (const raw of content.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line.length === 0 || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq === -1) continue;
+    const key = line.slice(0, eq).trim();
+    if (key.length === 0) continue;
+    env[key] = line.slice(eq + 1).trim();
+  }
+  return env;
+}
+async function collectFunctions(dir) {
+  const files = {};
+  const walk = async (sub, prefix) => {
+    let entries;
+    try {
+      entries = await readdir2(sub, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const rel = prefix.length === 0 ? entry.name : `${prefix}/${entry.name}`;
+      const full = join9(sub, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full, rel);
+      } else if (entry.isFile() && entry.name.endsWith(".ts")) {
+        files[rel] = await readFile5(full, "utf8");
+      }
+    }
+  };
+  await walk(dir, "");
+  return files;
+}
+function bodyOf(req) {
+  return new Promise((resolveBody, rejectBody) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString("utf8");
+      if (raw.length === 0) {
+        resolveBody(void 0);
+        return;
+      }
+      try {
+        resolveBody(JSON.parse(raw));
+      } catch {
+        resolveBody(raw);
+      }
+    });
+    req.on("error", rejectBody);
+  });
+}
+function writeJson(res, status, payload) {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(payload));
+}
+function printBoundaries(log) {
+  log("[adep] \u80FD\u529B\u8FB9\u754C\uFF08\u6A21\u62DF\u8FD0\u884C\u65F6\u53EA\u66FF\u6362\u4F20\u8F93/\u6301\u4E45\u5316\uFF0C\u4E0D\u6539\u5199\u8BED\u4E49\uFF09\uFF1A");
+  for (const b of SIM_BOUNDARIES) {
+    log(`[adep]   - [${b.kind}] ${b.title}\uFF1A${b.detail}`);
+  }
+}
+async function ensureGitignore(cwd) {
+  const gitignorePath = join9(cwd, ".gitignore");
+  const existing = await readFile5(gitignorePath, "utf8").catch(() => "");
+  if (existing.split(/\r?\n/).includes(".adep/")) return;
+  await writeFile5(gitignorePath, `${existing.replace(/\n+$/, "")}
+.adep/
+`, "utf8");
+}
+async function startDevServer(options) {
+  const cwd = resolve5(options.cwd);
+  const log = options.log ?? ((line) => process.stdout.write(`${line}
+`));
+  const config = await loadConfig(cwd);
+  const functionsDir = join9(cwd, config.functionsDir);
+  const coldStartAt = Date.now();
+  const executor = new WorkerFunctionExecutor();
+  await mkdir6(functionsDir, { recursive: true });
+  const runtime = await createSimRuntime({
+    cwd,
+    projectId: "local",
+    baseUrl: `http://127.0.0.1:${options.port ?? 8787}`,
+    log
+  });
+  await ensureGitignore(cwd);
+  let files = await collectFunctions(functionsDir);
+  let env = await loadSimEnv(cwd).catch(() => ({}));
+  const dbBundle = runtime.bundle;
+  const invokeHandler = createSimInvokeHandler({ executor, files });
+  const reload = async () => {
+    const [nextFiles, envText2] = await Promise.all([
+      collectFunctions(functionsDir),
+      readFile5(join9(cwd, ".env.local"), "utf8").catch(() => "")
+    ]);
+    files = nextFiles;
+    env = parseEnvFile(envText2);
+  };
+  const envText = await readFile5(join9(cwd, ".env.local"), "utf8").catch(() => "");
+  env = parseEnvFile(envText);
+  let debounceTimer;
+  let watcher;
+  try {
+    watcher = watch(cwd, { recursive: true }, () => {
+      if (debounceTimer !== void 0) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => {
+        void reload();
+      }, 120);
+    });
+  } catch {
+    watcher = void 0;
+  }
+  const buildInput = async (fnName, url, req) => {
+    const query = {};
+    for (const key of new Set(url.searchParams.keys())) {
+      const values = url.searchParams.getAll(key);
+      query[key] = values.length > 1 ? values.join(",") : values[0] ?? "";
+    }
+    const headers = {};
+    for (const [key, value] of Object.entries(req.headers)) {
+      if (typeof value === "string") headers[key] = value;
+    }
+    const body = req.method === "GET" || req.method === "HEAD" ? void 0 : await bodyOf(req);
+    const hasEnv = Object.keys(env).length > 0;
+    return {
+      project: { id: "local", slug: config.name },
+      fn: { id: fnName, name: fnName },
+      files,
+      entry: `${fnName}.ts`,
+      request: {
+        method: req.method ?? "GET",
+        path: url.pathname,
+        query,
+        headers,
+        ...body === void 0 ? {} : { body }
+      },
+      // 模拟运行时能力：db / storage / realtime 各自只读复用线上装配，语义一致。
+      capabilities: dbBundle.capabilities,
+      rpcHandlers: {
+        ...dbBundle.rpcHandlers,
+        invoke: invokeHandler
+      },
+      timeoutMs: 1e4,
+      ...hasEnv ? { env } : {}
+    };
+  };
+  const handle = async (req, res) => {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    const fnName = url.pathname.split("/").find((segment) => segment.length > 0);
+    if (fnName === void 0) {
+      writeJson(res, 400, {
+        error: { code: "FN_NAME_REQUIRED", message: "\u4EE5 /{fnName} \u8C03\u7528\u672C\u5730\u51FD\u6570" }
+      });
+      return;
+    }
+    const entry = `${fnName}.ts`;
+    const source = files[entry];
+    if (source === void 0) {
+      log(`[adep] ${req.method ?? "GET"} /${fnName} -> 404\uFF08\u51FD\u6570\u4E0D\u5B58\u5728\uFF09`);
+      writeJson(res, 404, { error: { code: "FN_NOT_FOUND", message: `\u51FD\u6570 "${fnName}" \u4E0D\u5B58\u5728` } });
+      return;
+    }
+    const input = await buildInput(fnName, url, req);
+    const startedAt = performance.now();
+    try {
+      const result = await executor.execute(input);
+      const durationMs = Math.round(performance.now() - startedAt);
+      log(`[adep] ${req.method ?? "GET"} /${fnName} -> 200 ${durationMs}ms`);
+      for (const line of result.logs) log(`[adep]   ${line}`);
+      writeJson(res, 200, result.body === void 0 ? null : result.body);
+    } catch (error) {
+      const durationMs = Math.round(performance.now() - startedAt);
+      if (error instanceof ExecutorError) {
+        log(
+          `[adep] ${req.method ?? "GET"} /${fnName} -> ${error.status} ${durationMs}ms (${error.code})`
+        );
+        writeJson(res, error.status, { error: { code: error.code, message: error.message } });
+        return;
+      }
+      log(`[adep] ${req.method ?? "GET"} /${fnName} -> 500 ${durationMs}ms`);
+      writeJson(res, 500, {
+        error: {
+          code: "FN_EXEC_ERROR",
+          message: error instanceof Error ? error.message : "\u51FD\u6570\u6267\u884C\u5931\u8D25"
+        }
+      });
+    }
+  };
+  const server = createServer((req, res) => {
+    void handle(req, res);
+  });
+  const port = options.port ?? 8787;
+  await new Promise((resolveListen, rejectListen) => {
+    server.once("error", rejectListen);
+    server.listen(port, "127.0.0.1", () => {
+      server.off("error", rejectListen);
+      resolveListen();
+    });
+  });
+  const address = server.address();
+  const actualPort = typeof address === "object" && address !== null ? address.port : port;
+  const baseUrl = `http://127.0.0.1:${actualPort}`;
+  const coldStartMs = Date.now() - coldStartAt;
+  log(`[adep] dev server listening on ${baseUrl}\uFF08\u6A21\u62DF\u8FD0\u884C\u65F6\uFF0C\u51B7\u542F\u52A8 ${coldStartMs}ms\uFF09`);
+  log(`[adep] curl \u793A\u4F8B\uFF1Acurl ${baseUrl}/hello`);
+  printBoundaries(log);
+  log(`[adep] \u6A21\u62DF\u6570\u636E\u76EE\u5F55\uFF1A${simDir(cwd)}`);
+  return {
+    port: actualPort,
+    baseUrl,
+    close: async () => {
+      if (debounceTimer !== void 0) clearTimeout(debounceTimer);
+      watcher?.close();
+      await new Promise((resolveClose) => server.close(() => resolveClose()));
+      await executor.dispose();
+      await runtime.dispose();
+    }
+  };
+}
+var init_dev = __esm({
+  "packages/cli/src/dev.ts"() {
+    "use strict";
+    init_executor();
+    init_worker_executor();
+    init_runtime();
+    init_env();
+    init_invoke();
+    init_boundary();
+  }
+});
+
+// packages/cli/src/client.ts
+async function envelopeError(response, fallbackCode, parsed) {
+  const payload = parsed ?? null;
+  return new CliError(
+    payload?.error?.code ?? fallbackCode,
+    payload?.error?.message ?? `\u5E73\u53F0\u8FD4\u56DE HTTP ${response.status}`
+  );
+}
+async function parseBody(response) {
+  const text = await response.text();
+  if (text.length === 0) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+async function createClient(paths) {
+  const credentials = await loadCredentials(paths);
+  if (credentials === null) {
+    throw new CliError("NOT_LOGGED_IN", "\u672A\u767B\u5F55\uFF1A\u8BF7\u5148\u6267\u884C adep login");
+  }
+  const server = credentials.server;
+  const cookie = `better-auth.session_token=${decodeToken(credentials.encodedToken)}`;
+  const request = async (path, init = {}, fallbackCode = "API_REQUEST_FAILED") => {
+    const method = init.method ?? (init.body === void 0 ? "GET" : "POST");
+    let response;
+    try {
+      response = await fetch(`${server}${path}`, {
+        method,
+        headers: { "content-type": "application/json", cookie },
+        ...init.body === void 0 ? {} : { body: JSON.stringify(init.body) }
+      });
+    } catch (error) {
+      throw new CliError(
+        "SERVER_UNREACHABLE",
+        `\u65E0\u6CD5\u8FDE\u63A5\u5E73\u53F0 ${server}\uFF1A${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    const parsed = await parseBody(response);
+    if (response.status < 200 || response.status >= 300) {
+      throw await envelopeError(response, fallbackCode, parsed);
+    }
+    return parsed;
+  };
+  const upload = async (path, form, fallbackCode = "UPLOAD_FAILED") => {
+    let response;
+    try {
+      response = await fetch(`${server}${path}`, {
+        method: "POST",
+        headers: { cookie },
+        body: form
+      });
+    } catch (error) {
+      throw new CliError(
+        "SERVER_UNREACHABLE",
+        `\u65E0\u6CD5\u8FDE\u63A5\u5E73\u53F0 ${server}\uFF1A${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    if (response.status < 200 || response.status >= 300) {
+      throw await envelopeError(response, fallbackCode, await parseBody(response));
+    }
+    return response;
+  };
+  const download = async (url, fallbackCode = "DOWNLOAD_FAILED") => {
+    const target = url.startsWith("http") ? url : `${server}${url}`;
+    let response;
+    try {
+      response = await fetch(target, { headers: { cookie } });
+    } catch (error) {
+      throw new CliError(
+        "SERVER_UNREACHABLE",
+        `\u65E0\u6CD5\u8FDE\u63A5\u5E73\u53F0 ${server}\uFF1A${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    if (response.status < 200 || response.status >= 300) {
+      throw await envelopeError(response, fallbackCode, await parseBody(response));
+    }
+    return response;
+  };
+  return { server, cookie, request, upload, download };
+}
+async function resolveSlug(cwd, slug) {
+  if (slug !== void 0 && slug.length > 0) return slug;
+  const config = await loadConfig(cwd);
+  return config.name;
+}
+var init_client = __esm({
+  "packages/cli/src/client.ts"() {
+    "use strict";
+    init_auth();
+    init_credentials();
+    init_dev();
+  }
+});
+
+// packages/cli/src/deploy.ts
+var deploy_exports = {};
+__export(deploy_exports, {
+  collectEntries: () => collectEntries,
+  deploy: () => deploy
+});
+import { createHash as createHash3 } from "node:crypto";
+import { readdir as readdir3, readFile as readFile6 } from "node:fs/promises";
+import { join as join10, resolve as resolve6, basename as basename2 } from "node:path";
+async function collectEntries(functionsDir) {
+  const entries = {};
+  let names;
+  try {
+    const dirents = await readdir3(functionsDir, { withFileTypes: true });
+    names = dirents.filter((entry) => entry.isFile() && entry.name.endsWith(".ts")).map((entry) => basename2(entry.name, ".ts")).toSorted();
+  } catch {
+    return entries;
+  }
+  for (const name of names) {
+    entries[name] = await readFile6(join10(functionsDir, `${name}.ts`), "utf8");
+  }
+  return entries;
+}
+function sha256Hex(content) {
+  return createHash3("sha256").update(content).digest("hex");
+}
+async function deploy(paths, options) {
+  const log = options.log ?? ((line) => process.stdout.write(`${line}
+`));
+  const client = await createClient(paths);
+  const cwd = resolve6(options.cwd);
+  const config = await loadConfig(cwd);
+  const slug = options.slug ?? config.name;
+  const functionsDir = join10(cwd, config.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`);
+  }
+  const remote = await client.request(
+    "/api/v1/deploy/diff",
+    {
+      body: {
+        slug,
+        functions: Object.entries(local).map(([name, content]) => ({
+          name,
+          files: { "index.ts": sha256Hex(content) }
+        }))
+      }
+    },
+    "DEPLOY_FAILED"
+  );
+  const baseUrl = `${remote.scheme}://${remote.slug}.${remote.domain}`;
+  const deployed = [];
+  for (const item of remote.functions) {
+    const content = local[item.name];
+    if (item.action === "none") {
+      deployed.push({
+        name: item.name,
+        action: "none",
+        version: item.version ?? 0,
+        url: `${baseUrl}/${item.name}`
+      });
+      continue;
+    }
+    log(`[adep] \u90E8\u7F72 ${item.name}\uFF08${item.action === "create" ? "\u65B0\u5EFA" : "\u53D8\u66F4"}\uFF09`);
+    let functionId = item.id;
+    if (functionId === null) {
+      const created = await client.request(
+        `/api/v1/projects/${remote.projectId}/functions`,
+        {
+          body: { name: item.name, files: { "index.ts": content } }
+        }
+      );
+      functionId = created.id;
+    } else {
+      await client.request(`/api/v1/projects/${remote.projectId}/functions/${item.name}`, {
+        method: "PATCH",
+        body: { files: { "index.ts": content } }
+      });
+    }
+    const published = await client.request(
+      `/api/v1/functions/${functionId}/publish`,
+      { method: "POST" }
+    );
+    deployed.push({
+      name: item.name,
+      action: item.action,
+      version: published.version,
+      url: `${baseUrl}/${item.name}`
+    });
+  }
+  return {
+    projectId: remote.projectId,
+    slug: remote.slug,
+    baseUrl,
+    noChanges: deployed.every((function_) => function_.action === "none"),
+    functions: deployed
+  };
+}
+var init_deploy = __esm({
+  "packages/cli/src/deploy.ts"() {
+    "use strict";
+    init_auth();
+    init_client();
+    init_dev();
+  }
+});
+
+// packages/cli/src/db.ts
+var db_exports = {};
+__export(db_exports, {
+  dbExec: () => dbExec,
+  dbRollback: () => dbRollback,
+  dbSnapshotCreate: () => dbSnapshotCreate,
+  dbSnapshotList: () => dbSnapshotList,
+  dbSnapshotRestore: () => dbSnapshotRestore,
+  dbStart: () => dbStart,
+  dbStatus: () => dbStatus,
+  dbStop: () => dbStop
+});
+import { resolve as resolve7 } from "node:path";
+async function open2(paths, options) {
+  const client = await createClient(paths);
+  const project2 = await resolveSlug(resolve7(options.cwd), options.slug);
+  return { client, project: project2 };
+}
+async function dbStart(paths, options) {
+  const { client, project: project2 } = await open2(paths, options);
+  return client.request(`/api/v1/projects/${project2}/database`, { method: "POST" });
+}
+async function dbStatus(paths, options) {
+  const { client, project: project2 } = await open2(paths, options);
+  return client.request(`/api/v1/projects/${project2}/database`);
+}
+async function dbStop(paths, options) {
+  const { client, project: project2 } = await open2(paths, options);
+  return client.request(`/api/v1/projects/${project2}/database`, {
+    method: "DELETE"
+  });
+}
+async function dbExec(paths, options) {
+  const { client, project: project2 } = await open2(paths, options);
+  return client.request(
+    `/api/v1/projects/${project2}/database/console/sql`,
+    {
+      method: "POST",
+      body: {
+        sql: options.sql,
+        ...options.params === void 0 ? {} : { params: options.params },
+        ...options.confirmTable === void 0 ? {} : { confirmTable: options.confirmTable }
+      }
+    },
+    "SQL_EXEC_FAILED"
+  );
+}
+async function dbSnapshotList(paths, options) {
+  const { client, project: project2 } = await open2(paths, options);
+  return client.request(
+    `/api/v1/projects/${project2}/database/snapshots`
+  );
+}
+async function dbSnapshotCreate(paths, options) {
+  const { client, project: project2 } = await open2(paths, options);
+  return client.request(`/api/v1/projects/${project2}/database/snapshots`, {
+    method: "POST"
+  });
+}
+async function dbSnapshotRestore(paths, options) {
+  const { client, project: project2 } = await open2(paths, options);
+  return client.request(
+    `/api/v1/projects/${project2}/database/snapshots/${options.snapshotId}/restore`,
+    { method: "POST" }
+  );
+}
+async function dbRollback(paths, options) {
+  const { client, project: project2 } = await open2(paths, options);
+  return client.request(
+    `/api/v1/projects/${project2}/database/rollback`,
+    { method: "POST", body: { to: options.to } }
+  );
+}
+var init_db2 = __esm({
+  "packages/cli/src/db.ts"() {
+    "use strict";
+    init_client();
+  }
+});
+
+// packages/cli/src/storage.ts
+var storage_exports = {};
+__export(storage_exports, {
+  contentTypeOf: () => contentTypeOf,
+  storageDownload: () => storageDownload,
+  storageList: () => storageList,
+  storageRemove: () => storageRemove,
+  storageUpload: () => storageUpload
+});
+import { mkdir as mkdir7, readFile as readFile7, stat as stat6, writeFile as writeFile6 } from "node:fs/promises";
+import { basename as basename3, dirname as dirname7, extname, join as join11, resolve as resolve8 } from "node:path";
+async function open3(paths, options) {
+  const client = await createClient(paths);
+  const project2 = await resolveSlug(resolve8(options.cwd), options.slug);
+  return { client, project: project2 };
+}
+function contentTypeOf(path) {
+  const map = {
+    ".html": "text/html; charset=utf-8",
+    ".htm": "text/html; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".mjs": "text/javascript; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".webp": "image/webp",
+    ".ico": "image/x-icon",
+    ".txt": "text/plain; charset=utf-8",
+    ".md": "text/markdown; charset=utf-8",
+    ".xml": "application/xml",
+    ".wasm": "application/wasm",
+    ".pdf": "application/pdf",
+    ".zip": "application/zip",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".ttf": "font/ttf",
+    ".otf": "font/otf"
+  };
+  return map[extname(path).toLowerCase()] ?? "application/octet-stream";
+}
+async function storageUpload(paths, options) {
+  const { client, project: project2 } = await open3(paths, options);
+  const local = resolve8(options.file);
+  const info = await stat6(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 readFile7(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)
+  );
+  const response = await client.upload(
+    `/api/v1/projects/${project2}/files`,
+    form,
+    "STORAGE_UPLOAD_FAILED"
+  );
+  const body = await response.json();
+  return { ...body.file, ...body.signedUrl === void 0 ? {} : { signedUrl: body.signedUrl } };
+}
+async function storageList(paths, options) {
+  const { client, project: project2 } = await open3(paths, options);
+  const query = options.prefix === void 0 ? "" : `?prefix=${encodeURIComponent(options.prefix)}`;
+  const body = await client.request(
+    `/api/v1/projects/${project2}/files${query}`
+  );
+  return { project: project2, files: body.files };
+}
+async function resolveDownloadUrl(client, project2, path) {
+  const body = await client.request(
+    `/api/v1/projects/${project2}/files?prefix=${encodeURIComponent(path)}`
+  );
+  const entry = body.files.find((file) => file.path === path);
+  const url = entry?.url ?? entry?.signedUrl;
+  if (entry === void 0 || url === void 0 || url.length === 0) {
+    throw new CliError("STORAGE_NOT_FOUND", `\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${path}`);
+  }
+  return url;
+}
+async function storageDownload(paths, options) {
+  const { client, project: project2 } = await open3(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 ?? join11(resolve8(options.cwd), basename3(options.path)));
+  await mkdir7(dirname7(output), { recursive: true });
+  await writeFile6(output, bytes);
+  return { path: options.path, output, size: bytes.length };
+}
+async function storageRemove(paths, options) {
+  const { client, project: project2 } = await open3(paths, options);
+  return client.request(
+    `/api/v1/projects/${project2}/files/${encodeURIComponent(options.path)}`,
+    { method: "DELETE" }
+  );
+}
+var init_storage2 = __esm({
+  "packages/cli/src/storage.ts"() {
+    "use strict";
+    init_client();
+    init_auth();
+  }
+});
+
+// packages/cli/src/hosting.ts
+var hosting_exports = {};
+__export(hosting_exports, {
+  hostingConfig: () => hostingConfig,
+  hostingDeploy: () => hostingDeploy,
+  hostingInfo: () => hostingInfo,
+  hostingPull: () => hostingPull
+});
+import { readdir as readdir4, readFile as readFile8, stat as stat7 } from "node:fs/promises";
+import { dirname as dirname8, join as join12, relative, resolve as resolve9, sep } from "node:path";
+async function open4(paths, options) {
+  const client = await createClient(paths);
+  const project2 = await resolveSlug(resolve9(options.cwd), options.slug);
+  return { client, project: project2 };
+}
+async function hostingInfo(paths, options) {
+  const { client, project: project2 } = await open4(paths, options);
+  const body = await client.request(`/api/v1/projects/${project2}/hosting`);
+  return {
+    config: body.config,
+    siteUrl: body.siteUrl,
+    files: body.files ?? []
+  };
+}
+async function collectSiteFiles(dir) {
+  const root = resolve9(dir);
+  const files = /* @__PURE__ */ new Map();
+  const walk = async (sub) => {
+    let entries;
+    try {
+      entries = await readdir4(sub, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = join12(sub, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else if (entry.isFile()) {
+        const rel = relative(root, full).split(sep).join("/");
+        files.set(rel, full);
+      }
+    }
+  };
+  await walk(root);
+  return files;
+}
+async function hostingDeploy(paths, options) {
+  const { client, project: project2 } = await open4(paths, options);
+  const log = options.log ?? ((line) => process.stdout.write(`${line}
+`));
+  const files = await collectSiteFiles(options.dir);
+  if (files.size === 0) {
+    throw new CliError("NO_SITE_FILES", `\u7AD9\u70B9\u76EE\u5F55\u4E3A\u7A7A\uFF1A${resolve9(options.dir)}`);
+  }
+  const uploaded = [];
+  for (const [rel, full] of files) {
+    log(`[adep] \u4E0A\u4F20 site/${rel}`);
+    const info2 = await stat7(full);
+    const bytes = await readFile8(full);
+    const form = new FormData();
+    form.set("path", `site/${rel}`);
+    form.set("visibility", "public");
+    form.set(
+      "file",
+      new Blob([bytes], { type: contentTypeOf(rel) }),
+      rel.split("/").pop()
+    );
+    await client.upload(`/api/v1/projects/${project2}/files`, form, "HOSTING_UPLOAD_FAILED");
+    uploaded.push({ path: `site/${rel}`, size: info2.size });
+  }
+  const config = await client.request(
+    `/api/v1/projects/${project2}/hosting`,
+    {
+      method: "PUT",
+      body: options.spa === void 0 ? { enabled: true } : { enabled: true, spaMode: options.spa }
+    }
+  );
+  const info = await hostingInfo(paths, options);
+  return { config: config.config, siteUrl: info.siteUrl, uploaded };
+}
+async function hostingPull(paths, options) {
+  const { client } = await open4(paths, options);
+  const log = options.log ?? ((line) => process.stdout.write(`${line}
+`));
+  const info = await hostingInfo(paths, options);
+  const outputDir = resolve9(options.output ?? resolve9(options.cwd));
+  const { mkdir: mkdir8, writeFile: writeFile7 } = await import("node:fs/promises");
+  const files = [];
+  for (const entry of info.files) {
+    if (entry.visibility !== "public" || entry.path === HOSTING_CONFIG_PATH) continue;
+    const url = entry.url;
+    if (url === void 0 || url.length === 0) continue;
+    log(`[adep] \u4E0B\u8F7D ${entry.path}`);
+    const response = await client.download(url, "HOSTING_DOWNLOAD_FAILED");
+    const bytes = Buffer.from(await response.arrayBuffer());
+    const rel = entry.path.replace(/^site\//, "");
+    const target = join12(outputDir, ...rel.split("/"));
+    await mkdir8(dirname8(target), { recursive: true });
+    await writeFile7(target, bytes);
+    files.push({ path: entry.path, size: bytes.length });
+  }
+  return { siteUrl: info.siteUrl, outputDir, files };
+}
+async function hostingConfig(paths, options) {
+  const { client, project: project2 } = await open4(paths, options);
+  const body = {};
+  if (options.enabled !== void 0) body["enabled"] = options.enabled;
+  if (options.spa !== void 0) body["spaMode"] = options.spa;
+  const result = await client.request(
+    `/api/v1/projects/${project2}/hosting`,
+    { method: "PUT", body }
+  );
+  return result.config;
+}
+var HOSTING_CONFIG_PATH;
+var init_hosting = __esm({
+  "packages/cli/src/hosting.ts"() {
+    "use strict";
+    init_client();
+    init_auth();
+    init_storage2();
+    HOSTING_CONFIG_PATH = "site/.hosting.json";
+  }
+});
+
+// packages/cli/src/widget/dev.ts
+var dev_exports2 = {};
+__export(dev_exports2, {
+  loadWidgetProject: () => loadWidgetProject,
+  startWidgetDev: () => startWidgetDev
+});
+import { createServer as createServer2 } from "node:http";
+import { watch as watch2 } from "node:fs";
+import { readFile as readFile9, stat as stat8 } from "node:fs/promises";
+import { join as join13, resolve as resolve10 } from "node:path";
+async function loadWidgetProject(cwd) {
+  const fallback = {
+    name: "widget",
+    framework: "vue3"
+  };
+  const manifestPath = join13(resolve10(cwd), "manifest.json");
+  try {
+    await stat8(manifestPath);
+  } catch {
+    return fallback;
+  }
+  try {
+    const raw = await readFile9(manifestPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      name: typeof parsed["name"] === "string" ? parsed["name"] : fallback.name,
+      framework: parsed["framework"] === "react" ? "react" : "vue3"
+    };
+  } catch {
+    return fallback;
+  }
+}
+function sandboxHtml(name, framework) {
+  return `<!doctype html>
+<html>
+<head>
+<meta charset="utf-8" />
+<title>adep widget dev \u2014 ${name}</title>
+<link rel="stylesheet" href="/__widget/theme.css" />
+<style>
+  body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; background: #f5f6f7; margin: 0; padding: 24px; }
+  #toolbar { display: flex; gap: 12px; align-items: center; font-size: 13px; color: #4c5561; margin-bottom: 16px; }
+  #toolbar .dot { width: 8px; height: 8px; border-radius: 50%; background: #99a2ad; }
+  #toolbar .dot.on { background: #16a34a; }
+  #sandbox { background: #fff; border: 1px solid #e5e6eb; border-radius: 8px; min-height: 120px; }
+  code { background: #eef0f3; padding: 2px 6px; border-radius: 4px; }
+</style>
+</head>
+<body>
+  <div id="toolbar"><span id="status"><span class="dot" id="dot"></span>  sandbox connecting\u2026</span></div>
+  <div id="sandbox"></div>
+  <script type="module">
+    const q = new URLSearchParams(location.search)
+    const token = q.get('token') ?? ''
+    document.getElementById('status').textContent = 'token: ' + (token ? 'injected' : '(none)')
+    const hostEl = document.getElementById('sandbox')
+    const host = hostEl.attachShadow({ mode: 'open' })
+    let version = 0
+
+    async function load(v) {
+      host.textContent = ''
+      let props = {}
+      try { props = await (await fetch('/__widget/mock-props')).json() } catch { props = {} }
+      const mod = await import('/__widget/index.js?v=' + v)
+      mod.mount(host, {
+        widgetName: '${name}',
+        framework: '${framework}',
+        props,
+        host: {
+          getProjectId: () => 'local-dev',
+          invokeFunction: async () => ({})
+        }
+      })
+    }
+
+    function markConnected() {
+      const dot = document.getElementById('dot')
+      dot.classList.add('on')
+      document.getElementById('status').firstChild.textContent = 'sandbox live \u2014 watch src/\uFF0C\u4FDD\u5B58\u540E\u81EA\u52A8\u70ED\u66F4\u65B0 '
+    }
+
+    const es = new EventSource('/__widget/events')
+    es.addEventListener('rebuild', (e) => {
+      version = Number(e.data) || 0
+      load(version).catch((err) => { console.error(err); host.textContent = 'mount error: ' + err.message })
+    })
+    es.addEventListener('open', (e) => {
+      e.preventDefault()
+      markConnected()
+      if (version === 0) load(0)
+    })
+  </script>
+</body>
+</html>
+`;
+}
+async function startWidgetDev(options) {
+  const cwd = resolve10(options.cwd);
+  const log = options.log ?? ((line) => process.stdout.write(`${line}
+`));
+  const project2 = await loadWidgetProject(cwd);
+  const framework = options.framework ?? project2.framework;
+  let state = { text: "", version: 0 };
+  const rebuild = async () => {
+    const built = await buildWidget({ cwd, framework });
+    const next = { text: built.text, version: state.version + 1 };
+    state = next;
+    return next;
+  };
+  try {
+    await rebuild();
+  } catch (error) {
+    throw new WidgetError(
+      "BUILD_FAILED",
+      `widget \u6784\u5EFA\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const clients = /* @__PURE__ */ new Set();
+  const broadcast = (version) => {
+    for (const res of clients) {
+      res.write(`event: rebuild
+data: ${version}
+
+`);
+    }
+  };
+  let debounceTimer;
+  let watcher;
+  try {
+    watcher = watch2(cwd, { recursive: true }, () => {
+      if (debounceTimer !== void 0) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => {
+        void buildWidget({ cwd, framework }).then((built) => {
+          const next = { text: built.text, version: state.version + 1 };
+          state = next;
+          broadcast(next.version);
+          log(`[adep] widget rebuilt v${next.version}`);
+          return void 0;
+        }).catch((error) => {
+          log(`[adep] rebuild failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+      }, 120);
+    });
+  } catch {
+    watcher = void 0;
+  }
+  const readTheme = async () => {
+    try {
+      return await readFile9(join13(cwd, "src", "theme.css"), "utf8");
+    } catch {
+      return null;
+    }
+  };
+  const readProps = async () => {
+    try {
+      return await readFile9(join13(cwd, "src", "mock-props.json"), "utf8");
+    } catch {
+      return null;
+    }
+  };
+  const handle = async (req, res) => {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    if (url.pathname === "/") {
+      res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+      res.end(sandboxHtml(project2.name, framework));
+      return;
+    }
+    if (url.pathname === "/__widget/index.js") {
+      const version = url.searchParams.get("v");
+      if (version !== null && Number(version) > state.version) {
+        await rebuild().catch(() => void 0);
+      }
+      res.writeHead(200, { "content-type": "application/javascript; charset=utf-8" });
+      res.end(state.text);
+      return;
+    }
+    if (url.pathname === "/__widget/theme.css") {
+      const css = await readTheme();
+      if (css === null) {
+        res.writeHead(404).end("not found");
+        return;
+      }
+      res.writeHead(200, { "content-type": "text/css; charset=utf-8" });
+      res.end(css);
+      return;
+    }
+    if (url.pathname === "/__widget/mock-props") {
+      const props = await readProps();
+      res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
+      res.end(props ?? "{}");
+      return;
+    }
+    if (url.pathname === "/__widget/events") {
+      res.writeHead(200, {
+        "content-type": "text/event-stream",
+        "cache-control": "no-cache",
+        connection: "keep-alive"
+      });
+      res.write(": connected\n\n");
+      clients.add(res);
+      req.on("close", () => {
+        clients.delete(res);
+      });
+      return;
+    }
+    res.writeHead(404).end("not found");
+  };
+  const server = createServer2((req, res) => {
+    void handle(req, res);
+  });
+  await new Promise((resolveListen, rejectListen) => {
+    server.once("error", rejectListen);
+    server.listen(options.port ?? 8788, "127.0.0.1", () => {
+      server.off("error", rejectListen);
+      resolveListen();
+    });
+  });
+  const address = server.address();
+  const port = typeof address === "object" && address !== null ? address.port : options.port ?? 8788;
+  const baseUrl = `http://127.0.0.1:${port}`;
+  return {
+    port,
+    baseUrl,
+    close: async () => {
+      if (debounceTimer !== void 0) clearTimeout(debounceTimer);
+      watcher?.close();
+      for (const res of clients) res.end();
+      clients.clear();
+      await new Promise((resolveClose) => server.close(() => resolveClose()));
+    }
+  };
+}
+var init_dev2 = __esm({
+  "packages/cli/src/widget/dev.ts"() {
+    "use strict";
+    init_build();
+  }
+});
+
+// packages/cli/src/widget/publish.ts
+var publish_exports = {};
+__export(publish_exports, {
+  publishWidget: () => publishWidget
+});
+import { readFile as readFile10 } from "node:fs/promises";
+import { basename as basename4, join as join14, resolve as resolve11 } from "node:path";
+async function publishWidget(paths, options) {
+  const log = options.log ?? ((line) => process.stdout.write(`${line}
+`));
+  const client = await createClient(paths);
+  const root = resolve11(options.cwd);
+  const project2 = await loadWidgetProject(root);
+  const framework = options.framework ?? project2.framework;
+  let version = "0.1.0";
+  try {
+    const pkg = JSON.parse(await readFile10(join14(root, "package.json"), "utf8"));
+    if (typeof pkg["version"] === "string" && pkg["version"].length > 0) version = pkg["version"];
+  } catch {
+    version = "0.1.0";
+  }
+  const name = project2.name === "widget" ? basename4(root) : project2.name;
+  log(`[adep] \u6784\u5EFA ${name}\uFF08${framework}\uFF09v${version} \u2026`);
+  const built = await buildWidget({ cwd: root, framework });
+  const path = `widgets/${name}/${version}/index.js`;
+  const form = new FormData();
+  form.set("path", path);
+  form.set("visibility", "public");
+  form.set("file", new Blob([built.text], { type: "text/javascript" }), "index.js");
+  await client.upload(`/api/v1/projects/${options.project}/files`, form, "PUBLISH_UPLOAD_FAILED");
+  const prefix = encodeURIComponent(`widgets/${name}/${version}/`);
+  const listing = await client.request(
+    `/api/v1/projects/${options.project}/files?prefix=${prefix}`
+  );
+  const entry = (listing.files ?? []).find((file) => file.path?.endsWith("index.js"));
+  const url = entry?.url;
+  if (typeof url !== "string" || url.length === 0) {
+    throw new WidgetError("URL_MISSING", "\u4E0A\u4F20\u6210\u529F\u4F46\u65E0\u6CD5\u89E3\u6790\u4EA7\u7269 URL\uFF0C\u8BF7\u68C0\u67E5\u5E73\u53F0\u5B58\u50A8\u914D\u7F6E");
+  }
+  log(`[adep] \u5DF2\u53D1\u5E03 ${name} v${version}\uFF08hash ${built.hash.slice(0, 8)}\u2026\uFF09`);
+  return { name, version, framework, url, hash: built.hash };
+}
+var init_publish = __esm({
+  "packages/cli/src/widget/publish.ts"() {
+    "use strict";
+    init_client();
+    init_build();
+    init_dev2();
+  }
+});
+
+// packages/cli/src/cli.ts
+init_auth();
+import { Command } from "commander";
+import { createRequire } from "node:module";
+
+// packages/cli/src/config.ts
+function resolvePaths(env = process.env) {
+  const home = env["ADEP_HOME"] ?? `${env["HOME"] ?? ""}/.adep`;
+  return { home, credentialsFile: `${home}/credentials` };
+}
+function resolveServer(env = process.env) {
+  return (env["ADEP_SERVER"] ?? "https://adep.jajabjbj.top").replace(/\/+$/, "");
+}
+
+// packages/cli/src/init.ts
+import { mkdir as mkdir2, stat as stat2, writeFile } from "node:fs/promises";
+import { dirname as dirname2, join, resolve } from "node:path";
+var InitError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "InitError";
+  }
+};
+var ADEP_CONFIG = (name, template) => `import { defineConfig } from 'adep/config'
+
+// adep \u9879\u76EE\u914D\u7F6E\uFF1ACLI\uFF08dev / deploy\uFF09\u4E0E\u5E73\u53F0\u6309\u6B64\u8BC6\u522B\u9879\u76EE\u3002
+export default defineConfig({
+  name: '${name}',
+  template: '${template}',
+})
+`;
+var README = (name, template) => `# ${name}
+
+AgentDeploy \u9879\u76EE\uFF08\u6A21\u677F\uFF1A${template}\uFF09\u3002
+
+- \`adep dev\`\uFF1A\u672C\u5730\u8C03\u8BD5\uFF08CLI-002 \u4EA4\u4ED8\uFF09
+- \`adep deploy\`\uFF1A\u53D1\u5E03\uFF08CLI-003 \u4EA4\u4ED8\uFF09
+`;
+var HELLO_FUNCTION = `import { defineFunction } from 'adep/function'
+
+// \u793A\u4F8B\u51FD\u6570\uFF1Aadep deploy \u540E\u7ECF https://<project-slug>.<platform-domain>/hello \u89E6\u53D1\u3002
+export default defineFunction(async (ctx) => {
+  const name = (ctx.query['name'] as string | undefined) ?? 'world'
+  return { message: \`hello \${name}\` }
+})
+`;
+var FUNCTION_INDEX = `// \u51FD\u6570\u6A21\u5757\u5165\u53E3\uFF1A\u9879\u76EE\u91CC\u7684\u6BCF\u4E2A\u51FD\u6570\u662F functions/ \u4E0B\u7684\u72EC\u7ACB\u6587\u4EF6\uFF0C
+// \u9ED8\u8BA4\u5BFC\u51FA (ctx) => Response \u5F62\u72B6\u7684\u5904\u7406\u5668\uFF08\u5951\u7EA6\u89C1 @adep/types \u7684 FunctionContext\uFF09\u3002
+`;
+var EMPTY_INDEX = `// AgentDeploy \u9879\u76EE\u5165\u53E3\u3002M1 \u4E2D\u6A21\u677F\u6682\u65E0\u66F4\u591A\u5185\u5BB9\u2014\u2014\u51FD\u6570\u653E functions/\uFF0C\u914D\u7F6E\u89C1 adep.config.ts\u3002
+`;
+async function initProject(cwd, name, template) {
+  if (!/^[a-z][a-z0-9-]{0,62}$/.test(name)) {
+    throw new InitError(
+      "INVALID_NAME",
+      `\u9879\u76EE\u540D "${name}" \u4E0D\u5408\u6CD5\uFF1A\u9700\u4EE5\u5C0F\u5199\u5B57\u6BCD\u5F00\u5934\uFF0C\u4EC5\u542B\u5C0F\u5199\u5B57\u6BCD / \u6570\u5B57 / \u8FDE\u5B57\u7B26`
+    );
+  }
+  const projectPath = resolve(cwd, name);
+  let existing;
+  try {
+    existing = await stat2(projectPath);
+  } catch {
+    existing = null;
+  }
+  if (existing !== null) {
+    throw new InitError("DIR_EXISTS", `\u76EE\u5F55 ${projectPath} \u5DF2\u5B58\u5728\uFF1A\u8BF7\u6362\u4E00\u4E2A\u540D\u5B57\u6216\u5148\u5220\u9664`);
+  }
+  const files = [
+    { path: "adep.config.ts", content: ADEP_CONFIG(name, template) },
+    { path: "README.md", content: README(name, template) }
+  ];
+  if (template === "function") {
+    files.push({ path: "functions/hello.ts", content: HELLO_FUNCTION });
+    files.push({ path: "functions/README.md", content: FUNCTION_INDEX });
+    files.push({ path: ".gitignore", content: "node_modules/\ndata/\n.adep/\n" });
+  } else {
+    files.push({ path: ".gitignore", content: "node_modules/\ndata/\n.adep/\n" });
+    files.push({ path: "README-EMPTY.md", content: EMPTY_INDEX });
+  }
+  await mkdir2(projectPath, { recursive: true });
+  await Promise.all(
+    files.map(async (file) => {
+      const target = join(projectPath, file.path);
+      await mkdir2(dirname2(target), { recursive: true });
+      await writeFile(target, file.content);
+    })
+  );
+  return { projectPath, files: files.map((file) => file.path) };
+}
+
+// packages/cli/src/templates.ts
+init_auth();
+async function fetchTemplates(server) {
+  let response;
+  try {
+    response = await fetch(`${server}/api/v1/templates`);
+  } catch (error) {
+    throw new CliError(
+      "SERVER_UNREACHABLE",
+      `\u65E0\u6CD5\u8FDE\u63A5\u5E73\u53F0 ${server}\uFF1A${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const text = await response.text();
+  let parsed = null;
+  try {
+    parsed = text.length === 0 ? null : JSON.parse(text);
+  } catch {
+    parsed = null;
+  }
+  if (response.status < 200 || response.status >= 300) {
+    const msg = parsed?.error;
+    throw new CliError("TEMPLATE_LIST_FAILED", msg ?? `\u5E73\u53F0\u8FD4\u56DE HTTP ${response.status}`);
+  }
+  const templates = parsed?.templates;
+  return templates ?? [];
+}
+
+// packages/cli/src/cli.ts
+init_build();
+init_init();
+var requireJson = createRequire(import.meta.url);
+var APP_VERSION = requireJson("../package.json").version;
+function emitError(output, command, json, error) {
+  if (error instanceof CliError || error instanceof InitError || error instanceof WidgetError || error instanceof WidgetInitError) {
+    if (json) {
+      output(
+        JSON.stringify({
+          ok: false,
+          command,
+          error: { code: error.code, message: error.message }
+        })
+      );
+    } else {
+      output(`\u9519\u8BEF\uFF1A${error.message}`);
+      if (error instanceof CliError && error.code === "NOT_LOGGED_IN") {
+        output("\u63D0\u793A\uFF1A\u5148\u6267\u884C adep login");
+      }
+    }
+    process.exitCode = 1;
+    return;
+  }
+  throw error;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let value = bytes;
+  let unit = -1;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit++;
+  }
+  return `${value.toFixed(unit < 0 ? 0 : 1)} ${units[unit] ?? "B"}`;
+}
+function formatTable(columns, rows) {
+  const widths = columns.map((column) => column.length);
+  for (const row of rows) {
+    columns.forEach((column, index) => {
+      const cell = String(row[column] ?? "");
+      widths[index] = Math.max(widths[index], cell.length);
+    });
+  }
+  const line = (cells) => cells.map((cell, index) => cell.padEnd(widths[index] ?? 0)).join("  ").trimEnd();
+  const parts = [
+    line(columns),
+    ...rows.map((row) => line(columns.map((c) => String(row[c] ?? ""))))
+  ];
+  return parts.join("\n");
+}
+function parseBool(raw) {
+  if (raw === void 0) return void 0;
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  throw new CliError("INVALID_BOOLEAN", `\u5E03\u5C14\u53C2\u6570\u987B\u4E3A true \u6216 false\uFF0C\u6536\u5230 "${raw}"`);
+}
+function buildProgram(options = {}) {
+  const output = options.output ?? ((line) => process.stdout.write(`${line}
+`));
+  const paths = options.paths ?? resolvePaths();
+  const cwd = options.cwd ?? process.cwd();
+  const program2 = new Command();
+  program2.name("adep").description("AgentDeploy CLI").version(APP_VERSION);
+  program2.option("--json", "\u4EE5\u673A\u5668\u53EF\u8BFB JSON \u8F93\u51FA\uFF08Agent / \u811A\u672C\u8C03\u7528\uFF09", false);
+  const jsonMode = () => program2.opts()["json"] === true;
+  program2.command("login").description("\u767B\u5F55\u5E73\u53F0\uFF08better-auth \u90AE\u7BB1\u5BC6\u7801\u767B\u5F55\uFF1B\u8BBE\u5907\u6388\u6743\u6D41\u5F52 CORE \u57DF\u540E\u7EED\u4EFB\u52A1\uFF09").option("-s, --server <url>", "\u5E73\u53F0\u5730\u5740\uFF08\u7F3A\u7701\u8BFB\u53D6 ADEP_SERVER \u6216 http://localhost:3000\uFF09").option("-e, --email <email>", "\u767B\u5F55\u90AE\u7BB1").option("-p, --password <password>", "\u767B\u5F55\u5BC6\u7801\uFF08\u6CE8\u610F shell \u5386\u53F2\uFF1B\u7F3A\u7701\u4EA4\u4E92\u8F93\u5165\uFF09").action(async (flags) => {
+    try {
+      const server = flags.server ?? resolveServer();
+      let email = flags.email;
+      let password = flags.password;
+      if (email === void 0 || password === void 0) {
+        const { createPrompt: createPrompt2 } = await Promise.resolve().then(() => (init_prompt(), prompt_exports));
+        const prompt = createPrompt2();
+        email = email ?? await prompt.ask("\u90AE\u7BB1\uFF1A");
+        password = password ?? await prompt.askHidden("\u5BC6\u7801\uFF1A");
+        prompt.close();
+      }
+      const result = await login(paths, {
+        server,
+        email,
+        password
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "login", data: result }));
+      } else {
+        output(`\u5DF2\u767B\u5F55\uFF1A${result.email}\uFF08\u51ED\u636E\u5DF2\u5199\u5165 ${paths.credentialsFile}\uFF0C\u6743\u9650 0600\uFF09`);
+      }
+    } catch (error) {
+      emitError(output, "login", jsonMode(), error);
+    }
+  });
+  program2.command("whoami").description("\u663E\u793A\u5F53\u524D\u767B\u5F55\u8EAB\u4EFD").action(async () => {
+    try {
+      const result = await whoami(paths);
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "whoami", data: result }));
+      } else {
+        output(`${result.email} @ ${result.server}`);
+      }
+    } catch (error) {
+      emitError(output, "whoami", jsonMode(), error);
+    }
+  });
+  program2.command("logout").description("\u767B\u51FA\u5E76\u6E05\u9664\u672C\u5730\u51ED\u636E").action(async () => {
+    try {
+      await logout(paths);
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "logout", data: { done: true } }));
+      } else {
+        output("\u5DF2\u767B\u51FA");
+      }
+    } catch (error) {
+      emitError(output, "logout", jsonMode(), error);
+    }
+  });
+  program2.command("init").description("\u521D\u59CB\u5316\u9879\u76EE\uFF08\u6A21\u677F\uFF1Aempty / function\uFF09\uFF0C\u6216 --list \u4ECE\u5E73\u53F0\u53D6\u6A21\u677F\u6E05\u5355").argument("[name]", "\u9879\u76EE\u76EE\u5F55\u540D\uFF08\u914D\u5408 --list \u65F6\u53EF\u7701\u7565\uFF09").option("-t, --template <template>", "\u6A21\u677F\uFF1Aempty | function", "function").option("-l, --list", "\u4ECE\u5E73\u53F0 /api/v1/templates \u5217\u51FA\u53EF\u7528\u6A21\u677F\uFF08\u4E0D\u811A\u624B\u67B6\uFF09", false).option(
+    "-s, --server <url>",
+    "\u5E73\u53F0\u5730\u5740\uFF08--list \u7528\uFF1B\u7F3A\u7701\u8BFB ADEP_SERVER \u6216 http://localhost:3000\uFF09"
+  ).action(
+    async (name, flags) => {
+      try {
+        if (flags.list === true) {
+          const server = flags.server ?? resolveServer();
+          const templates = await fetchTemplates(server);
+          if (jsonMode()) {
+            output(JSON.stringify({ ok: true, command: "init", data: { templates } }));
+          } else {
+            for (const tpl of templates) {
+              output(`${tpl.code}	${tpl.name}	${tpl.description ?? ""}`);
+            }
+          }
+          return;
+        }
+        if (name === void 0) {
+          throw new InitError("MISSING_NAME", "\u9700\u7ED9\u51FA\u9879\u76EE\u540D\uFF0C\u6216\u4F7F\u7528 --list \u5217\u51FA\u5E73\u53F0\u53EF\u7528\u6A21\u677F");
+        }
+        const template = flags.template;
+        if (!["empty", "function"].includes(template)) {
+          throw new InitError("INVALID_TEMPLATE", `\u672A\u77E5\u6A21\u677F "${template}"\uFF1A\u53EF\u9009 empty | function`);
+        }
+        const result = await initProject(cwd, name, template);
+        if (jsonMode()) {
+          output(JSON.stringify({ ok: true, command: "init", data: result }));
+        } else {
+          output(`\u5DF2\u521B\u5EFA ${result.projectPath}`);
+        }
+      } catch (error) {
+        emitError(output, "init", jsonMode(), error);
+      }
+    }
+  );
+  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) => {
+    try {
+      const { startDevServer: startDevServer2 } = await Promise.resolve().then(() => (init_dev(), dev_exports));
+      const started = await startDevServer2({ cwd, port: Number(flags.port ?? "8787") });
+      output(`[adep] dev server listening on ${started.baseUrl}\uFF08Ctrl-C \u9000\u51FA\uFF09`);
+      await new Promise(() => void 0);
+    } catch (error) {
+      emitError(output, "dev", jsonMode(), error);
+    }
+  });
+  program2.command("deploy").description("\u589E\u91CF\u90E8\u7F72\uFF1A\u5BF9\u6BD4\u8FDC\u7AEF\u54C8\u5E0C \u2192 \u4EC5\u4E0A\u4F20\u53D8\u66F4 \u2192 \u53D1\u5E03 \u2192 \u8F93\u51FA\u8BBF\u95EE\u57DF\u540D").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (flags) => {
+    try {
+      const { deploy: deploy2 } = await Promise.resolve().then(() => (init_deploy(), deploy_exports));
+      const result = await deploy2(paths, {
+        cwd,
+        ...flags.project === void 0 ? {} : { slug: flags.project }
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "deploy", data: result }));
+      } else {
+        if (result.noChanges) {
+          output("no changes\uFF1A\u5168\u90E8\u51FD\u6570\u4E0E\u5DF2\u53D1\u5E03\u7248\u672C\u4E00\u81F4\uFF0C\u672A\u4EA7\u751F\u65B0\u7248\u672C");
+        }
+        for (const fn of result.functions) {
+          output(`${fn.name}  v${fn.version}  ${fn.url}`);
+        }
+      }
+    } catch (error) {
+      emitError(output, "deploy", jsonMode(), error);
+    }
+  });
+  const db = program2.command("db").description("\u9879\u76EE\u6570\u636E\u5E93\u7EF4\u62A4\uFF1A\u542F\u52A8 / \u72B6\u6001 / \u505C\u6B62 / SQL / \u5FEB\u7167 / \u56DE\u6EDA").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09");
+  db.command("start").description("\u542F\u52A8\u9879\u76EE\u6570\u636E\u5E93\uFF08\u5DF2\u5B58\u5728\u5219\u91CD\u65B0\u6FC0\u6D3B\uFF0C\u4E0D\u91CD\u5EFA\u6570\u636E\uFF09").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (flags) => {
+    try {
+      const { dbStart: dbStart2 } = await Promise.resolve().then(() => (init_db2(), db_exports));
+      const result = await dbStart2(paths, {
+        cwd,
+        ...flags.project === void 0 ? {} : { slug: flags.project }
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "db start", data: result }));
+      } else {
+        output(
+          `\u6570\u636E\u5E93\u5DF2\u5C31\u7EEA\uFF1A${result.projectId}\uFF08${result.journalMode}\uFF0C${result.usage.tableCount} \u8868 / ${result.usage.rowCount} \u884C / ${formatBytes(result.usage.sizeBytes)}\uFF09`
+        );
+      }
+    } catch (error) {
+      emitError(output, "db start", jsonMode(), error);
+    }
+  });
+  db.command("status").description("\u67E5\u8BE2\u9879\u76EE\u6570\u636E\u5E93\u72B6\u6001\u4E0E\u7528\u91CF\uFF08\u4F53\u79EF / \u8868\u6570 / \u884C\u6570\uFF09").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (flags) => {
+    try {
+      const { dbStatus: dbStatus2 } = await Promise.resolve().then(() => (init_db2(), db_exports));
+      const result = await dbStatus2(paths, {
+        cwd,
+        ...flags.project === void 0 ? {} : { slug: flags.project }
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "db status", data: result }));
+      } else {
+        output(
+          `\u72B6\u6001\uFF1A${result.status}\uFF08${result.projectId}\uFF0C${result.usage.tableCount} \u8868 / ${result.usage.rowCount} \u884C / ${formatBytes(result.usage.sizeBytes)}\uFF09`
+        );
+      }
+    } catch (error) {
+      emitError(output, "db status", jsonMode(), error);
+    }
+  });
+  db.command("stop").description("\u505C\u6B62\u9879\u76EE\u6570\u636E\u5E93\uFF08\u8FDE\u63A5\u5173\u95ED\u5E76\u6807\u8BB0\uFF1B\u6587\u4EF6\u4FDD\u7559\uFF09").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (flags) => {
+    try {
+      const { dbStop: dbStop2 } = await Promise.resolve().then(() => (init_db2(), db_exports));
+      const result = await dbStop2(paths, {
+        cwd,
+        ...flags.project === void 0 ? {} : { slug: flags.project }
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "db stop", data: result }));
+      } else {
+        output(`\u6570\u636E\u5E93\u5DF2\u505C\u6B62\uFF1A${result.status}`);
+      }
+    } catch (error) {
+      emitError(output, "db stop", jsonMode(), error);
+    }
+  });
+  db.command("exec").description("\u6267\u884C\u5355\u6761 SQL\uFF08\u5199 / \u7834\u574F\u6027\u8BED\u53E5\u9700 --confirm-table \u4E8C\u6B21\u786E\u8BA4\uFF09").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").requiredOption("--sql <sql>", "\u5F85\u6267\u884C SQL").option("--confirm-table <table>", "\u7834\u574F\u6027\u64CD\u4F5C\u7684\u76EE\u6807\u8868\u540D\uFF08\u4E8C\u6B21\u786E\u8BA4\uFF09").action(async (flags) => {
+    try {
+      const { dbExec: dbExec2 } = await Promise.resolve().then(() => (init_db2(), db_exports));
+      const result = await dbExec2(paths, {
+        cwd,
+        sql: flags.sql,
+        ...flags.project === void 0 ? {} : { slug: flags.project },
+        ...flags.confirmTable === void 0 ? {} : { confirmTable: flags.confirmTable }
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "db exec", data: result }));
+      } else {
+        if (result.columns.length > 0) {
+          output(formatTable(result.columns, result.rows));
+          if (result.truncated) output(`\uFF08\u7ED3\u679C\u5DF2\u622A\u65AD\u5230 ${result.rows.length} \u884C\uFF09`);
+        } else if (result.changes > 0) {
+          output(`${result.changes} \u884C\u53D7\u5F71\u54CD`);
+        } else {
+          output("\u8BED\u53E5\u6267\u884C\u6210\u529F\uFF08\u65E0\u8FD4\u56DE\u884C\uFF09");
+        }
+        output(`\u8017\u65F6 ${result.elapsedMs}ms`);
+      }
+    } catch (error) {
+      emitError(output, "db exec", jsonMode(), error);
+    }
+  });
+  const snapshot = db.command("snapshot").description("\u6570\u636E\u5E93\u5FEB\u7167\uFF08\u4ED8\u8D39\u6863\u4F4D\uFF09\uFF1A\u5217\u51FA\uFF08\u7F3A\u7701\uFF09/ \u521B\u5EFA / \u8FD8\u539F");
+  snapshot.command("list").description("\u5217\u51FA\u9879\u76EE\u6570\u636E\u5E93\u5FEB\u7167\uFF08\u6309\u521B\u5EFA\u65F6\u95F4\u5012\u5E8F\uFF09").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (flags) => {
+    try {
+      const { dbSnapshotList: dbSnapshotList2 } = await Promise.resolve().then(() => (init_db2(), db_exports));
+      const result = await dbSnapshotList2(paths, {
+        cwd,
+        ...flags.project === void 0 ? {} : { slug: flags.project }
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "db snapshot list", data: result }));
+      } else {
+        if (result.snapshots.length === 0) {
+          output("\u6682\u65E0\u5FEB\u7167");
+        }
+        for (const snap of result.snapshots) {
+          output(
+            `${snap.id}	${snap.type}	${snap.plan}	${formatBytes(snap.sizeBytes)}	${snap.createdAt}`
+          );
+        }
+      }
+    } catch (error) {
+      emitError(output, "db snapshot list", jsonMode(), error);
+    }
+  });
+  snapshot.command("create").description("\u521B\u5EFA\u624B\u52A8\u6570\u636E\u5E93\u5FEB\u7167\uFF08\u514D\u8D39\u7248\u5E73\u53F0\u8FD4\u56DE 403 \u6743\u76CA\u672A\u5F00\u653E\uFF09").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (flags) => {
+    try {
+      const { dbSnapshotCreate: dbSnapshotCreate2 } = await Promise.resolve().then(() => (init_db2(), db_exports));
+      const result = await dbSnapshotCreate2(paths, {
+        cwd,
+        ...flags.project === void 0 ? {} : { slug: flags.project }
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "db snapshot create", data: result }));
+      } else {
+        output(`\u5FEB\u7167\u5DF2\u521B\u5EFA\uFF1A${result.id}\uFF08${result.plan}\uFF0C${formatBytes(result.sizeBytes)}\uFF09`);
+      }
+    } catch (error) {
+      emitError(output, "db snapshot create", jsonMode(), error);
+    }
+  });
+  snapshot.command("restore").description("\u6574\u4F53\u8FD8\u539F\u6570\u636E\u5E93\u5230\u5FEB\u7167\u65F6\u523B\uFF08\u4ED8\u8D39\u6863\u4F4D\uFF09").argument("<snapshotId>", "\u5FEB\u7167 id").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (snapshotId, flags) => {
+    try {
+      const { dbSnapshotRestore: dbSnapshotRestore2 } = await Promise.resolve().then(() => (init_db2(), db_exports));
+      const result = await dbSnapshotRestore2(paths, {
+        cwd,
+        snapshotId,
+        ...flags.project === void 0 ? {} : { slug: flags.project }
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "db snapshot restore", data: result }));
+      } else {
+        output(`\u5DF2\u8FD8\u539F\u5230\u5FEB\u7167 ${result.snapshotId}`);
+      }
+    } catch (error) {
+      emitError(output, "db snapshot restore", jsonMode(), error);
+    }
+  });
+  db.command("rollback").description("\u65F6\u95F4\u70B9\u56DE\u6EDA\u5230\u6307\u5B9A\u65F6\u523B\uFF08\u56E2\u961F\u7248\uFF1B\u57FA\u4E8E\u53D8\u66F4\u6D41\u91CD\u653E\uFF09").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").requiredOption("--to <iso-time>", "\u56DE\u6EDA\u76EE\u6807\u65F6\u523B\uFF08ISO 8601\uFF09").action(async (flags) => {
+    try {
+      const { dbRollback: dbRollback2 } = await Promise.resolve().then(() => (init_db2(), db_exports));
+      const result = await dbRollback2(paths, {
+        cwd,
+        to: flags.to,
+        ...flags.project === void 0 ? {} : { slug: flags.project }
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "db rollback", data: result }));
+      } else {
+        output(`\u5DF2\u56DE\u6EDA\u5230 ${result.to}\uFF08\u91CD\u653E ${result.reverted} \u6761\u53D8\u66F4\uFF09`);
+      }
+    } catch (error) {
+      emitError(output, "db rollback", jsonMode(), error);
+    }
+  });
+  const storage = program2.command("storage").description("\u4E91\u5B58\u50A8 / \u6587\u4EF6\u5B58\u50A8\uFF1A\u4E0A\u4F20 / \u4E0B\u8F7D / \u5217\u8868 / \u5220\u9664").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09");
+  storage.command("upload").description("\u4E0A\u4F20\u5355\u4E2A\u6587\u4EF6\uFF08multipart\uFF1B\u5355\u6587\u4EF6 \u2264 50MB\uFF09").argument("<file>", "\u672C\u5730\u6587\u4EF6\u8DEF\u5F84").requiredOption("--path <remote-path>", "\u6876\u5185\u76EE\u6807\u8DEF\u5F84\uFF08\u5982 avatars/a.png\uFF09").option(
+    "--visibility <public|private>",
+    "public \u76F4\u8FDE / private \u7B7E\u540D\uFF08\u7F3A\u7701 private\uFF09",
+    "private"
+  ).option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (file, flags) => {
+    try {
+      const { storageUpload: storageUpload2 } = await Promise.resolve().then(() => (init_storage2(), storage_exports));
+      const result = await storageUpload2(paths, {
+        cwd,
+        file,
+        path: flags.path,
+        visibility: flags.visibility === "public" ? "public" : "private",
+        ...flags.project === void 0 ? {} : { slug: flags.project }
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "storage upload", data: result }));
+      } else {
+        output(`\u5DF2\u4E0A\u4F20 ${result.path}\uFF08${result.visibility}\uFF0C${formatBytes(result.size)}\uFF09`);
+        if (result.signedUrl !== void 0) output(`\u7B7E\u540D URL\uFF1A${result.signedUrl}`);
+      }
+    } catch (error) {
+      emitError(output, "storage upload", jsonMode(), error);
+    }
+  });
+  storage.command("download").description("\u4E0B\u8F7D\u6587\u4EF6\u5230\u672C\u5730\uFF08public \u76F4\u8FDE / private \u7B7E\u540D URL\uFF09").argument("<remote-path>", "\u6876\u5185\u6587\u4EF6\u8DEF\u5F84").option("-o, --output <file>", "\u672C\u5730\u8F93\u51FA\u8DEF\u5F84\uFF08\u7F3A\u7701\u5199\u5230 cwd\uFF09").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (remotePath, flags) => {
+    try {
+      const { storageDownload: storageDownload2 } = await Promise.resolve().then(() => (init_storage2(), storage_exports));
+      const result = await storageDownload2(paths, {
+        cwd,
+        path: remotePath,
+        ...flags.output === void 0 ? {} : { output: flags.output },
+        ...flags.project === void 0 ? {} : { slug: flags.project }
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "storage download", data: result }));
+      } else {
+        output(`\u5DF2\u4E0B\u8F7D ${result.path} \u2192 ${result.output}\uFF08${formatBytes(result.size)}\uFF09`);
+      }
+    } catch (error) {
+      emitError(output, "storage download", jsonMode(), error);
+    }
+  });
+  storage.command("ls").description("\u5217\u51FA\u9879\u76EE\u6587\u4EF6\uFF08\u6309\u524D\u7F00\u8FC7\u6EE4\uFF1Bpublic \u9644\u76F4\u8FDE url\u3001private \u9644\u7B7E\u540D url\uFF09").option("--prefix <prefix>", "\u6309\u524D\u7F00\u8FC7\u6EE4").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (flags) => {
+    try {
+      const { storageList: storageList2 } = await Promise.resolve().then(() => (init_storage2(), storage_exports));
+      const result = await storageList2(paths, {
+        cwd,
+        ...flags.prefix === void 0 ? {} : { prefix: flags.prefix },
+        ...flags.project === void 0 ? {} : { slug: flags.project }
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "storage ls", data: result }));
+      } else {
+        if (result.files.length === 0) {
+          output("\uFF08\u65E0\u6587\u4EF6\uFF09");
+        }
+        for (const file of result.files) {
+          output(
+            `${file.path}	${file.visibility}	${formatBytes(file.size)}	${file.url ?? file.signedUrl ?? ""}`
+          );
+        }
+      }
+    } catch (error) {
+      emitError(output, "storage ls", jsonMode(), error);
+    }
+  });
+  storage.command("rm").description("\u5220\u9664\u6587\u4EF6\uFF08\u4EC5\u9879\u76EE\u6240\u6709\u8005\uFF09").argument("<remote-path>", "\u6876\u5185\u6587\u4EF6\u8DEF\u5F84").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (remotePath, flags) => {
+    try {
+      const { storageRemove: storageRemove2 } = await Promise.resolve().then(() => (init_storage2(), storage_exports));
+      const result = await storageRemove2(paths, {
+        cwd,
+        path: remotePath,
+        ...flags.project === void 0 ? {} : { slug: flags.project }
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "storage rm", data: result }));
+      } else {
+        output(`\u5DF2\u5220\u9664 ${remotePath}`);
+      }
+    } catch (error) {
+      emitError(output, "storage rm", jsonMode(), error);
+    }
+  });
+  const hosting = program2.command("hosting").description("\u9759\u6001\u6258\u7BA1\uFF1A\u67E5\u770B / \u90E8\u7F72 / \u62C9\u53D6 / \u914D\u7F6E").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09");
+  hosting.command("info").description("\u67E5\u770B\u9759\u6001\u6258\u7BA1\u914D\u7F6E\u3001\u7AD9\u70B9\u5730\u5740\u4E0E\u6587\u4EF6\u6811").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (flags) => {
+    try {
+      const { hostingInfo: hostingInfo2 } = await Promise.resolve().then(() => (init_hosting(), hosting_exports));
+      const result = await hostingInfo2(paths, {
+        cwd,
+        ...flags.project === void 0 ? {} : { slug: flags.project }
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "hosting info", data: result }));
+      } else {
+        output(
+          `\u7AD9\u70B9\uFF1A${result.siteUrl}\uFF08\u6258\u7BA1 ${result.config.enabled ? "\u5F00" : "\u5173"}\uFF0CSPA \u56DE\u9000 ${result.config.spaMode ? "\u5F00" : "\u5173"}\uFF09`
+        );
+        for (const file of result.files) {
+          output(`${file.path}	${formatBytes(file.size)}`);
+        }
+      }
+    } catch (error) {
+      emitError(output, "hosting info", jsonMode(), error);
+    }
+  });
+  hosting.command("deploy").description("\u90E8\u7F72\u672C\u5730\u76EE\u5F55\u4E3A\u9759\u6001\u7AD9\u70B9\uFF1A\u9012\u5F52\u4E0A\u4F20\u5230 site/ \u5E76\u6253\u5F00\u6258\u7BA1").argument("<dir>", "\u672C\u5730\u7AD9\u70B9\u76EE\u5F55").option("--spa", "\u6253\u5F00\u6258\u7BA1\u5E76\u542F\u7528 SPA \u56DE\u9000\uFF08\u7F3A\u7701\u4EC5\u6253\u5F00\u6258\u7BA1\uFF09", false).option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (dir, flags) => {
+    try {
+      const { hostingDeploy: hostingDeploy2 } = await Promise.resolve().then(() => (init_hosting(), hosting_exports));
+      const result = await hostingDeploy2(paths, {
+        cwd,
+        dir,
+        ...flags.spa === true ? { spa: true } : {},
+        ...flags.project === void 0 ? {} : { slug: flags.project }
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "hosting deploy", data: result }));
+      } else {
+        output(
+          `\u7AD9\u70B9\u5DF2\u4E0A\u7EBF\uFF1A${result.siteUrl}\uFF08${result.uploaded.length} \u4E2A\u6587\u4EF6\uFF0CSPA \u56DE\u9000 ${result.config.spaMode ? "\u5F00" : "\u5173"}\uFF09`
+        );
+      }
+    } catch (error) {
+      emitError(output, "hosting deploy", jsonMode(), error);
+    }
+  });
+  hosting.command("pull").description("\u62C9\u53D6\u7AD9\u70B9\u516C\u5F00\u6587\u4EF6\u5230\u672C\u5730\u76EE\u5F55\uFF08\u8DF3\u8FC7\u6258\u7BA1\u914D\u7F6E\uFF09").option("-o, --output <dir>", "\u672C\u5730\u8F93\u51FA\u76EE\u5F55\uFF08\u7F3A\u7701\u5199\u5230 cwd\uFF09").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (flags) => {
+    try {
+      const { hostingPull: hostingPull2 } = await Promise.resolve().then(() => (init_hosting(), hosting_exports));
+      const result = await hostingPull2(paths, {
+        cwd,
+        ...flags.output === void 0 ? {} : { output: flags.output },
+        ...flags.project === void 0 ? {} : { slug: flags.project }
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "hosting pull", data: result }));
+      } else {
+        output(
+          `\u5DF2\u62C9\u53D6 ${result.files.length} \u4E2A\u6587\u4EF6 \u2192 ${result.outputDir}\uFF08\u7AD9\u70B9\uFF1A${result.siteUrl}\uFF09`
+        );
+      }
+    } catch (error) {
+      emitError(output, "hosting pull", jsonMode(), error);
+    }
+  });
+  hosting.command("config").description("\u66F4\u65B0\u9759\u6001\u6258\u7BA1\u914D\u7F6E\uFF08\u6258\u7BA1\u5F00\u5173 / SPA \u56DE\u9000\u6A21\u5F0F\uFF0C\u5E42\u7B49\uFF09").option("--enabled <true|false>", "\u6258\u7BA1\u5F00\u5173").option("--spa <true|false>", "SPA \u56DE\u9000\u6A21\u5F0F").option("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug\uFF08\u7F3A\u7701\u53D6 adep.config.ts \u7684 name\uFF09").action(async (flags) => {
+    try {
+      const { hostingConfig: hostingConfig2 } = await Promise.resolve().then(() => (init_hosting(), hosting_exports));
+      const enabled = parseBool(flags.enabled);
+      const spa = parseBool(flags.spa);
+      const config = await hostingConfig2(paths, {
+        cwd,
+        ...enabled === void 0 ? {} : { enabled },
+        ...spa === void 0 ? {} : { spa },
+        ...flags.project === void 0 ? {} : { slug: flags.project }
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "hosting config", data: { config } }));
+      } else {
+        output(`\u6258\u7BA1 ${config.enabled ? "\u5F00" : "\u5173"}\uFF0CSPA \u56DE\u9000 ${config.spaMode ? "\u5F00" : "\u5173"}`);
+      }
+    } catch (error) {
+      emitError(output, "hosting config", jsonMode(), error);
+    }
+  });
+  const widget = program2.command("widget").description("\u5FAE\u524D\u7AEF\u7EC4\u4EF6\uFF08widget\uFF09\uFF1A\u811A\u624B\u67B6 / \u672C\u5730\u6C99\u7BB1 / \u53D1\u5E03");
+  widget.command("init").description("\u521D\u59CB\u5316 widget \u5DE5\u7A0B\uFF08\u6A21\u677F\uFF1Avue3-ts / react-ts\uFF09").argument("<name>", "widget \u540D\u79F0\uFF08\u5C0F\u5199\u5B57\u6BCD\u5F00\u5934\uFF0C\u4EC5\u5C0F\u5199\u5B57\u6BCD/\u6570\u5B57/\u8FDE\u5B57\u7B26\uFF09").option("-t, --template <template>", "\u6A21\u677F\uFF1Avue3-ts | react-ts", "vue3-ts").action(async (name, flags) => {
+    try {
+      const { initWidget: initWidget2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+      const result = await initWidget2(cwd, name, flags.template);
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "widget init", data: result }));
+      } else {
+        output(`\u5DF2\u521B\u5EFA widget ${result.projectPath}`);
+      }
+    } catch (error) {
+      emitError(output, "widget init", jsonMode(), error);
+    }
+  });
+  widget.command("dev").description("\u672C\u5730\u5BBF\u4E3B\u6C99\u7BB1\uFF1A\u4E3B\u9898\u53D8\u91CF + mock props + token \u6CE8\u5165 + \u70ED\u66F4\u65B0").option("-p, --port <port>", "\u76D1\u542C\u7AEF\u53E3\uFF08\u7F3A\u7701 8788\uFF09", "8788").action(async (flags) => {
+    try {
+      const { startWidgetDev: startWidgetDev2 } = await Promise.resolve().then(() => (init_dev2(), dev_exports2));
+      const started = await startWidgetDev2({ cwd, port: Number(flags.port ?? "8788") });
+      output(
+        `[adep] widget dev sandbox on ${started.baseUrl}\uFF08?token=<...> \u6CE8\u5165\u9274\u6743 token\uFF1BCtrl-C \u9000\u51FA\uFF09`
+      );
+      await new Promise(() => void 0);
+    } catch (error) {
+      emitError(output, "widget dev", jsonMode(), error);
+    }
+  });
+  widget.command("publish").description("\u6309\u6846\u67B6\u6784\u5EFA \u2192 \u4E0A\u4F20\u5E73\u53F0\u9759\u6001\u8D44\u6E90 \u2192 \u7248\u672C\u5316\u8F93\u51FA URL").requiredOption("-p, --project <slug>", "\u76EE\u6807\u5E73\u53F0\u9879\u76EE slug").action(async (flags) => {
+    try {
+      const { publishWidget: publishWidget2 } = await Promise.resolve().then(() => (init_publish(), publish_exports));
+      const result = await publishWidget2(paths, {
+        cwd,
+        project: flags.project
+      });
+      if (jsonMode()) {
+        output(JSON.stringify({ ok: true, command: "widget publish", data: result }));
+      } else {
+        output(`${result.name}  v${result.version}  ${result.url}`);
+      }
+    } catch (error) {
+      emitError(output, "widget publish", jsonMode(), error);
+    }
+  });
+  return program2;
+}
+
+// packages/cli/src/index.ts
+var program = buildProgram();
+await program.parseAsync(process.argv);