@helipod/cli 0.1.0

package/dist/chunk-IBFZ2HUR.js

@@ -0,0 +1,2653 @@
+import {
+  handleHttpRequest
+} from "./chunk-N5J276OX.js";
+import {
+  loadProject
+} from "./chunk-EPHSHGFU.js";
+
+// src/load-config.ts
+import { existsSync } from "fs";
+import { join } from "path";
+import { pathToFileURL } from "url";
+var CACHE_BUST = () => `?t=${Date.now()}`;
+async function loadConfig(projectDir) {
+  const path = ["helipod.config.ts", "helipod.config.js"].map((f) => join(projectDir, f)).find((p) => existsSync(p));
+  if (!path) return { components: [] };
+  const mod = await import(pathToFileURL(path).href + CACHE_BUST());
+  const cfg = mod.default ?? mod;
+  return { components: cfg.components ?? [], deploy: cfg.deploy, functionsDir: cfg.functionsDir };
+}
+
+// src/functions-dir.ts
+import { existsSync as existsSync2 } from "fs";
+import { dirname, isAbsolute, join as join2, resolve } from "path";
+var DEFAULT_FUNCTIONS_DIR = "helipod";
+async function resolveFunctionsDir(flagValue, cwd) {
+  if (flagValue !== void 0 && flagValue !== "") {
+    const functionsDir = isAbsolute(flagValue) ? flagValue : resolve(cwd, flagValue);
+    return { functionsDir, projectRoot: dirname(functionsDir) };
+  }
+  const projectRoot = resolve(cwd);
+  const config = await loadConfig(projectRoot);
+  const name = config.functionsDir ?? DEFAULT_FUNCTIONS_DIR;
+  return { functionsDir: isAbsolute(name) ? name : join2(projectRoot, name), projectRoot };
+}
+function functionsDirNotFoundMessage(functionsDir) {
+  return `no functions directory found at ${functionsDir}
+
+If this is a Convex app, run \`helipod migrate\` to convert it. It renames
+convex/ to helipod/ and rewrites your imports.
+
+Otherwise create ${join2(functionsDir, "schema.ts")}, or point at an existing folder:
+  helipod dev --dir <path>
+`;
+}
+function ensureFunctionsDirExists(functionsDir) {
+  if (existsSync2(functionsDir)) return true;
+  process.stderr.write(functionsDirNotFoundMessage(functionsDir));
+  return false;
+}
+
+// src/dev-options.ts
+function resolveDevOptions(options = {}) {
+  return {
+    port: options.port ?? 3e3,
+    ip: options.ip ?? "127.0.0.1",
+    functionsDir: options.functionsDir ?? DEFAULT_FUNCTIONS_DIR,
+    dataPath: options.dataPath ?? ".helipod/data.db",
+    runtime: options.runtime ?? "auto",
+    webDir: options.webDir,
+    databaseUrl: options.databaseUrl ?? process.env.HELIPOD_DATABASE_URL,
+    storageBucket: options.storageBucket,
+    storageEndpoint: options.storageEndpoint
+  };
+}
+function detectRuntime() {
+  return typeof globalThis.Bun !== "undefined" ? "bun" : "node";
+}
+
+// src/load-modules.ts
+import { createHash } from "crypto";
+import { readdirSync, existsSync as existsSync3, mkdirSync, writeFileSync } from "fs";
+import { join as join3, resolve as resolve2, dirname as dirname2 } from "path";
+import { pathToFileURL as pathToFileURL2, fileURLToPath } from "url";
+import { build } from "esbuild";
+var CACHE_BUST2 = () => `?t=${Date.now()}`;
+function moduleKeyForFile(file) {
+  return file.replace(/\.(ts|js)$/, "");
+}
+function listFunctionModuleFiles(absDir) {
+  const isModule = (f) => (f.endsWith(".ts") || f.endsWith(".js")) && !f.endsWith(".d.ts") && !f.startsWith("_") && f !== "schema.ts" && f !== "schema.js";
+  return readdirSync(absDir).filter(isModule);
+}
+function nearestNodeModulesRoot(startDir) {
+  let dir = resolve2(startDir);
+  for (; ; ) {
+    if (existsSync3(join3(dir, "node_modules"))) return dir;
+    const parent = dirname2(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function resolveCacheDir(startDir) {
+  const dir = nearestNodeModulesRoot(startDir) ?? // Fallback: the dir containing the CLI's own node_modules (found by walking up from this module).
+  (nearestNodeModulesRoot(dirname2(fileURLToPath(import.meta.url))) ?? resolve2(startDir));
+  const ns = createHash("sha256").update(resolve2(startDir)).digest("hex").slice(0, 16);
+  const cacheDir = join3(dir, "node_modules", ".cache", "helipod", ns);
+  mkdirSync(cacheDir, { recursive: true });
+  return cacheDir;
+}
+function extraBundleExternals() {
+  const raw = process.env.HELIPOD_BUNDLE_EXTERNAL;
+  if (!raw) return [];
+  return raw.split(",").map((s) => s.trim()).filter(Boolean);
+}
+async function bundleAndImport(file, key, cacheDir) {
+  const result = await build({
+    entryPoints: [file],
+    bundle: true,
+    external: ["@helipod/*", ...extraBundleExternals()],
+    format: "esm",
+    platform: "node",
+    write: false,
+    sourcemap: "inline",
+    logLevel: "silent"
+  });
+  const code = result.outputFiles[0].text;
+  const outFile = join3(cacheDir, `${key.replace(/[\\/]/g, "__")}.mjs`);
+  writeFileSync(outFile, code);
+  return await import(pathToFileURL2(outFile).href + CACHE_BUST2());
+}
+async function loadFunctionsDir(dir) {
+  const absDir = resolve2(dir);
+  const entries = listFunctionModuleFiles(absDir);
+  const cacheDir = resolveCacheDir(absDir);
+  const schemaFile = existsSync3(join3(absDir, "schema.ts")) ? "schema.ts" : "schema.js";
+  const schemaModule = await bundleAndImport(join3(absDir, schemaFile), "schema", cacheDir);
+  const modules = {};
+  for (const file of entries) {
+    const key = moduleKeyForFile(file);
+    modules[key] = await bundleAndImport(join3(absDir, file), key, cacheDir);
+  }
+  return { schema: schemaModule.default, modules };
+}
+
+// src/push-pipeline.ts
+import { generateAll } from "@helipod/codegen";
+function push(loaded, components = [], existingTableNumbers) {
+  const project = loadProject(loaded, components, existingTableNumbers);
+  const generated = generateAll({
+    schema: project.schemaJson,
+    manifest: project.manifest,
+    tableNumbers: project.tableNumbers,
+    components: components.map((c) => ({ name: c.name, contextType: c.contextType, serverExports: c.serverExports }))
+  });
+  return { project, generated };
+}
+
+// src/boot.ts
+import { mkdirSync as mkdirSync2, readFileSync, accessSync, constants as fsConstants } from "fs";
+import { createRequire } from "module";
+import { dirname as dirname3, join as join5, resolve as resolve3 } from "path";
+import { randomUUID } from "crypto";
+import { NodeSqliteAdapter, BunSqliteAdapter, SqliteDocStore } from "@helipod/docstore-sqlite";
+import { NodePgClient, BunSqlClient, PostgresDocStore } from "@helipod/docstore-postgres";
+import {
+  createEmbeddedRuntime
+} from "@helipod/runtime-embedded";
+import { InMemoryLogSink } from "@helipod/executor";
+import { AdminApi, browseTableModule, systemModules, verifyAdminKey } from "@helipod/admin";
+import { shardIdList, DEFAULT_SHARD } from "@helipod/id-codec";
+import {
+  storageContextProvider,
+  storageReaper,
+  storageModules,
+  storageRoutes
+} from "@helipod/storage";
+import { receiptsReaper } from "@helipod/receipts";
+
+// src/blobstore-select.ts
+import { join as join4 } from "path";
+import { FsBlobStore } from "@helipod/blobstore-fs";
+import { S3BlobStore } from "@helipod/blobstore-s3";
+function isS3Config(storage) {
+  return Boolean(storage?.bucket);
+}
+function resolveStorageConfig(env, flags) {
+  return {
+    bucket: flags?.bucket ?? env.HELIPOD_STORAGE_BUCKET,
+    endpoint: flags?.endpoint ?? env.HELIPOD_STORAGE_ENDPOINT,
+    region: flags?.region ?? env.HELIPOD_STORAGE_REGION,
+    publicBaseUrl: flags?.publicBaseUrl ?? env.HELIPOD_STORAGE_PUBLIC_URL,
+    accessKeyId: flags?.accessKeyId ?? env.AWS_ACCESS_KEY_ID,
+    secretAccessKey: flags?.secretAccessKey ?? env.AWS_SECRET_ACCESS_KEY,
+    ...flags?.forcePathStyle !== void 0 ? { forcePathStyle: flags.forcePathStyle } : {}
+  };
+}
+function makeBlobStore(opts) {
+  const s = opts.storage;
+  if (isS3Config(s)) {
+    return new S3BlobStore({
+      bucket: s.bucket,
+      region: s.region,
+      endpoint: s.endpoint,
+      accessKeyId: s.accessKeyId,
+      secretAccessKey: s.secretAccessKey,
+      forcePathStyle: s.forcePathStyle,
+      publicBaseUrl: s.publicBaseUrl
+    });
+  }
+  return new FsBlobStore({ root: join4(opts.dataPath, "storage") });
+}
+
+// src/objectstore-select.ts
+import { FsObjectStore } from "@helipod/objectstore-fs";
+import { S3ObjectStore } from "@helipod/objectstore-s3";
+function parseBoolParam(v) {
+  if (v === null) return void 0;
+  if (v === "true") return true;
+  if (v === "false") return false;
+  throw new Error(`helipod: invalid --object-store URL \u2014 forcePathStyle must be "true" or "false", got "${v}"`);
+}
+function parseS3ObjectStoreUrl(url, env = process.env) {
+  let u;
+  try {
+    u = new URL(url);
+  } catch (e) {
+    throw new Error(`helipod: invalid --object-store URL "${url}": ${e.message}`);
+  }
+  const bucket = decodeURIComponent(u.pathname.replace(/^\//, "").split("/")[0] ?? "");
+  if (!bucket) {
+    throw new Error(
+      `helipod: --object-store S3 URL "${url}" has no bucket \u2014 use s3://host/<bucket> (or s3:///<bucket> for real AWS S3 with no custom endpoint).`
+    );
+  }
+  const endpointProtocol = u.protocol === "s3+https:" ? "https" : "http";
+  const explicitEndpoint = u.searchParams.get("endpoint") ?? void 0;
+  const endpoint = explicitEndpoint ?? (u.hostname ? `${endpointProtocol}://${u.hostname}${u.port ? `:${u.port}` : ""}` : void 0);
+  const region = u.searchParams.get("region") ?? void 0;
+  const forcePathStyle = parseBoolParam(u.searchParams.get("forcePathStyle"));
+  const accessKeyId = (u.username ? decodeURIComponent(u.username) : void 0) ?? env.AWS_ACCESS_KEY_ID;
+  const secretAccessKey = (u.password ? decodeURIComponent(u.password) : void 0) ?? env.AWS_SECRET_ACCESS_KEY;
+  if (!accessKeyId || !secretAccessKey) {
+    throw new Error(
+      `helipod: --object-store S3 URL "${url}" is missing credentials \u2014 supply them in the URL (s3://accessKeyId:secretAccessKey@\u2026) or set AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY.`
+    );
+  }
+  return { bucket, endpoint, region, accessKeyId, secretAccessKey, forcePathStyle };
+}
+function parseFsObjectStorePath(url) {
+  return url.startsWith("file://") ? url.slice("file://".length) : url;
+}
+var SCHEME_RE = /^([a-zA-Z][a-zA-Z0-9+.\-]*):\/\//;
+var SUPPORTED_SCHEMES = "s3://, s3+http://, s3+https://, file:// (or a bare filesystem path with no scheme)";
+function resolveObjectStore(url, env = process.env) {
+  const trimmed = url?.trim();
+  if (!trimmed) return null;
+  const schemeMatch = trimmed.match(SCHEME_RE);
+  if (!schemeMatch) {
+    return { objectStore: new FsObjectStore({ dir: parseFsObjectStorePath(trimmed) }), kind: "fs" };
+  }
+  switch (schemeMatch[1]) {
+    case "s3":
+    case "s3+http":
+    case "s3+https": {
+      const config = parseS3ObjectStoreUrl(trimmed, env);
+      return { objectStore: new S3ObjectStore(config), kind: "s3" };
+    }
+    case "file":
+      return { objectStore: new FsObjectStore({ dir: parseFsObjectStorePath(trimmed) }), kind: "fs" };
+    default:
+      throw new Error(
+        `helipod: --object-store URL "${trimmed}" uses an unsupported scheme "${schemeMatch[1]}://" \u2014 supported schemes are ${SUPPORTED_SCHEMES}.`
+      );
+  }
+}
+
+// src/replica-forward.ts
+function trimTrailingSlash(url) {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+var ReplicaWriteForwarder = class {
+  constructor(writerUrl) {
+    this.writerUrl = writerUrl;
+  }
+  writerUrl;
+  /** A replica is never the writer for any shard — every mutation/action forwards. Consulted
+   *  fresh on every call (mirrors the fleet forwarder's own "never cached" contract) — cheap
+   *  here since it's a constant, not a live lease read. */
+  isLocalWriter(_shardId) {
+    return false;
+  }
+  async forward(kind, path, args, identity, _shardId, dedup) {
+    const body = {
+      path,
+      args,
+      kind,
+      forwarded: true,
+      ...dedup ? { clientId: dedup.clientId, seq: dedup.seq } : {}
+    };
+    let res;
+    try {
+      res = await fetch(`${trimTrailingSlash(this.writerUrl)}/api/run`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          ...identity !== null ? { authorization: `Bearer ${identity}` } : {}
+        },
+        body: JSON.stringify(body)
+      });
+    } catch (e) {
+      throw new Error(
+        `helipod: replica write-forward to writer "${this.writerUrl}" failed (unreachable) for ${kind} "${path}" \u2014 ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+    const text = await res.text();
+    let parsed = {};
+    try {
+      parsed = text ? JSON.parse(text) : {};
+    } catch {
+      parsed = {};
+    }
+    if (!res.ok || parsed.error !== void 0) {
+      throw new Error(
+        parsed.error ?? `helipod: replica write-forward to writer "${this.writerUrl}" returned HTTP ${res.status} for ${kind} "${path}"`
+      );
+    }
+    if (parsed.clientReplay) return { value: parsed.clientReplay.value ?? null, replay: parsed.clientReplay };
+    return {
+      value: parsed.value ?? null,
+      commitTs: parsed.commitTs !== void 0 ? Number(parsed.commitTs) : void 0
+    };
+  }
+};
+
+// src/boot.ts
+function isPostgresUrl(s) {
+  return !!s && /^postgres(ql)?:\/\//.test(s);
+}
+function makePgClient(connectionString) {
+  return detectRuntime() === "bun" ? new BunSqlClient({ connectionString }) : new NodePgClient({ connectionString });
+}
+function makeStore(opts) {
+  if (isPostgresUrl(opts.databaseUrl)) {
+    return new PostgresDocStore(makePgClient(opts.databaseUrl));
+  }
+  mkdirSync2(dirname3(resolve3(opts.dataPath)), { recursive: true });
+  const adapter = detectRuntime() === "bun" ? new BunSqliteAdapter({ path: opts.dataPath }) : new NodeSqliteAdapter({ path: opts.dataPath });
+  return new SqliteDocStore(adapter);
+}
+var OBJECTSTORE_SUBSTRATE_ERR_NO_PACKAGE = "helipod: --object-store requires @helipod/objectstore-substrate \u2014 install it (bun add @helipod/objectstore-substrate).";
+function isObjectStoreBootFailFast(e) {
+  return e instanceof Error && /^helipod: (--object-store|invalid --object-store)\b/.test(e.message);
+}
+async function loadObjectStoreSubstrateModule() {
+  try {
+    const specifier = "@helipod/objectstore-substrate";
+    return await import(specifier);
+  } catch {
+    throw new Error(OBJECTSTORE_SUBSTRATE_ERR_NO_PACKAGE);
+  }
+}
+async function acquireWithRetry(store, opts) {
+  const now = opts.now ?? Date.now;
+  const pollIntervalMs = opts.pollIntervalMs ?? 1e3;
+  const deadline = now() + opts.timeoutMs;
+  let last;
+  for (; ; ) {
+    const result = await store.acquire({ writerId: opts.writerId, leaseTtlMs: opts.leaseTtlMs, now: now() });
+    if (result.acquired) return;
+    last = { heldBy: result.heldBy, expiresAt: result.expiresAt };
+    if (now() >= deadline) {
+      throw new Error(
+        `helipod: --object-store shard "0" held by '${last.heldBy}' until ${new Date(last.expiresAt).toISOString()} \u2014 timed out after ${opts.timeoutMs}ms waiting for the lease to free up. If '${last.heldBy}' crashed, its lease will expire on its own and a retry will take over; otherwise stop that writer before starting this one.`
+      );
+    }
+    await new Promise((r) => setTimeout(r, pollIntervalMs));
+  }
+}
+function makeLocalSqliteStore(dataPath) {
+  mkdirSync2(dirname3(resolve3(dataPath)), { recursive: true });
+  const adapter = detectRuntime() === "bun" ? new BunSqliteAdapter({ path: dataPath }) : new NodeSqliteAdapter({ path: dataPath });
+  return new SqliteDocStore(adapter);
+}
+function makeInMemorySqliteStore() {
+  const adapter = detectRuntime() === "bun" ? new BunSqliteAdapter({ path: ":memory:" }) : new NodeSqliteAdapter({ path: ":memory:" });
+  return new SqliteDocStore(adapter);
+}
+var RUNTIME_DEPLOYMENT_ID_GLOBAL_KEY = "fleet:deploymentId";
+var DEFAULT_OBJECTSTORE_LEASE_TTL_MS = 15e3;
+var DEFAULT_OBJECTSTORE_HEARTBEAT_MS = 5e3;
+var DEFAULT_OBJECTSTORE_GC_MS = 6e4;
+async function buildObjectStoreWriterNode(opts) {
+  const resolved = resolveObjectStore(opts.objectStoreUrl);
+  if (resolved === null) {
+    throw new Error(`helipod: --object-store "${opts.objectStoreUrl}" did not resolve to a store (empty/unset value?).`);
+  }
+  await resolved.objectStore.assertCasSupported();
+  const substrate = await loadObjectStoreSubstrateModule();
+  const writerId = opts.writerId ?? randomUUID();
+  const leaseTtlMs = opts.leaseTtlMs ?? DEFAULT_OBJECTSTORE_LEASE_TTL_MS;
+  const heartbeatMs = opts.heartbeatMs ?? DEFAULT_OBJECTSTORE_HEARTBEAT_MS;
+  const acquireTimeoutMs = opts.acquireTimeoutMs ?? leaseTtlMs + 5e3;
+  const gcMs = opts.gcMs ?? DEFAULT_OBJECTSTORE_GC_MS;
+  const desiredShards = opts.shards && opts.shards > 1 ? opts.shards : 1;
+  const globals = await substrate.ensureGlobals(resolved.objectStore, {
+    deploymentId: randomUUID(),
+    numShards: desiredShards
+  });
+  const numShards = globals.numShards;
+  if (opts.shards !== void 0 && opts.shards !== numShards) {
+    throw new Error(
+      `helipod: --shards ${opts.shards} disagrees with the bucket's persisted shard count ${numShards} \u2014 reshard the bucket (\`helipod objectstore reshard --object-store <url> --dir <dir> --shards ${opts.shards}\`) to change it, or drop --shards.`
+    );
+  }
+  const shardIds = numShards > 1 ? [...shardIdList(numShards)] : ["0"];
+  const buildLane = async (shardId, laneDataPath) => {
+    const local = makeLocalSqliteStore(laneDataPath);
+    const lane = await substrate.ObjectStoreDocStore.open({ objectStore: resolved.objectStore, shard: shardId, local });
+    await lane.writeGlobalIfAbsent(RUNTIME_DEPLOYMENT_ID_GLOBAL_KEY, globals.deploymentId);
+    await acquireWithRetry(lane, {
+      writerId,
+      leaseTtlMs,
+      timeoutMs: acquireTimeoutMs,
+      ...opts.acquirePollIntervalMs !== void 0 ? { pollIntervalMs: opts.acquirePollIntervalMs } : {}
+    });
+    const heartbeat = substrate.leaseHeartbeatDriver(lane, {
+      leaseTtlMs,
+      heartbeatMs,
+      onFenced: (e) => opts.onFenced?.(e)
+    });
+    const gc = substrate.gcDriver(lane, { sweepMs: gcMs });
+    return { lane, heartbeat, gc };
+  };
+  const built = [];
+  for (const shardId of shardIds) {
+    const laneDataPath = numShards > 1 ? `${opts.dataPath}.${shardId}` : opts.dataPath;
+    built.push({ shardId, ...await buildLane(shardId, laneDataPath) });
+  }
+  const drivers = built.flatMap((b) => [b.heartbeat, b.gc]);
+  const release = async () => {
+    await Promise.all(built.map((b) => b.lane.relinquish()));
+  };
+  if (numShards === 1) return { store: built[0].lane, drivers, release, numShards };
+  const lanes = new Map(built.map((b) => [b.shardId, b.lane]));
+  const store = new substrate.ShardedObjectStoreDocStore(lanes, { defaultShard: DEFAULT_SHARD });
+  return { store, drivers, release, numShards };
+}
+var REPLICA_WRITE_REJECTED_MESSAGE = "helipod: this node is a read replica (--replica) \u2014 it holds no write lease and cannot commit mutations. Send writes to the primary/writer node.";
+var LEASE_OWNER_REJECTION_RE = /not the lease owner/;
+function wrapReplicaWriteRejection(store) {
+  return new Proxy(store, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "function") return value;
+      const bound = value.bind(target);
+      if (prop !== "commitWrite" && prop !== "commitWriteBatch") return bound;
+      return async (...args) => {
+        try {
+          return await bound(...args);
+        } catch (e) {
+          if (e instanceof Error && LEASE_OWNER_REJECTION_RE.test(e.message)) {
+            throw new Error(REPLICA_WRITE_REJECTED_MESSAGE);
+          }
+          throw e;
+        }
+      };
+    }
+  });
+}
+function defaultReplicaConsumerId() {
+  return `replica-${randomUUID()}`;
+}
+var DEFAULT_OBJECTSTORE_REPLICA_POLL_MS = 1e3;
+async function buildObjectStoreReplicaNode(opts) {
+  const resolved = resolveObjectStore(opts.objectStoreUrl);
+  if (resolved === null) {
+    throw new Error(`helipod: --object-store "${opts.objectStoreUrl}" did not resolve to a store (empty/unset value?).`);
+  }
+  await resolved.objectStore.assertCasSupported();
+  const substrate = await loadObjectStoreSubstrateModule();
+  const objectStore = resolved.objectStore;
+  const globals = await substrate.ensureGlobals(objectStore, { deploymentId: randomUUID(), numShards: 1 });
+  const numShards = globals.numShards;
+  const shardIds = numShards > 1 ? [...shardIdList(numShards)] : ["0"];
+  const lanes = [];
+  for (const shardId of shardIds) {
+    const laneDataPath = numShards > 1 ? `${opts.dataPath}.${shardId}` : opts.dataPath;
+    const local = makeLocalSqliteStore(laneDataPath);
+    const laneStore = await substrate.ObjectStoreDocStore.open({ objectStore, shard: shardId, local });
+    await laneStore.writeGlobalIfAbsent(RUNTIME_DEPLOYMENT_ID_GLOBAL_KEY, globals.deploymentId);
+    lanes.push({ shardId, store: laneStore, local });
+  }
+  const composite = numShards === 1 ? lanes[0].store : new substrate.ShardedObjectStoreDocStore(new Map(lanes.map((l) => [l.shardId, l.store])), {
+    defaultShard: DEFAULT_SHARD
+  });
+  const store = wrapReplicaWriteRejection(composite);
+  const baseConsumerId = opts.consumerId ?? defaultReplicaConsumerId();
+  const pollMs = opts.pollMs ?? DEFAULT_OBJECTSTORE_REPLICA_POLL_MS;
+  const laneConsumerId = (shardId) => numShards === 1 ? baseConsumerId : `${baseConsumerId}:${shardId}`;
+  return {
+    store,
+    numShards,
+    attachTailer: (runtime) => {
+      const handles = lanes.map(
+        (l) => substrate.startReplicaReactiveTailer({
+          runtime,
+          objectStore,
+          shard: l.shardId,
+          local: l.local,
+          consumerId: laneConsumerId(l.shardId),
+          pollMs
+        })
+      );
+      return async () => {
+        await Promise.all(handles.map((h) => h.stop()));
+        await Promise.all(lanes.map((l) => substrate.removeConsumer(objectStore, l.shardId, laneConsumerId(l.shardId))));
+      };
+    }
+  };
+}
+var DEFAULT_NUM_SHARDS = 8;
+var NUM_SHARDS_GLOBAL_KEY = "fleet:numShards";
+function parseNumShards(raw) {
+  if (raw === void 0 || raw.trim() === "") return void 0;
+  const n = Number(raw);
+  return Number.isFinite(n) && Number.isInteger(n) && n >= 1 ? n : void 0;
+}
+function groupCommitEnabled(raw) {
+  return /^(1|true|yes)$/i.test(raw ?? "");
+}
+function resolveGroupCommit(opts) {
+  const raw = opts.envRaw;
+  if (raw !== void 0 && raw !== "") return groupCommitEnabled(raw);
+  return isPostgresUrl(opts.databaseUrl);
+}
+function numShardsMismatchError(envValue, persisted) {
+  return new Error(
+    `helipod: HELIPOD_FLEET_SHARDS=${envValue} conflicts with the shard count already persisted for this deployment (${persisted}, set at first boot). The shard count is immutable after first boot \u2014 changing it live isn't supported; resharding is a planned offline tool (B5). Unset HELIPOD_FLEET_SHARDS, or set it to ${persisted} to match the existing deployment.`
+  );
+}
+async function resolveNumShards(store, envValue) {
+  const persistedRaw = await store.getGlobal(NUM_SHARDS_GLOBAL_KEY);
+  if (persistedRaw !== null) {
+    const persisted = Number(persistedRaw);
+    if (envValue !== void 0 && envValue !== persisted) throw numShardsMismatchError(envValue, persisted);
+    return persisted;
+  }
+  const resolved = envValue ?? DEFAULT_NUM_SHARDS;
+  const wrote = await store.writeGlobalIfAbsent(NUM_SHARDS_GLOBAL_KEY, String(resolved));
+  if (wrote) return resolved;
+  const raced = Number(await store.getGlobal(NUM_SHARDS_GLOBAL_KEY));
+  if (envValue !== void 0 && envValue !== raced) throw numShardsMismatchError(envValue, raced);
+  return raced;
+}
+function withStorageModules(map) {
+  return { ...map, ...storageModules };
+}
+function assertStorageConfigCoherent(storage) {
+  if (isS3Config(storage)) return;
+  const s3Shaped = storage?.endpoint !== void 0 || storage?.region !== void 0 || storage?.publicBaseUrl !== void 0;
+  if (!s3Shaped) return;
+  throw new Error(
+    "helipod: S3 storage settings (HELIPOD_STORAGE_ENDPOINT/REGION/PUBLIC_URL or --storage-endpoint/etc.) are set, but no bucket was provided \u2014 the S3 backend is selected only by HELIPOD_STORAGE_BUCKET (or --storage-bucket). Set the bucket to use S3, or unset the other storage settings to use local FS. Refusing to boot rather than silently store uploads on local disk."
+  );
+}
+function ensureStorageDirWritable(dir) {
+  try {
+    mkdirSync2(dir, { recursive: true });
+    accessSync(dir, fsConstants.W_OK);
+  } catch (e) {
+    throw new Error(
+      `helipod: file-storage directory "${dir}" is not creatable/writable \u2014 ${e instanceof Error ? e.message : String(e)}. Point --data at a writable location, or configure S3 storage (set HELIPOD_STORAGE_BUCKET).`
+    );
+  }
+}
+async function bootLoaded(opts) {
+  const { project, generated } = push(opts.loaded, opts.components);
+  const logSink = new InMemoryLogSink();
+  if (opts.objectStoreUrl !== void 0 && opts.fleet) {
+    throw new Error("helipod: --object-store cannot be combined with --fleet (Tier 2) \u2014 pick one write-scaling story.");
+  }
+  if (opts.replica && opts.objectStoreUrl === void 0) {
+    throw new Error(
+      "helipod: --replica requires --object-store \u2014 a replica materializes from an object-storage bucket; pass --object-store <url>."
+    );
+  }
+  const objectStoreWriterNode = opts.objectStoreUrl !== void 0 && !opts.replica ? await buildObjectStoreWriterNode({
+    objectStoreUrl: opts.objectStoreUrl,
+    dataPath: opts.dataPath,
+    onFenced: opts.objectStoreOnFenced,
+    leaseTtlMs: opts.objectStoreLeaseTtlMs,
+    heartbeatMs: opts.objectStoreHeartbeatMs,
+    acquireTimeoutMs: opts.objectStoreAcquireTimeoutMs,
+    acquirePollIntervalMs: opts.objectStoreAcquirePollIntervalMs,
+    writerId: opts.objectStoreWriterId,
+    gcMs: opts.objectStoreGcMs,
+    ...opts.objectStoreShards !== void 0 ? { shards: opts.objectStoreShards } : {}
+  }) : void 0;
+  const objectStoreReplicaNode = opts.objectStoreUrl !== void 0 && opts.replica ? await buildObjectStoreReplicaNode({
+    objectStoreUrl: opts.objectStoreUrl,
+    dataPath: opts.dataPath,
+    consumerId: opts.objectStoreReplicaConsumerId,
+    pollMs: opts.objectStoreReplicaPollMs
+  }) : void 0;
+  const store = opts.fleet?.store ?? objectStoreWriterNode?.store ?? objectStoreReplicaNode?.store ?? makeStore({ dataPath: opts.dataPath, databaseUrl: opts.databaseUrl });
+  if (objectStoreReplicaNode && opts.writerUrl !== void 0 && objectStoreReplicaNode.numShards > 1) {
+    throw new Error(
+      `helipod: --writer-url (replica write-forwarding) is not yet supported on a multi-shard bucket (this bucket has ${objectStoreReplicaNode.numShards} shards) \u2014 run the replica in reject mode (drop --writer-url) and send writes directly to the writer, or use a single-shard deployment.`
+    );
+  }
+  const replicaWriteForwarder = objectStoreReplicaNode && opts.writerUrl !== void 0 ? new ReplicaWriteForwarder(opts.writerUrl) : void 0;
+  let numShards;
+  if (opts.fleet) {
+    numShards = opts.fleet.numShards ?? 1;
+  } else if (objectStoreWriterNode || objectStoreReplicaNode) {
+    await store.setupSchema();
+    numShards = objectStoreWriterNode?.numShards ?? objectStoreReplicaNode?.numShards ?? 1;
+  } else {
+    await store.setupSchema();
+    numShards = await resolveNumShards(store, parseNumShards(process.env.HELIPOD_FLEET_SHARDS));
+  }
+  const groupCommit = opts.fleet ? opts.fleet.groupCommit ?? false : resolveGroupCommit({ envRaw: process.env.HELIPOD_GROUP_COMMIT, databaseUrl: opts.databaseUrl });
+  const dataDir = dirname3(resolve3(opts.dataPath));
+  const storageConfig = resolveStorageConfig(process.env, opts.storage);
+  assertStorageConfigCoherent(storageConfig);
+  const blobStore = makeBlobStore({ dataPath: dataDir, storage: storageConfig });
+  if (!isS3Config(storageConfig)) ensureStorageDirWritable(join5(dataDir, "storage"));
+  const runtime = await createEmbeddedRuntime({
+    store,
+    catalog: project.catalog,
+    logSink,
+    // `_storage:*` built-ins go in BOTH maps: `modules` (reached by the action facade's `invoke`
+    // and the reaper's `runFunction`) and `systemModules` (reached by the HTTP routes' `runSystem`,
+    // the same trusted path `_admin` uses). `systemModules` isn't swapped by `setModules`, so it
+    // persists across reload/deploy on its own; `modules` is re-applied via `withStorageModules`.
+    modules: withStorageModules(project.moduleMap),
+    systemModules: { ...systemModules(), ...storageModules },
+    adminModules: { "_admin:browseTable": browseTableModule },
+    verifyAdmin: (key) => verifyAdminKey(opts.adminKey, key),
+    componentNames: project.componentNames,
+    // Prepend the `ctx.storage` provider and the orphan-reaper driver to whatever components composed.
+    contextProviders: [
+      storageContextProvider(blobStore, {
+        signingKey: opts.adminKey,
+        ...opts.storageUploadTtlMs !== void 0 ? { uploadTtlMs: opts.storageUploadTtlMs } : {}
+      }),
+      ...project.contextProviders
+    ],
+    tableNumbers: project.tableNumbers,
+    bootSteps: project.bootSteps,
+    drivers: [
+      storageReaper(blobStore, opts.storageReaperSweepMs !== void 0 ? { sweepMs: opts.storageReaperSweepMs } : void 0),
+      // Receipted Outbox TTL reaper (verdict §(c) Retention): a timer-only bulk sweep of expired
+      // `client_mutations` rows. Always on (every deployment has the receipts tables); no-op work when
+      // no client ever wrote a receipt. Reads the SAME `store` the runtime commits to.
+      receiptsReaper(store),
+      // Tier 3 Slice 6: the lease-heartbeat + gc drivers (renews shard-0's lease on cadence; stops +
+      // signals via `objectStoreOnFenced` on a fence). Writer-only — empty outside the object-store
+      // writer path (absent entirely for a `--replica` node, Task 8.2: no heartbeat, no gc — a
+      // replica holds no lease and reclaims nothing; its OWN reactive-tailer wiring is started
+      // separately, below, once the runtime exists).
+      ...objectStoreWriterNode?.drivers ?? [],
+      ...project.drivers
+    ],
+    // Fleet (Tier 2): route writes to the lease-holder when not the writer, defer drivers until
+    // promotion, and (writer boot) fan out commits cross-process via pg_notify.
+    ...opts.fleet?.writeRouter ? { writeRouter: opts.fleet.writeRouter } : {},
+    // Tier 3 Slice 8 follow-on (replica write-forwarding): mutually exclusive with `opts.fleet`
+    // (guarded at the top of this function — `--object-store` + `--fleet` throws), so at most one
+    // of these two `writeRouter` spreads ever contributes a key.
+    ...replicaWriteForwarder ? { writeRouter: replicaWriteForwarder } : {},
+    ...opts.fleet?.deferDrivers ? { deferDrivers: true } : {},
+    ...opts.fleet?.fanoutAdapter ? { fanoutAdapter: opts.fleet.fanoutAdapter } : {},
+    // Fleet B3 hybrid (multi-writer): the replica-backed query path + the own-commit RYOW drain gate.
+    ...opts.fleet?.queryStore ? { queryStore: opts.fleet.queryStore } : {},
+    // Receipted Outbox (verdict §(c) placement): route the Connect handshake's classification/ack-prune
+    // to the authoritative PRIMARY receipts store on a sync node (whose `store` is the receipt-less
+    // replica) — without this the handshake spuriously resets a client. Absent → the runtime uses `store`.
+    ...opts.fleet?.receiptsStore ? { receiptsStore: opts.fleet.receiptsStore } : {},
+    ...opts.fleet?.beforeNotify ? { beforeNotify: opts.fleet.beforeNotify } : {},
+    // Triggers D1: the fleet stable-prefix bound for `readLog` (`min(shard_leases.frontier_ts)`).
+    ...opts.fleet?.stablePrefix ? { stablePrefix: opts.fleet.stablePrefix } : {},
+    // Receipted Outbox: fleet owns the receipts guard on the concrete Postgres store (armWriter,
+    // before the fence) — the runtime skips its own registration so it never lands on a sync node's
+    // SwitchableDocStore only to vanish on the promotion swapTo. Non-fleet → the runtime owns it.
+    ...opts.fleet?.externalReceiptsGuard ? { externalReceiptsGuard: true } : {},
+    // Shards B2a: >1 → a ShardedTransactor (per-shard parallel commits) over the store — resolved
+    // above (fleet: threaded in already-resolved; non-fleet: resolved+persisted just now).
+    numShards,
+    // Fleet B4 (T4): route every shard's commits through the group-commit committer loop — resolved
+    // above (fleet: threaded in already-resolved; non-fleet: read from HELIPOD_GROUP_COMMIT).
+    groupCommit,
+    // The wake seam (`serve --wake-url` / `--backstop-min-ms`): a host that stops the process between
+    // requests fires driver timers via `runtime.fireDueTimers()` instead of `setTimeout`, and can
+    // stretch the pure-backstop cadences so an idle app isn't cold-started every 30s. Both absent →
+    // today's `setTimeout` + 30s/60s behavior, unchanged.
+    ...opts.wakeHost ? { wakeHost: opts.wakeHost } : {},
+    ...opts.backstopMs ? { backstopMs: opts.backstopMs } : {}
+  });
+  const objectStoreReplicaRelease = objectStoreReplicaNode ? objectStoreReplicaNode.attachTailer(runtime) : void 0;
+  const storageRouteDeps = {
+    // The routes reach the privileged `_storage:_finalize`/`_get` built-ins via `runSystem` (trusted,
+    // like `_admin`), which reads `systemModules` — unaffected by any later `setModules` swap.
+    runMutation: async (path, args) => (await runtime.runSystem(path, args)).value,
+    runQuery: async (path, args) => (await runtime.runSystem(path, args)).value,
+    signingKey: opts.adminKey,
+    // When authz isn't composed (the default), leave `checkRead` undefined so `handleServe` falls
+    // back to the capability-token check (a private file's `getUrl` embeds a valid token). See the
+    // task-10 report for the authz effective-permissions bridge status.
+    checkRead: makeStorageCheckRead(opts.components)
+  };
+  const routes = storageRoutes(blobStore, storageRouteDeps);
+  const bearerOf = (request) => {
+    const h = request.headers.get("authorization");
+    const m = h ? /^Bearer\s+(.+)$/.exec(h) : null;
+    return m ? m[1] ?? null : null;
+  };
+  const componentRoutes = project.componentRoutes.map((r) => ({
+    method: r.method,
+    pathPrefix: r.pathPrefix,
+    handler: (request) => runtime.runHttpAction(r.handlerPath, request, { identity: bearerOf(request) })
+  }));
+  const adminApi = new AdminApi({
+    runtime,
+    schemaJson: project.schemaJson,
+    tableNumbers: project.tableNumbers,
+    manifest: project.manifest,
+    logSink,
+    catalog: project.catalog
+  });
+  return {
+    runtime,
+    adminApi,
+    project,
+    generated,
+    store,
+    logSink,
+    components: opts.components,
+    blobStore,
+    storageRoutes: routes,
+    componentRoutes,
+    // Mutually exclusive by construction (Task 8.2 guards `objectStoreUrl !== undefined && !replica`
+    // vs. `&& replica`) — at most one of these two spreads ever contributes a key, so `serve.ts`'s
+    // shutdown can call `objectStoreRelease()` generically without knowing which node type booted.
+    ...objectStoreWriterNode ? { objectStoreRelease: objectStoreWriterNode.release } : {},
+    ...objectStoreReplicaRelease ? { objectStoreRelease: objectStoreReplicaRelease } : {},
+    // Tier 3 Slice 8 follow-on (replica write-forwarding): threaded through so `serve.ts` can arm
+    // `/api/run`'s single-hop defensive guard on THIS node (`startDevServer`'s `replicaWriterUrl`).
+    ...replicaWriteForwarder ? { replicaWriterUrl: opts.writerUrl } : {}
+  };
+}
+function makeStorageCheckRead(_components) {
+  return void 0;
+}
+async function bootProject(opts) {
+  const { functionsDir, ...forwarded } = opts;
+  const loaded = await loadFunctionsDir(functionsDir);
+  const config = await loadConfig(dirname3(functionsDir));
+  return bootLoaded({ ...forwarded, loaded, components: config.components });
+}
+function loadDashboard(adminKey) {
+  try {
+    const indexPath = createRequire(import.meta.url).resolve("@helipod/dashboard/dist");
+    const distDir = dirname3(indexPath);
+    const raw = readFileSync(indexPath, "utf8");
+    if (adminKey === void 0) return { distDir, html: raw };
+    const inject = `<script>window.__ADMIN_KEY__=${JSON.stringify(adminKey).replace(/</g, "\\u003c")}</script>`;
+    return { distDir, html: raw.replace("</head>", `${inject}</head>`) };
+  } catch {
+    return void 0;
+  }
+}
+
+// src/server.ts
+import { createServer } from "http";
+import { readFileSync as readFileSync2, realpathSync, statSync } from "fs";
+import { extname, join as join6, resolve as resolve4, sep } from "path";
+var SYNC_PATH = "/api/sync";
+var STORAGE_PREFIX = "/api/storage/";
+var MAX_BODY_BYTES = 5 * 1024 * 1024;
+function matchStorageRoute(routes, method, path) {
+  if (!routes || !path.startsWith(STORAGE_PREFIX)) return void 0;
+  return routes.find((r) => r.method === method && path.startsWith(r.pathPrefix));
+}
+function matchComponentRoute(routes, method, path) {
+  if (!routes) return void 0;
+  return routes.find((r) => r.method === method && path.startsWith(r.pathPrefix));
+}
+function hasBody(method) {
+  return method === "POST" || method === "PUT" || method === "PATCH";
+}
+var CONTENT_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon"
+};
+var EMBEDDED_CONTENT_TYPES = {
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".html": "text/html",
+  ".svg": "image/svg+xml",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".json": "application/json",
+  ".map": "application/json"
+};
+async function serveDashboard(path, d) {
+  if ("distDir" in d) {
+    if (path === "/_dashboard" || path === "/_dashboard/" || path === "/_dashboard/index.html")
+      return { contentType: "text/html; charset=utf-8", body: d.html };
+    if (path.startsWith("/_dashboard/")) {
+      return resolveStatic(d.distDir, path.slice("/_dashboard".length));
+    }
+    return null;
+  }
+  if (path === "/" || path === "/index.html") return { contentType: "text/html", body: d.html };
+  const embeddedPath = d.assets[path] ?? (path.startsWith("/_dashboard/") ? d.assets[path.slice("/_dashboard".length)] : void 0);
+  if (!embeddedPath) return null;
+  const bun = globalThis.Bun;
+  if (!bun) return null;
+  const body = new Uint8Array(await bun.file(embeddedPath).arrayBuffer());
+  return { contentType: EMBEDDED_CONTENT_TYPES[extname(embeddedPath)] ?? "application/octet-stream", body };
+}
+function resolveStatic(webDir, urlPath) {
+  const rel = urlPath === "/" ? "/index.html" : urlPath;
+  let root;
+  let resolved;
+  try {
+    root = realpathSync(resolve4(webDir));
+    resolved = realpathSync(resolve4(join6(webDir, rel)));
+  } catch {
+    return null;
+  }
+  if (resolved !== root && !resolved.startsWith(root + sep)) return null;
+  if (!statSync(resolved).isFile()) return null;
+  return { contentType: CONTENT_TYPES[extname(resolved)] ?? "application/octet-stream", body: readFileSync2(resolved) };
+}
+function readBodyBytes(req) {
+  return new Promise((resolvePromise, reject) => {
+    const chunks = [];
+    let total = 0;
+    req.on("data", (c) => {
+      total += c.length;
+      if (total > MAX_BODY_BYTES) {
+        req.destroy();
+        reject(new Error("request body too large"));
+        return;
+      }
+      chunks.push(c);
+    });
+    req.on("end", () => resolvePromise(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+function readBody(req) {
+  return readBodyBytes(req).then((b) => b.toString("utf8"));
+}
+async function startNodeServer(runtime, options) {
+  const { WebSocketServer } = await import("ws");
+  let currentRoutes = options.routes ?? [];
+  const server = createServer((req, res) => {
+    void (async () => {
+      try {
+        const rawUrl = req.url ?? "/";
+        const url = new URL(rawUrl, "http://x");
+        const path = url.pathname;
+        const needsBody = hasBody(req.method);
+        const isStorageRequest = path.startsWith(STORAGE_PREFIX);
+        const bodyBytes = needsBody && isStorageRequest ? await readBodyBytes(req) : void 0;
+        const body = needsBody && !isStorageRequest ? await readBody(req) : void 0;
+        const query = {};
+        url.searchParams.forEach((val, key) => {
+          query[key] = val;
+        });
+        const authorization = req.headers.authorization ?? void 0;
+        const headers = Object.fromEntries(
+          Object.entries(req.headers).filter((e) => typeof e[1] === "string")
+        );
+        if ((req.method ?? "GET") === "GET" && options.dashboard) {
+          const dash = await serveDashboard(path, options.dashboard);
+          if (dash) {
+            res.writeHead(200, { "content-type": dash.contentType });
+            res.end(dash.body);
+            return;
+          }
+        }
+        const storageRoute = matchStorageRoute(options.storageRoutes, req.method ?? "GET", path);
+        if (storageRoute) {
+          const storageHeaders = new Headers(headers);
+          if (authorization && !storageHeaders.has("authorization")) storageHeaders.set("authorization", authorization);
+          const request = new Request(`http://${storageHeaders.get("host") ?? "localhost"}${rawUrl}`, {
+            method: req.method ?? "GET",
+            headers: storageHeaders,
+            // Raw bytes, NOT the utf8-decoded `body` string — see `readBodyBytes`'s doc comment.
+            // (Copied into a plain `Uint8Array<ArrayBuffer>` — `Buffer`'s `.buffer` is typed
+            // `ArrayBufferLike`, which doesn't structurally satisfy DOM lib's `BodyInit`.)
+            ...needsBody && bodyBytes !== void 0 ? { body: new Uint8Array(bodyBytes) } : {}
+          });
+          const response2 = await storageRoute.handler(request);
+          const outHeaders = {};
+          response2.headers.forEach((v, k) => {
+            outHeaders[k] = v;
+          });
+          res.writeHead(response2.status, outHeaders);
+          res.end(Buffer.from(await response2.arrayBuffer()));
+          return;
+        }
+        const componentRoute = matchComponentRoute(options.componentRoutes, req.method ?? "GET", path);
+        if (componentRoute) {
+          const compHeaders = new Headers(headers);
+          if (authorization && !compHeaders.has("authorization")) compHeaders.set("authorization", authorization);
+          const request = new Request(`http://${compHeaders.get("host") ?? "localhost"}${rawUrl}`, {
+            method: req.method ?? "GET",
+            headers: compHeaders,
+            ...needsBody && !isStorageRequest && body !== void 0 ? { body } : {}
+          });
+          const response2 = await componentRoute.handler(request);
+          const outHeaders = {};
+          response2.headers.forEach((v, k) => {
+            outHeaders[k] = v;
+          });
+          res.writeHead(response2.status, outHeaders);
+          res.end(Buffer.from(await response2.arrayBuffer()));
+          return;
+        }
+        const info = { functions: runtime.functionPaths(), tables: runtime.tableNames() };
+        const response = await handleHttpRequest(
+          runtime,
+          { method: req.method ?? "GET", path, body, query, authorization, headers },
+          info,
+          options.admin,
+          currentRoutes,
+          options.deploy,
+          options.fleet,
+          options.replicaWriterUrl
+        );
+        if (response.status === 404 && (req.method ?? "GET") === "GET" && options.webDir) {
+          const file = resolveStatic(options.webDir, path);
+          if (file) {
+            res.writeHead(200, { "content-type": file.contentType });
+            res.end(file.body);
+            return;
+          }
+        }
+        res.writeHead(response.status, response.headers);
+        res.end(response.body);
+      } catch (e) {
+        res.writeHead(500, { "content-type": "application/json" });
+        res.end(JSON.stringify({ error: e instanceof Error ? e.message : String(e) }));
+      }
+    })();
+  });
+  const wss = new WebSocketServer({ noServer: true });
+  let sessionCounter = 0;
+  server.on("upgrade", (req, socket, head) => {
+    if ((req.url ?? "").split("?")[0] !== SYNC_PATH) {
+      socket.destroy();
+      return;
+    }
+    wss.handleUpgrade(req, socket, head, (ws) => {
+      const sessionId = `ws-${++sessionCounter}`;
+      const syncSocket = {
+        send: (data) => ws.send(data),
+        get bufferedAmount() {
+          return ws.bufferedAmount;
+        },
+        close: () => ws.close(),
+        ping: (onPong) => {
+          ws.once("pong", onPong);
+          ws.ping();
+        }
+      };
+      runtime.handler.connect(sessionId, syncSocket);
+      ws.on("message", (data) => void runtime.handler.handleMessage(sessionId, data.toString("utf8")));
+      ws.on("close", () => runtime.handler.disconnect(sessionId));
+      ws.on("error", () => runtime.handler.disconnect(sessionId));
+    });
+  });
+  await new Promise((res) => server.listen(options.port, options.ip, res));
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : options.port;
+  return {
+    url: `http://${options.ip}:${port}`,
+    port,
+    setRoutes: (r) => {
+      currentRoutes = r;
+    },
+    close: async () => {
+      await runtime.stopDrivers();
+      await new Promise((res) => {
+        for (const c of wss.clients) c.terminate();
+        wss.close();
+        server.close(() => res());
+      });
+    }
+  };
+}
+var bunPongCallbacks = /* @__PURE__ */ new Map();
+async function startBunServer(runtime, options) {
+  const bun = globalThis.Bun;
+  if (!bun) throw new Error("Bun runtime not available");
+  let sessionCounter = 0;
+  let currentRoutes = options.routes ?? [];
+  const handle = bun.serve({
+    port: options.port,
+    hostname: options.ip,
+    maxRequestBodySize: MAX_BODY_BYTES,
+    async fetch(req, server) {
+      const url = new URL(req.url);
+      const path = url.pathname;
+      if (path === SYNC_PATH) {
+        const sessionId = `ws-${++sessionCounter}`;
+        return server.upgrade(req, { data: { sessionId } }) ? void 0 : new Response("upgrade failed", { status: 400 });
+      }
+      if (req.method === "GET" && options.dashboard) {
+        const dash = await serveDashboard(path, options.dashboard);
+        if (dash) {
+          const body2 = typeof dash.body === "string" ? dash.body : new Uint8Array(dash.body);
+          return new Response(body2, { headers: { "content-type": dash.contentType } });
+        }
+      }
+      const storageRoute = matchStorageRoute(options.storageRoutes, req.method, path);
+      if (storageRoute) return await storageRoute.handler(req);
+      const componentRoute = matchComponentRoute(options.componentRoutes, req.method, path);
+      if (componentRoute) return await componentRoute.handler(req);
+      const body = hasBody(req.method) ? await req.text() : void 0;
+      const query = {};
+      url.searchParams.forEach((val, key) => {
+        query[key] = val;
+      });
+      const authorization = req.headers.get("authorization") ?? void 0;
+      const headers = {};
+      req.headers.forEach((v, k) => {
+        headers[k] = v;
+      });
+      const info = { functions: runtime.functionPaths(), tables: runtime.tableNames() };
+      const response = await handleHttpRequest(
+        runtime,
+        { method: req.method, path, body, query, authorization, headers },
+        info,
+        options.admin,
+        currentRoutes,
+        options.deploy,
+        options.fleet,
+        options.replicaWriterUrl
+      );
+      if (response.status === 404 && req.method === "GET" && options.webDir) {
+        const file = resolveStatic(options.webDir, path);
+        if (file) return new Response(new Uint8Array(file.body), { headers: { "content-type": file.contentType } });
+      }
+      return new Response(response.body, { status: response.status, headers: response.headers });
+    },
+    websocket: {
+      open(ws) {
+        const syncSocket = {
+          send: (data) => void ws.send(data),
+          get bufferedAmount() {
+            return ws.getBufferedAmount();
+          },
+          close: () => ws.close(),
+          ping: (onPong) => {
+            bunPongCallbacks.set(ws.data.sessionId, onPong);
+            ws.ping();
+          }
+        };
+        runtime.handler.connect(ws.data.sessionId, syncSocket);
+      },
+      message(ws, message) {
+        void runtime.handler.handleMessage(ws.data.sessionId, typeof message === "string" ? message : new TextDecoder().decode(message));
+      },
+      close(ws) {
+        bunPongCallbacks.delete(ws.data.sessionId);
+        runtime.handler.disconnect(ws.data.sessionId);
+      },
+      pong(ws) {
+        const cb = bunPongCallbacks.get(ws.data.sessionId);
+        bunPongCallbacks.delete(ws.data.sessionId);
+        cb?.();
+      }
+    }
+  });
+  return {
+    url: `http://${options.ip}:${handle.port}`,
+    port: handle.port,
+    setRoutes: (r) => {
+      currentRoutes = r;
+    },
+    close: async () => {
+      await runtime.stopDrivers();
+      handle.stop(true);
+    }
+  };
+}
+function startDevServer(runtime, options) {
+  return detectRuntime() === "bun" ? startBunServer(runtime, options) : startNodeServer(runtime, options);
+}
+var ProcessRuntimeHost = class {
+  serve(runtime, options) {
+    return startDevServer(runtime, options);
+  }
+};
+
+// src/watch.ts
+function createWatchLoop(options) {
+  const debounceMs = options.debounceMs ?? 50;
+  const setTimer = options.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+  const clearTimer = options.clearTimer ?? ((h) => clearTimeout(h));
+  let timer = null;
+  let unsubscribe = null;
+  const fire = () => {
+    timer = null;
+    void options.onTrigger("change");
+  };
+  return {
+    start() {
+      void options.onTrigger("initial");
+      unsubscribe = options.subscribe(() => {
+        if (timer !== null) clearTimer(timer);
+        timer = setTimer(fire, debounceMs);
+      });
+    },
+    stop() {
+      if (timer !== null) clearTimer(timer);
+      unsubscribe?.();
+      unsubscribe = null;
+    }
+  };
+}
+
+// src/cli.ts
+import { watch as fsWatch } from "fs";
+import { dirname as dirname9, join as join13, resolve as resolve8 } from "path";
+import { writeGenerated as writeGenerated4 } from "@helipod/codegen";
+import { generateAdminKey } from "@helipod/admin";
+
+// src/serve.ts
+import { existsSync as existsSync4 } from "fs";
+import { dirname as dirname5, join as join8, resolve as resolve5 } from "path";
+import { PostgresDocStore as PostgresDocStore2 } from "@helipod/docstore-postgres";
+
+// src/deploy-apply.ts
+import { createHash as createHash2 } from "crypto";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname4, isAbsolute as isAbsolute2, join as join7 } from "path";
+import { sha256Hex } from "@helipod/deploy";
+
+// src/schema-diff.ts
+function fieldsOf(s, table) {
+  return s.schemaJson.tables[table]?.documentType?.value ?? {};
+}
+function compatibleType(cur, next) {
+  return cur.type === next.type;
+}
+function diffSchema(current, next) {
+  for (const name of Object.keys(current.tableNumbers)) {
+    if (!(name in next.tableNumbers)) return { ok: false, reason: `table "${name}" was removed (destructive \u2014 rename/drop not supported)` };
+    if (current.tableNumbers[name] !== next.tableNumbers[name])
+      return { ok: false, reason: `table "${name}" tableNumber changed ${current.tableNumbers[name]}\u2192${next.tableNumbers[name]} (destructive)` };
+    const cur = fieldsOf(current, name);
+    const nxt = fieldsOf(next, name);
+    for (const [field, curV] of Object.entries(cur)) {
+      const nxtV = nxt[field];
+      if (nxtV === void 0) return { ok: false, reason: `field "${name}.${field}" was removed (destructive)` };
+      if (!compatibleType(curV.fieldType, nxtV.fieldType))
+        return { ok: false, reason: `field "${name}.${field}" changed type ${curV.fieldType.type}\u2192${nxtV.fieldType.type} (destructive)` };
+      if (curV.optional && !nxtV.optional)
+        return { ok: false, reason: `field "${name}.${field}" became required (destructive \u2014 existing rows may omit it)` };
+    }
+    for (const [field, nxtV] of Object.entries(nxt)) {
+      if (cur[field] === void 0 && !nxtV.optional)
+        return { ok: false, reason: `field "${name}.${field}" is a new required field on an existing table (destructive \u2014 existing rows lack it; make it optional)` };
+    }
+  }
+  return { ok: true };
+}
+
+// src/deploy-apply.ts
+function reconstructFiles(payload, currentModules) {
+  if ("changed" in payload) {
+    const files = [...payload.changed ?? []];
+    for (const u of payload.unchanged ?? []) {
+      const cur = currentModules.get(u.path);
+      if (!cur) return { ok: false, error: `stale-base: server has no module "${u.path}"` };
+      if (cur.sha !== u.sha256) return { ok: false, error: `stale-base: module "${u.path}" hash mismatch` };
+      files.push({ path: u.path, code: cur.code });
+    }
+    return { ok: true, files };
+  }
+  return { ok: true, files: payload.files ?? [] };
+}
+async function applyDeploy(deps, payload) {
+  const rec = reconstructFiles(payload, deps.currentModules);
+  if (!rec.ok) return { ok: false, kind: "stale-base", error: rec.error };
+  const files = rec.files;
+  const rev = createHash2("sha256").update(JSON.stringify(files)).digest("hex").slice(0, 12);
+  const dir = join7(deps.deployRoot, rev, "functions");
+  let project;
+  try {
+    for (const f of files) {
+      if (typeof f.path !== "string" || typeof f.code !== "string") {
+        throw new Error(`invalid deploy payload: file entry must have a string "path" and "code"`);
+      }
+      if (isAbsolute2(f.path) || f.path.split("/").includes("..")) {
+        throw new Error(`invalid deploy payload: unsafe path "${f.path}"`);
+      }
+      const abs = join7(dir, f.path);
+      mkdirSync3(dirname4(abs), { recursive: true });
+      writeFileSync2(abs, f.code);
+    }
+    const loaded = await loadFunctionsDir(dir);
+    project = push(loaded, deps.components, deps.current().tableNumbers).project;
+  } catch (e) {
+    return { ok: false, kind: "load-error", error: e instanceof Error ? e.message : String(e) };
+  }
+  const diff = diffSchema(deps.current(), {
+    schemaJson: project.schemaJson,
+    tableNumbers: project.tableNumbers
+  });
+  if (!diff.ok) return { ok: false, kind: "schema-incompatible", error: diff.reason };
+  deps.runtime.setModules(withStorageModules(project.moduleMap));
+  deps.runtime.setTableNumbers(project.tableNumbers);
+  deps.setRoutes(project.routes);
+  deps.adminApi.setSchema(project.schemaJson, project.tableNumbers, project.manifest);
+  const modules = new Map(files.map((f) => [f.path, { code: f.code, sha: sha256Hex(f.code) }]));
+  return { ok: true, rev, functions: Object.keys(project.moduleMap).length, modules };
+}
+
+// src/wake-host.ts
+function httpWakeHost(url) {
+  return {
+    armWake(atMs) {
+      void fetch(url, { method: "POST", body: atMs === null ? "" : String(atMs) }).then((res) => {
+        if (!res.ok) console.error(`[wake] arm at ${atMs} rejected by ${url}: ${res.status}`);
+      }).catch((e) => {
+        console.error(`[wake] arm at ${atMs} failed to reach ${url}:`, e);
+      });
+    }
+  };
+}
+
+// src/serve.ts
+function raceWithTimeout(promise, ms) {
+  return new Promise((resolveOuter) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        resolveOuter();
+      }
+    }, ms);
+    promise.then(
+      () => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          resolveOuter();
+        }
+      },
+      () => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          resolveOuter();
+        }
+      }
+    );
+  });
+}
+var OBJECTSTORE_RELINQUISH_TIMEOUT_MS = 2e3;
+var FLEET_ERR_NO_DB = "fleet mode requires --database-url (Postgres) \u2014 set --database-url postgres://\u2026 or HELIPOD_DATABASE_URL.";
+var FLEET_ERR_NO_ADVERTISE = "fleet mode requires --advertise-url (or HELIPOD_ADVERTISE_URL) \u2014 the URL other fleet nodes reach this node at, e.g. --advertise-url http://10.0.0.2:3000";
+var FLEET_ERR_NO_PACKAGE = "fleet mode requires @helipod/fleet \u2014 install it (bun add @helipod/fleet).";
+function validateFleetOptions(opts) {
+  if (!isPostgresUrl(opts.databaseUrl)) return { ok: false, error: FLEET_ERR_NO_DB };
+  const advertiseUrl = opts.advertiseUrl?.trim();
+  if (!advertiseUrl) return { ok: false, error: FLEET_ERR_NO_ADVERTISE };
+  return { ok: true, databaseUrl: opts.databaseUrl, advertiseUrl };
+}
+function parseLeaseTtlMs(raw) {
+  if (raw === void 0 || raw.trim() === "") return void 0;
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+async function resolveFleetNumShards(databaseUrl, envValue) {
+  const client = makePgClient(databaseUrl);
+  try {
+    const probe = new PostgresDocStore2(client, { readOnly: true });
+    await probe.setupSchema();
+    return await resolveNumShards(probe, envValue);
+  } finally {
+    await client.close();
+  }
+}
+function resolveServeOptions(args) {
+  let functionsDir = "";
+  let dataPath = process.env.HELIPOD_DATA_DIR ? join8(process.env.HELIPOD_DATA_DIR, "db.sqlite") : "./data/db.sqlite";
+  let ip = "0.0.0.0";
+  let port = process.env.PORT ? Number(process.env.PORT) : 3e3;
+  let dashboard = process.env.HELIPOD_DASHBOARD?.trim().toLowerCase() !== "off";
+  let allowDeploy = process.env.HELIPOD_ALLOW_DEPLOY === "1";
+  let webDir = process.env.HELIPOD_WEB_DIR;
+  let databaseUrl = process.env.HELIPOD_DATABASE_URL;
+  let storageBucket;
+  let storageEndpoint;
+  let fleet = process.env.HELIPOD_FLEET === "1" || process.env.HELIPOD_FLEET?.trim().toLowerCase() === "true";
+  let advertiseUrl = process.env.HELIPOD_ADVERTISE_URL;
+  let objectStoreUrl = process.env.HELIPOD_OBJECT_STORE;
+  let replica = /^(1|true|yes)$/i.test(process.env.HELIPOD_REPLICA ?? "");
+  let writerUrl = process.env.HELIPOD_WRITER_URL;
+  let wakeUrl = process.env.HELIPOD_WAKE_URL;
+  let backstopMinMs = parseLeaseTtlMs(process.env.HELIPOD_BACKSTOP_MIN_MS);
+  let objectStoreShards;
+  const objectStoreGcMs = parseLeaseTtlMs(process.env.HELIPOD_OBJECTSTORE_GC_MS);
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--dir" && args[i + 1]) functionsDir = args[++i];
+    else if (a === "--data" && args[i + 1]) dataPath = args[++i];
+    else if (a === "--ip" && args[i + 1]) ip = args[++i];
+    else if (a === "--port" && args[i + 1]) port = Number(args[++i]);
+    else if (a === "--no-dashboard") dashboard = false;
+    else if (a === "--allow-deploy") allowDeploy = true;
+    else if (a === "--database-url" && args[i + 1]) databaseUrl = args[++i];
+    else if (a === "--storage-bucket" && args[i + 1]) storageBucket = args[++i];
+    else if (a === "--storage-endpoint" && args[i + 1]) storageEndpoint = args[++i];
+    else if (a === "--fleet") fleet = true;
+    else if (a === "--advertise-url" && args[i + 1]) advertiseUrl = args[++i];
+    else if (a === "--object-store" && args[i + 1]) objectStoreUrl = args[++i];
+    else if (a === "--replica") replica = true;
+    else if (a === "--writer-url" && args[i + 1]) writerUrl = args[++i];
+    else if (a === "--shards" && args[i + 1]) objectStoreShards = Number(args[++i]);
+    else if (a === "--wake-url" && args[i + 1]) wakeUrl = args[++i];
+    else if (a === "--backstop-min-ms" && args[i + 1]) backstopMinMs = parseLeaseTtlMs(args[++i]);
+    else if (a === "--web" && args[i + 1]) webDir = args[++i];
+  }
+  if (objectStoreShards === void 0 && objectStoreUrl !== void 0) {
+    objectStoreShards = parseNumShards(process.env.HELIPOD_FLEET_SHARDS);
+  }
+  return {
+    functionsDir,
+    dataPath,
+    ip,
+    port,
+    dashboard,
+    ...webDir !== void 0 ? { webDir } : {},
+    allowDeploy,
+    databaseUrl,
+    storageBucket,
+    storageEndpoint,
+    fleet,
+    advertiseUrl,
+    ...objectStoreUrl !== void 0 ? { objectStoreUrl } : {},
+    ...objectStoreGcMs !== void 0 ? { objectStoreGcMs } : {},
+    ...objectStoreShards !== void 0 ? { objectStoreShards } : {},
+    replica,
+    ...writerUrl !== void 0 ? { writerUrl } : {},
+    ...wakeUrl !== void 0 ? { wakeUrl } : {},
+    ...backstopMinMs !== void 0 ? { backstopMinMs } : {}
+  };
+}
+function toDeploySchema(schemaJson) {
+  const tables = {};
+  for (const [name, t] of Object.entries(schemaJson.tables)) {
+    const dt = t.documentType;
+    tables[name] = { documentType: dt && dt.type === "object" ? dt : { type: "object", value: {} } };
+  }
+  return { tables };
+}
+async function startServe(opts) {
+  const backstopFloorMs = opts.backstopMinMs;
+  const prep = opts.fleet && opts.fleetModule && opts.fleetConfig ? await opts.fleetModule.prepareFleetNode({
+    ...opts.fleetConfig,
+    adminKey: opts.adminKey,
+    // A sync node's local replica lives beside the data file (same dir the SQLite store uses).
+    dataDir: dirname5(resolve5(opts.dataPath))
+  }) : void 0;
+  const { runtime, adminApi, project, store, components, storageRoutes: storageRoutes2, componentRoutes, objectStoreRelease, replicaWriterUrl } = await bootProject({
+    functionsDir: opts.functionsDir,
+    dataPath: opts.dataPath,
+    adminKey: opts.adminKey,
+    databaseUrl: opts.databaseUrl,
+    storage: { bucket: opts.storageBucket, endpoint: opts.storageEndpoint },
+    ...opts.storageUploadTtlMs !== void 0 ? { storageUploadTtlMs: opts.storageUploadTtlMs } : {},
+    ...opts.storageReaperSweepMs !== void 0 ? { storageReaperSweepMs: opts.storageReaperSweepMs } : {},
+    ...prep ? { fleet: prep.runtimeOptions } : {},
+    ...opts.objectStoreUrl !== void 0 ? { objectStoreUrl: opts.objectStoreUrl } : {},
+    ...opts.onObjectStoreFenced ? { objectStoreOnFenced: opts.onObjectStoreFenced } : {},
+    ...opts.objectStoreGcMs !== void 0 ? { objectStoreGcMs: opts.objectStoreGcMs } : {},
+    ...opts.replica ? { replica: opts.replica } : {},
+    ...opts.writerUrl !== void 0 ? { writerUrl: opts.writerUrl } : {},
+    ...opts.objectStoreShards !== void 0 ? { objectStoreShards: opts.objectStoreShards } : {},
+    // The wake seam (`--wake-url`/`--backstop-min-ms`): a host that stops the process between
+    // requests. Both unset (every existing deployment) → no keys, plain `setTimeout` + the drivers'
+    // own 30s/60s backstops.
+    ...opts.wakeUrl !== void 0 ? { wakeHost: httpWakeHost(opts.wakeUrl) } : {},
+    ...backstopFloorMs !== void 0 ? { backstopMs: (d) => Math.max(d, backstopFloorMs) } : {}
+  });
+  const dashboard = opts.dashboard ? loadDashboard(void 0) : void 0;
+  const fleet = prep && opts.fleetModule ? await opts.fleetModule.startFleetNode({
+    client: prep.client,
+    pgStore: prep.pgStore,
+    runtime,
+    lease: prep.lease,
+    forwarder: prep.forwarder,
+    replica: prep.replica,
+    switchable: prep.switchable,
+    replicaPath: prep.replicaPath,
+    numShards: prep.numShards
+  }) : void 0;
+  let server;
+  let currentPushedModules = /* @__PURE__ */ new Map();
+  const deploy = opts.allowDeploy ? {
+    apply: async (payload) => {
+      const result = await applyDeploy(
+        {
+          runtime,
+          adminApi,
+          setRoutes: (r) => server.setRoutes(r),
+          components,
+          current: () => {
+            const live = adminApi.getSchema();
+            return { schemaJson: toDeploySchema(live.schemaJson), tableNumbers: live.tableNumbers };
+          },
+          deployRoot: join8(process.cwd(), ".helipod-deploy"),
+          currentModules: currentPushedModules
+        },
+        payload
+      );
+      if (!result.ok) return result;
+      currentPushedModules = result.modules;
+      return { ok: true, rev: result.rev, functions: result.functions };
+    },
+    modules: () => Object.fromEntries([...currentPushedModules].map(([p, v]) => [p, v.sha]))
+  } : void 0;
+  server = await new ProcessRuntimeHost().serve(
+    runtime,
+    {
+      port: opts.port,
+      ip: opts.ip,
+      ...opts.webDir !== void 0 ? { webDir: opts.webDir } : {},
+      admin: { api: adminApi, key: opts.adminKey },
+      dashboard,
+      routes: project.routes,
+      storageRoutes: storageRoutes2,
+      componentRoutes,
+      deploy,
+      fleet,
+      ...replicaWriterUrl !== void 0 ? { replicaWriterUrl } : {}
+    }
+  );
+  return { server, store, runtime, fleet, role: prep?.role, ...objectStoreRelease ? { objectStoreRelease } : {} };
+}
+async function serveCommand(args) {
+  const opts = resolveServeOptions(args);
+  const adminKey = process.env.HELIPOD_ADMIN_KEY?.trim();
+  if (!adminKey) {
+    process.stderr.write("\u2717 HELIPOD_ADMIN_KEY is required for `serve` \u2014 set it to a strong secret.\n");
+    return 1;
+  }
+  const { functionsDir } = await resolveFunctionsDir(opts.functionsDir || void 0, process.cwd());
+  if (!ensureFunctionsDirExists(functionsDir)) return 1;
+  opts.functionsDir = functionsDir;
+  if (!existsSync4(join8(opts.functionsDir, "_generated", "server.ts"))) {
+    process.stderr.write(
+      `\u2717 ${opts.functionsDir}/_generated not found \u2014 run \`helipod codegen --dir ${opts.functionsDir}\` and commit _generated/ before deploying.
+`
+    );
+    return 1;
+  }
+  if (opts.fleet && opts.objectStoreUrl !== void 0) {
+    process.stderr.write(
+      "\u2717 --object-store cannot be combined with --fleet (Tier 2) \u2014 pick one write-scaling story.\n"
+    );
+    return 1;
+  }
+  if (opts.replica && opts.objectStoreUrl === void 0) {
+    process.stderr.write(
+      "\u2717 --replica requires --object-store \u2014 a replica materializes from an object-storage bucket; set --object-store <url> (or HELIPOD_OBJECT_STORE).\n"
+    );
+    return 1;
+  }
+  if (opts.objectStoreShards !== void 0 && opts.objectStoreShards > 1) {
+    if (opts.objectStoreUrl === void 0) {
+      process.stderr.write(
+        "\u2717 --shards N (N>1) requires --object-store \u2014 it sizes the object-storage writer's lane count; set --object-store <url>, or drop --shards.\n"
+      );
+      return 1;
+    }
+    if (opts.replica) {
+      process.stderr.write(
+        "\u2717 --shards cannot be combined with --replica \u2014 a replica is single-shard (it tails shard 0); run the multi-shard WRITER with --shards and point replicas at it.\n"
+      );
+      return 1;
+    }
+    if (!Number.isInteger(opts.objectStoreShards)) {
+      process.stderr.write(`\u2717 --shards must be a positive integer, got "${opts.objectStoreShards}".
+`);
+      return 1;
+    }
+  }
+  if (opts.writerUrl !== void 0 && !opts.replica) {
+    process.stderr.write(
+      "\u2717 --writer-url only applies to --replica (it's the writer this replica forwards mutations/actions to) \u2014 pass --replica too, or drop --writer-url (or HELIPOD_WRITER_URL).\n"
+    );
+    return 1;
+  }
+  let fleetModule;
+  let fleetConfig;
+  if (opts.fleet) {
+    const v = validateFleetOptions(opts);
+    if (!v.ok) {
+      process.stderr.write(`\u2717 ${v.error}
+`);
+      return 1;
+    }
+    try {
+      const fleetSpecifier = "@helipod/fleet";
+      fleetModule = await import(fleetSpecifier);
+    } catch {
+      process.stderr.write(`\u2717 ${FLEET_ERR_NO_PACKAGE}
+`);
+      return 1;
+    }
+    let numShards;
+    try {
+      numShards = await resolveFleetNumShards(v.databaseUrl, parseNumShards(process.env.HELIPOD_FLEET_SHARDS));
+    } catch (e) {
+      process.stderr.write(`\u2717 ${e instanceof Error ? e.message : String(e)}
+`);
+      return 1;
+    }
+    fleetConfig = {
+      databaseUrl: v.databaseUrl,
+      advertiseUrl: v.advertiseUrl,
+      leaseTtlMs: parseLeaseTtlMs(process.env.HELIPOD_FLEET_LEASE_TTL_MS),
+      numShards
+    };
+  }
+  let triggerObjectStoreFencedShutdown;
+  let booted;
+  try {
+    booted = await startServe({
+      ...opts,
+      adminKey,
+      fleetModule,
+      fleetConfig,
+      onObjectStoreFenced: (e) => {
+        process.stderr.write(`\u2717 object-store lease lost \u2014 shutting down: ${e.message}
+`);
+        triggerObjectStoreFencedShutdown?.();
+      }
+    });
+  } catch (e) {
+    if (isObjectStoreBootFailFast(e)) {
+      process.stderr.write(`\u2717 ${e.message}
+`);
+      return 1;
+    }
+    throw e;
+  }
+  const { server, store, role, fleet, objectStoreRelease } = booted;
+  process.stdout.write(
+    JSON.stringify({
+      level: "info",
+      msg: "helipod serve",
+      url: server.url,
+      dir: opts.functionsDir,
+      data: opts.dataPath,
+      dashboard: opts.dashboard,
+      allowDeploy: opts.allowDeploy,
+      // Additive: present only in fleet mode. Task 7's 2-process E2E asserts each node's role here.
+      ...role ? { fleet: true, role } : {},
+      // Additive: present only in object-store mode (Tier 3 Slice 6).
+      ...opts.objectStoreUrl !== void 0 ? { objectStore: true } : {},
+      // Additive: present only for a read-only replica node (Tier 3 Slice 8, Task 8.2).
+      ...opts.replica ? { replica: true } : {},
+      // Additive: present only when this replica forwards writes (Tier 3 Slice 8 follow-on).
+      ...opts.writerUrl !== void 0 ? { writerUrl: opts.writerUrl } : {}
+    }) + "\n"
+  );
+  let closing = false;
+  const shutdown = async () => {
+    if (closing) return;
+    closing = true;
+    process.stdout.write(JSON.stringify({ level: "info", msg: "shutting down" }) + "\n");
+    if (fleet) await fleet.stop();
+    await server.close();
+    if (objectStoreRelease) await raceWithTimeout(objectStoreRelease(), OBJECTSTORE_RELINQUISH_TIMEOUT_MS);
+    await store.close();
+    process.exit(0);
+  };
+  triggerObjectStoreFencedShutdown = () => void shutdown();
+  process.on("SIGTERM", () => void shutdown());
+  process.on("SIGINT", () => void shutdown());
+  return new Promise(() => {
+  });
+}
+
+// src/deploy.ts
+import { readdirSync as readdirSync2, statSync as statSync2, readFileSync as readFileSync3, mkdtempSync, rmSync, existsSync as existsSync5 } from "fs";
+import { join as join9, relative, sep as sep2 } from "path";
+import { tmpdir } from "os";
+import { transform } from "esbuild";
+import { writeGenerated } from "@helipod/codegen";
+import { resolveDeploy, loadTarget, NodeSpawner, DeployError } from "@helipod/deploy";
+function walkTs(root, dir, out) {
+  for (const entry of readdirSync2(dir)) {
+    const abs = join9(dir, entry);
+    if (statSync2(abs).isDirectory()) walkTs(root, abs, out);
+    else if (entry.endsWith(".ts") && !entry.endsWith(".d.ts")) out.push(abs);
+  }
+}
+async function packageApp(functionsDir) {
+  const absFiles = [];
+  walkTs(functionsDir, functionsDir, absFiles);
+  const out = [];
+  for (const abs of absFiles) {
+    const source = readFileSync3(abs, "utf8");
+    const { code } = await transform(source, { loader: "ts", format: "esm", target: "esnext" });
+    const rel = relative(functionsDir, abs).split(sep2).join("/").replace(/\.ts$/, ".js");
+    out.push({ path: rel, code });
+  }
+  return out.sort((a, b) => a.path.localeCompare(b.path));
+}
+function parseDeployFlags(args) {
+  let target;
+  let env;
+  let url = process.env.HELIPOD_DEPLOY_URL?.trim() || void 0;
+  let dirFlag;
+  let dryRun = false;
+  let check = false;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--target" && args[i + 1]) target = args[++i];
+    else if (args[i] === "--env" && args[i + 1]) env = args[++i];
+    else if (args[i] === "--url" && args[i + 1]) url = args[++i];
+    else if (args[i] === "--dir" && args[i + 1]) dirFlag = args[++i];
+    else if (args[i] === "--dry-run") dryRun = true;
+    else if (args[i] === "--check") check = true;
+  }
+  return { target, env, url, dirFlag, dryRun, check };
+}
+async function checkDrift(functionsDir, components) {
+  const tmp = mkdtempSync(join9(tmpdir(), "sb-codegen-"));
+  try {
+    const { generated } = push(await loadFunctionsDir(functionsDir), components);
+    writeGenerated(generated.files, tmp);
+    const genDir = join9(functionsDir, "_generated");
+    return !dirsEqual(tmp, genDir);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
+function dirsEqual(a, b) {
+  const walk2 = (root) => {
+    const out = /* @__PURE__ */ new Map();
+    const rec = (dir, rel) => {
+      if (!existsSync5(dir)) return;
+      for (const e of readdirSync2(dir)) {
+        const abs = join9(dir, e);
+        const r = rel ? `${rel}/${e}` : e;
+        if (statSync2(abs).isDirectory()) rec(abs, r);
+        else out.set(r, readFileSync3(abs, "utf8"));
+      }
+    };
+    rec(root, "");
+    return out;
+  };
+  const ma = walk2(a);
+  const mb = walk2(b);
+  if (ma.size !== mb.size) return false;
+  for (const [k, v] of ma) if (mb.get(k) !== v) return false;
+  return true;
+}
+async function deployCommand(args, deps = {}) {
+  const flags = parseDeployFlags(args);
+  const cwd = deps.cwd ?? process.cwd();
+  const { functionsDir } = await resolveFunctionsDir(flags.dirFlag, cwd);
+  if (!ensureFunctionsDirExists(functionsDir)) return 1;
+  const config = await loadConfig(cwd);
+  if (flags.check) {
+    const drift = await checkDrift(functionsDir, config.components);
+    if (drift) {
+      process.stderr.write(`\u2717 ${functionsDir}/_generated is out of date \u2014 run \`helipod codegen\` and commit the result
+`);
+      return 1;
+    }
+    process.stdout.write(`\u2713 ${functionsDir}/_generated is up to date
+`);
+    if (!flags.dryRun) return 0;
+  }
+  const resolved = resolveDeploy({ deploy: config.deploy, target: flags.target, env: flags.env, inlineUrl: flags.url });
+  if ("error" in resolved) {
+    process.stderr.write(`\u2717 ${resolved.error}
+`);
+    return 1;
+  }
+  let target;
+  try {
+    target = await loadTarget(resolved.provider);
+  } catch (e) {
+    process.stderr.write(`\u2717 ${e instanceof Error ? e.message : String(e)}
+`);
+    return 1;
+  }
+  const interactive = deps.interactive ?? (Boolean(process.stdin.isTTY) && !process.env.CI);
+  const ctx = {
+    cwd,
+    functionsDir,
+    env: resolved.env,
+    target: resolved,
+    interactive,
+    spawn: deps.spawn ?? new NodeSpawner(),
+    log: (m) => process.stdout.write(`  ${m}
+`),
+    packageApp: async () => ({ files: await packageApp(functionsDir) }),
+    codegen: async () => {
+      const { generated } = push(await loadFunctionsDir(functionsDir), config.components);
+      writeGenerated(generated.files, join9(functionsDir, "_generated"));
+    }
+  };
+  try {
+    await target.preflight(ctx);
+    await target.package(ctx);
+    if (flags.dryRun) {
+      process.stdout.write(`\u2713 dry-run OK (${resolved.provider} / ${resolved.env}) \u2014 push skipped
+`);
+      return 0;
+    }
+    const result = await target.push(ctx);
+    if (!result.ok) {
+      process.stderr.write(`\u2717 deploy failed: ${result.error}
+`);
+      return 1;
+    }
+    process.stdout.write(`\u2713 deployed via ${resolved.provider} (${resolved.env})${result.detail ? ` \u2014 ${result.detail}` : ""}
+`);
+    if (result.url) process.stdout.write(`  ${result.url}
+`);
+    return 0;
+  } catch (e) {
+    if (e instanceof DeployError) {
+      process.stderr.write(`\u2717 ${e.message}
+`);
+      return 1;
+    }
+    throw e;
+  }
+}
+
+// src/build.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readdirSync as readdirSync3, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync3 } from "fs";
+import { spawnSync } from "child_process";
+import { createRequire as createRequire2 } from "module";
+import { dirname as dirname6, join as join10, resolve as resolve6 } from "path";
+import { writeGenerated as writeGenerated2 } from "@helipod/codegen";
+
+// src/build-entry.ts
+function generateEntrySource(inp) {
+  const L = ["// AUTO-GENERATED by `helipod build` \u2014 do not edit."];
+  inp.moduleImports.forEach((m, i) => L.push(`import * as m${i} from ${JSON.stringify(m.absPath)};`));
+  L.push(`import schema from ${JSON.stringify(inp.schemaAbsPath)};`);
+  if (inp.configAbsPath) L.push(`import * as __config from ${JSON.stringify(inp.configAbsPath)};`);
+  (inp.dashboardFiles ?? []).forEach((d, i) => L.push(`import d${i} from ${JSON.stringify(d.absPath)} with { type: "file" };`));
+  L.push(`import { runBinaryServer } from "@helipod/cli";`);
+  L.push("");
+  const modEntries = inp.moduleImports.map((m, i) => `${JSON.stringify(m.key)}: m${i}`).join(", ");
+  L.push(`const loaded = { schema, modules: { ${modEntries} } };`);
+  L.push(inp.configAbsPath ? `const components = (__config.default ?? __config).components ?? [];` : `const components = [];`);
+  if (inp.dashboardFiles) {
+    const dEntries = inp.dashboardFiles.map((d, i) => `${JSON.stringify(d.urlPath)}: d${i}`).join(", ");
+    L.push(`const dashboard = { ${dEntries} };`);
+    L.push(`await runBinaryServer(loaded, components, dashboard);`);
+  } else {
+    L.push(`await runBinaryServer(loaded, components, undefined);`);
+  }
+  return L.join("\n") + "\n";
+}
+
+// src/build.ts
+async function resolveBuildOptions(args) {
+  let dirFlag, outfile = "./helipod-server", target = null, dashboard = true, verbose = false;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--dir" && args[i + 1]) dirFlag = args[++i];
+    else if (a === "--outfile" && args[i + 1]) outfile = args[++i];
+    else if (a === "--target" && args[i + 1]) target = args[++i];
+    else if (a === "--no-dashboard") dashboard = false;
+    else if (a === "--verbose") verbose = true;
+  }
+  const { functionsDir } = await resolveFunctionsDir(dirFlag, process.cwd());
+  return { functionsDir, outfile, target, dashboard, verbose };
+}
+var TARGETS = {
+  "linux-x64": "bun-linux-x64",
+  "linux-arm64": "bun-linux-arm64",
+  "darwin-x64": "bun-darwin-x64",
+  "darwin-arm64": "bun-darwin-arm64",
+  "windows-x64": "bun-windows-x64"
+};
+function bunTargetFor(friendly) {
+  const t = TARGETS[friendly];
+  if (!t) throw new Error(`unknown target "${friendly}" (expected one of: ${Object.keys(TARGETS).join(", ")})`);
+  return t;
+}
+function dashboardFiles() {
+  try {
+    const indexPath = createRequire2(import.meta.url).resolve("@helipod/dashboard/dist");
+    const dist = dirname6(indexPath);
+    const out = [];
+    const walk2 = (rel) => {
+      for (const e of readdirSync3(join10(dist, rel), { withFileTypes: true })) {
+        const r = rel ? `${rel}/${e.name}` : e.name;
+        if (e.isDirectory()) walk2(r);
+        else out.push({ urlPath: r === "index.html" ? "/" : `/${r}`, absPath: join10(dist, r) });
+      }
+    };
+    walk2("");
+    return out;
+  } catch {
+    return null;
+  }
+}
+async function buildCommand(args) {
+  const opts = await resolveBuildOptions(args);
+  const functionsDirAbs = opts.functionsDir;
+  if (!ensureFunctionsDirExists(functionsDirAbs)) return 1;
+  const loaded = await loadFunctionsDir(functionsDirAbs);
+  const config = await loadConfig(dirname6(functionsDirAbs));
+  const { generated } = push(loaded, config.components);
+  writeGenerated2(generated.files, join10(functionsDirAbs, "_generated"));
+  const moduleImports = listFunctionModuleFiles(functionsDirAbs).map((f) => ({ key: moduleKeyForFile(f), absPath: join10(functionsDirAbs, f) }));
+  const schemaAbsPath = join10(functionsDirAbs, existsSync6(join10(functionsDirAbs, "schema.ts")) ? "schema.ts" : "schema.js");
+  const cfgTs = join10(dirname6(functionsDirAbs), "helipod.config.ts"), cfgJs = join10(dirname6(functionsDirAbs), "helipod.config.js");
+  const configAbsPath = existsSync6(cfgTs) ? cfgTs : existsSync6(cfgJs) ? cfgJs : null;
+  const entrySrc = generateEntrySource({ moduleImports, schemaAbsPath, configAbsPath, dashboardFiles: opts.dashboard ? dashboardFiles() : null });
+  const buildDir = resolve6(".helipod-build");
+  mkdirSync4(buildDir, { recursive: true });
+  const entryPath = join10(buildDir, "entry.ts");
+  writeFileSync3(entryPath, entrySrc);
+  const bunArgs = ["build", "--compile", "--minify"];
+  if (opts.target) bunArgs.push(`--target=${bunTargetFor(opts.target)}`);
+  const outfile = opts.target === "windows-x64" && !opts.outfile.endsWith(".exe") ? `${opts.outfile}.exe` : opts.outfile;
+  bunArgs.push(`--outfile=${resolve6(outfile)}`, entryPath);
+  const proc = spawnSync("bun", bunArgs, { stdio: opts.verbose ? "inherit" : ["ignore", "ignore", "inherit"] });
+  rmSync2(buildDir, { recursive: true, force: true });
+  if (proc.error) {
+    process.stderr.write(`\u2717 could not run 'bun build --compile' \u2014 is Bun installed and on PATH? (${proc.error.message})
+`);
+    return 1;
+  }
+  if (proc.status !== 0) {
+    process.stderr.write("\u2717 bun build --compile failed\n");
+    return 1;
+  }
+  const size = (statSync3(resolve6(outfile)).size / (1024 * 1024)).toFixed(0);
+  process.stdout.write(`\u2713 built ${outfile} (${size}MB)
+`);
+  return 0;
+}
+
+// src/migrate.ts
+import { writeFileSync as writeFileSync5, existsSync as existsSync8, mkdirSync as mkdirSync5, rmSync as rmSync3, renameSync } from "fs";
+import { basename as basename2, dirname as dirname7, join as join12, resolve as resolve7 } from "path";
+import { spawnSync as spawnSync2 } from "child_process";
+import { writeGenerated as writeGenerated3, generateServer } from "@helipod/codegen";
+
+// src/migrate/source.ts
+function resolveSource(sources, id) {
+  const source = sources[id];
+  if (!source) {
+    throw new Error(`unknown migration source "${id}" (available: ${Object.keys(sources).join(", ")})`);
+  }
+  return source;
+}
+
+// src/migrate/convex-source.ts
+import { readFileSync as readFileSync4, readdirSync as readdirSync4, existsSync as existsSync7 } from "fs";
+import { join as join11, relative as relative2 } from "path";
+
+// src/migrate/rewrite-imports.ts
+var SIMPLE = {
+  "convex/values": "@helipod/values",
+  "convex/react": "@helipod/client/react",
+  "convex/browser": "@helipod/client"
+};
+var SCHEMA_SYMBOLS = /* @__PURE__ */ new Set(["defineSchema", "defineTable"]);
+var SERVER_SYMBOLS = /* @__PURE__ */ new Set(["httpRouter", "httpAction"]);
+var CRON_SYMBOLS = /* @__PURE__ */ new Set(["cronJobs"]);
+function lineOf(source, index) {
+  let line = 1;
+  for (let i = 0; i < index && i < source.length; i++) if (source[i] === "\n") line++;
+  return line;
+}
+function rewriteImports(source, file) {
+  const entries = [];
+  let output = source;
+  for (const [from, to] of Object.entries(SIMPLE)) {
+    const re = new RegExp(`(["'])${from.replace("/", "\\/")}\\1`, "g");
+    const input = output;
+    output = output.replace(re, (_m, q, offset) => {
+      entries.push({ severity: "auto-fixed", file, line: lineOf(input, offset), what: `import "${from}"`, fix: `rewritten to "${to}"` });
+      return `${q}${to}${q}`;
+    });
+  }
+  const serverRe = /import\s+(?:type\s+)?\{([^}]*)\}\s*from\s*(["'])convex\/server\2/g;
+  const serverInput = output;
+  output = output.replace(serverRe, (full, names, q, offset) => {
+    const line = lineOf(serverInput, offset);
+    const syms = names.split(",").map((s) => s.trim().split(/\s+as\s+/)[0].trim()).filter(Boolean);
+    const allSchema = syms.length > 0 && syms.every((s) => SCHEMA_SYMBOLS.has(s));
+    const allServer = syms.length > 0 && syms.every((s) => SERVER_SYMBOLS.has(s));
+    if (allSchema) {
+      entries.push({ severity: "auto-fixed", file, line, what: `import "convex/server" (schema)`, fix: `rewritten to "@helipod/values"` });
+      return full.replace(/["']convex\/server["']/, `${q}@helipod/values${q}`);
+    }
+    if (allServer) {
+      entries.push({ severity: "auto-fixed", file, line, what: `import "convex/server" (http)`, fix: `rewritten to "./_generated/server"` });
+      return full.replace(/["']convex\/server["']/, `${q}./_generated/server${q}`);
+    }
+    const hasCron = syms.some((s) => CRON_SYMBOLS.has(s));
+    const hasOther = syms.some((s) => !CRON_SYMBOLS.has(s));
+    const cronFix = `cronJobs \u2192 import from "@helipod/scheduler" and compose defineScheduler() in helipod.config.ts`;
+    const genericFix = `defineSchema/defineTable \u2192 "@helipod/values"; httpRouter/httpAction \u2192 "./_generated/server"`;
+    const fix = hasCron && hasOther ? `${cronFix}; other symbols: map manually: ${genericFix}` : hasCron ? cronFix : `map each symbol manually: ${genericFix}`;
+    entries.push({ severity: "action-needed", file, line, what: `import { ${syms.join(", ")} } from "convex/server"`, fix });
+    return full;
+  });
+  const handledRanges = [];
+  serverRe.lastIndex = 0;
+  let hm;
+  while ((hm = serverRe.exec(output)) !== null) {
+    handledRanges.push([hm.index, hm.index + hm[0].length]);
+  }
+  const residualRe = /(["'])convex\/server\1/g;
+  let m;
+  while ((m = residualRe.exec(output)) !== null) {
+    if (handledRanges.some(([start, end]) => m.index >= start && m.index < end)) continue;
+    entries.push({ severity: "action-needed", file, line: lineOf(output, m.index), what: `import "convex/server"`, fix: `map manually: defineSchema/defineTable \u2192 "@helipod/values"; httpRouter/httpAction \u2192 "./_generated/server"` });
+  }
+  return { output, entries };
+}
+
+// src/migrate/scan-divergences.ts
+import { basename } from "path";
+var RULES = [
+  {
+    test: /\.withIndex\s*\(/,
+    severity: "action-needed",
+    what: ".withIndex(...) query",
+    fix: `Helipod has no .withIndex \u2014 use ctx.db.query(table, "index").eq(f, v).gte(f, v).order("asc"|"desc").collect()`
+  },
+  {
+    test: /ctx\.db\.patch\s*\(/,
+    severity: "action-needed",
+    what: "ctx.db.patch(...)",
+    fix: `Helipod has no patch \u2014 read the doc, spread-merge, ctx.db.replace(id, { ...doc, ...changes })`
+  },
+  {
+    test: /\.paginate\s*\(/,
+    severity: "action-needed",
+    what: ".paginate(...)",
+    fix: `Helipod paginate({ cursor, pageSize, maxScan? }) returns { page, nextCursor, hasMore, scanCapped }`
+  },
+  {
+    test: /ctx\.auth\b|getUserIdentity\s*\(/,
+    severity: "action-needed",
+    what: "ctx.auth / getUserIdentity()",
+    fix: `Identity is a string token via a context provider (e.g. @helipod/auth's ctx.auth), not a JWT-claims object`
+  },
+  {
+    test: /@convex-dev\/auth|["']convex\/auth["']/,
+    severity: "unsupported",
+    what: "Convex Auth",
+    fix: `Auth is not auto-translated \u2014 use @helipod/auth or external JWT`
+  },
+  {
+    test: /\bapp\.use\s*\(/,
+    severity: "unsupported",
+    what: "Convex Component (app.use)",
+    fix: `Convex Components don't map 1:1 \u2014 recompose via helipod.config.ts`
+  },
+  {
+    test: /\.vectorIndex\s*\(|\.searchIndex\s*\(/,
+    severity: "unsupported",
+    what: "vector/search index",
+    fix: `search/vector is not yet supported in Helipod (see roadmap)`
+  }
+];
+function scanDivergences(source, file) {
+  const entries = [];
+  const lines = source.split("\n");
+  const base = basename(file);
+  if (base === "crons.ts" || /\bcronJobs\s*\(/.test(source)) {
+    const idx = lines.findIndex((l) => /\bcronJobs\s*\(/.test(l));
+    entries.push({
+      severity: "action-needed",
+      file,
+      line: idx >= 0 ? idx + 1 : 1,
+      what: "Convex crons (cronJobs)",
+      fix: `Compose defineScheduler() in helipod.config.ts and use cronJobs() from "@helipod/scheduler"`
+    });
+  }
+  if (base === "convex.config.ts") {
+    entries.push({
+      severity: "unsupported",
+      file,
+      line: 1,
+      what: "Convex app config (convex.config.ts)",
+      fix: `Recompose components via helipod.config.ts`
+    });
+  }
+  for (let i = 0; i < lines.length; i++) {
+    for (const rule of RULES) {
+      if (rule.test.test(lines[i])) {
+        entries.push({ severity: rule.severity, file, line: i + 1, what: rule.what, fix: rule.fix });
+      }
+    }
+  }
+  return entries;
+}
+
+// src/migrate/convex-source.ts
+function walk(dir) {
+  const out = [];
+  for (const ent of readdirSync4(dir, { withFileTypes: true })) {
+    if (ent.name === "_generated" || ent.name === "node_modules") continue;
+    const full = join11(dir, ent.name);
+    if (ent.isDirectory()) out.push(...walk(full));
+    else if (/\.tsx?$/.test(ent.name)) out.push(full);
+  }
+  return out;
+}
+var INTRODUCED_PKG = {
+  "@helipod/values": "@helipod/values",
+  "@helipod/client/react": "@helipod/client",
+  "@helipod/client": "@helipod/client"
+};
+var convexSource = {
+  id: "convex",
+  async detect(projectRoot) {
+    if (existsSync7(join11(projectRoot, "convex", "schema.ts"))) return true;
+    const pkgPath = join11(projectRoot, "package.json");
+    if (existsSync7(pkgPath)) {
+      const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
+      if (pkg.dependencies?.convex) return true;
+    }
+    return false;
+  },
+  async analyze(projectRoot, appDir) {
+    const edits = [];
+    const report = [];
+    const scaffold = [];
+    const introduced = /* @__PURE__ */ new Set();
+    let hasCrons = false;
+    for (const file of walk(appDir)) {
+      const src = readFileSync4(file, "utf8");
+      const rel = relative2(projectRoot, file);
+      const { output, entries } = rewriteImports(src, rel);
+      report.push(...entries, ...scanDivergences(src, rel));
+      for (const [spec, pkg] of Object.entries(INTRODUCED_PKG)) {
+        if (output.includes(`"${spec}"`) && !src.includes(`"${spec}"`)) introduced.add(pkg);
+      }
+      if (output !== src) edits.push({ path: file, newContent: output });
+      if (file.endsWith("crons.ts") || /\bcronJobs\s*\(/.test(src)) hasCrons = true;
+    }
+    const pkgPath = join11(projectRoot, "package.json");
+    if (existsSync7(pkgPath)) {
+      const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
+      const deps = { ...pkg.dependencies ?? {} };
+      for (const name of Object.keys(deps)) {
+        if (name === "convex" || name.startsWith("@convex-dev/")) delete deps[name];
+      }
+      for (const pkgName of introduced) deps[pkgName] = "latest";
+      const next = { ...pkg, dependencies: deps };
+      edits.push({ path: pkgPath, newContent: JSON.stringify(next, null, 2) + "\n" });
+    }
+    if (hasCrons) {
+      scaffold.push({
+        path: join11(projectRoot, "helipod.config.ts"),
+        content: `import { defineConfig } from "@helipod/component";
+import { defineScheduler } from "@helipod/scheduler";
+
+// Convex crons map to Helipod's scheduler component. Move your cron definitions into
+// a helipod/crons.ts using cronJobs() from "@helipod/scheduler".
+export default defineConfig({ components: [defineScheduler()] });
+`
+      });
+    }
+    return { edits, scaffold, report };
+  }
+};
+
+// src/migrate/data.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+function resolveOptions(args, env, fileFlag) {
+  let url = "";
+  let file = "";
+  let adminKey = env.HELIPOD_ADMIN_KEY?.trim() ?? "";
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--url" && args[i + 1]) url = args[++i];
+    else if (a === fileFlag && args[i + 1]) file = args[++i];
+    else if (a === "--admin-key" && args[i + 1]) adminKey = args[++i];
+  }
+  if (!url) return { error: "missing target URL \u2014 pass --url <url>" };
+  if (!file) return { error: `missing ${fileFlag} <file>` };
+  if (!adminKey) return { error: "HELIPOD_ADMIN_KEY is required (or pass --admin-key)" };
+  return { url, file, adminKey };
+}
+async function migrateExportCommand(args) {
+  const opts = resolveOptions(args, process.env, "--out");
+  if ("error" in opts) {
+    process.stderr.write(`\u2717 ${opts.error}
+`);
+    return 1;
+  }
+  let res;
+  try {
+    res = await fetch(`${opts.url.replace(/\/$/, "")}/_admin/export`, {
+      method: "GET",
+      headers: { authorization: `Bearer ${opts.adminKey}` }
+    });
+  } catch (e) {
+    process.stderr.write(`\u2717 could not reach ${opts.url}: ${e instanceof Error ? e.message : String(e)}
+`);
+    return 1;
+  }
+  if (res.status === 401) {
+    process.stderr.write("\u2717 unauthorized \u2014 check HELIPOD_ADMIN_KEY / --admin-key\n");
+    return 1;
+  }
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    process.stderr.write(`\u2717 export failed: ${body.error ?? res.statusText}
+`);
+    return 1;
+  }
+  const dumpText = await res.text();
+  writeFileSync4(opts.file, dumpText);
+  const dump = JSON.parse(dumpText);
+  process.stdout.write(
+    `\u2713 exported ${dump.documents?.length ?? 0} documents, ${dump.indexUpdates?.length ?? 0} index rows \u2192 ${opts.file}
+`
+  );
+  return 0;
+}
+async function migrateImportCommand(args) {
+  const opts = resolveOptions(args, process.env, "--in");
+  if ("error" in opts) {
+    process.stderr.write(`\u2717 ${opts.error}
+`);
+    return 1;
+  }
+  let dumpText;
+  try {
+    dumpText = readFileSync5(opts.file, "utf8");
+  } catch (e) {
+    process.stderr.write(`\u2717 could not read ${opts.file}: ${e instanceof Error ? e.message : String(e)}
+`);
+    return 1;
+  }
+  let res;
+  try {
+    res = await fetch(`${opts.url.replace(/\/$/, "")}/_admin/import`, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${opts.adminKey}` },
+      body: dumpText
+    });
+  } catch (e) {
+    process.stderr.write(`\u2717 could not reach ${opts.url}: ${e instanceof Error ? e.message : String(e)}
+`);
+    return 1;
+  }
+  if (res.status === 401) {
+    process.stderr.write("\u2717 unauthorized \u2014 check HELIPOD_ADMIN_KEY / --admin-key\n");
+    return 1;
+  }
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok || !body.ok) {
+    process.stderr.write(`\u2717 import failed: ${body.error ?? res.statusText}
+`);
+    return 1;
+  }
+  process.stdout.write(
+    `\u2713 imported ${body.imported?.documents ?? 0} documents, ${body.imported?.indexUpdates ?? 0} index rows
+`
+  );
+  return 0;
+}
+
+// src/migrate.ts
+var SOURCES = { convex: convexSource };
+function parse(args) {
+  const out = { from: "convex", functionsDir: "convex", dryRun: false, force: false };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--from" && args[i + 1]) out.from = args[++i];
+    else if (a === "--dir" && args[i + 1]) out.functionsDir = args[++i];
+    else if (a === "--dry-run") out.dryRun = true;
+    else if (a === "--force") out.force = true;
+  }
+  return out;
+}
+function renderReport(entries) {
+  const by = (s) => entries.filter((e) => e.severity === s);
+  const section = (title, items) => items.length === 0 ? "" : `
+## ${title} (${items.length})
+
+` + items.map((e) => `- \`${e.file}${e.line ? `:${e.line}` : ""}\` \u2014 ${e.what}. **Fix:** ${e.fix}`).join("\n") + "\n";
+  return `# Helipod migration report
+
+${by("auto-fixed").length} auto-fixed, ${by("action-needed").length} action-needed, ${by("unsupported").length} unsupported.
+` + section("Auto-fixed", by("auto-fixed")) + section("Action needed", by("action-needed")) + section("Unsupported", by("unsupported"));
+}
+function gitDirty(dir) {
+  const r = spawnSync2("git", ["status", "--porcelain"], { cwd: dir, encoding: "utf8" });
+  if (r.status !== 0) return null;
+  return r.stdout.trim().length > 0;
+}
+async function migrateCommand(args) {
+  if (args[0] === "export") return migrateExportCommand(args.slice(1));
+  if (args[0] === "import") return migrateImportCommand(args.slice(1));
+  const opts = parse(args);
+  const functionsDir = resolve7(opts.functionsDir);
+  const projectRoot = dirname7(functionsDir);
+  const dirty = gitDirty(projectRoot);
+  if (dirty === true && !opts.force) {
+    process.stderr.write(
+      `refusing to migrate: ${projectRoot} has uncommitted changes (commit/stash first, or pass --force)
+`
+    );
+    return 1;
+  }
+  if (dirty === null) {
+    process.stderr.write(`warning: ${projectRoot} is not a git repo \u2014 changes will be made in place with no easy revert
+`);
+  }
+  let source;
+  try {
+    source = resolveSource(SOURCES, opts.from);
+  } catch (e) {
+    process.stderr.write(`${String(e)}
+`);
+    return 1;
+  }
+  if (!await source.detect(projectRoot)) {
+    process.stderr.write(`no ${opts.from} project detected at ${projectRoot}
+`);
+    return 1;
+  }
+  const { functionsDir: targetDir } = await resolveFunctionsDir(void 0, projectRoot);
+  let migratedDir = functionsDir;
+  let renamed = false;
+  let pendingRename = false;
+  if (resolve7(functionsDir) !== resolve7(targetDir)) {
+    if (existsSync8(targetDir)) {
+      process.stderr.write(
+        `refusing to migrate: ${targetDir} already exists (remove or rename it, then re-run)
+`
+      );
+      return 1;
+    }
+    if (opts.dryRun) {
+      pendingRename = true;
+    } else {
+      try {
+        let didGitMv = false;
+        if (dirty !== null) {
+          const r = spawnSync2("git", ["mv", functionsDir, targetDir], { cwd: projectRoot });
+          didGitMv = r.status === 0;
+        }
+        if (!didGitMv) renameSync(functionsDir, targetDir);
+      } catch (e) {
+        process.stderr.write(
+          `refusing to migrate: could not rename ${functionsDir} to ${targetDir}: ${e instanceof Error ? e.message : String(e)}
+`
+        );
+        return 1;
+      }
+      migratedDir = targetDir;
+      renamed = true;
+      process.stdout.write(`renamed ${functionsDir} \u2192 ${targetDir}
+`);
+    }
+  }
+  const plan = await source.analyze(projectRoot, migratedDir);
+  if (renamed || pendingRename) {
+    plan.report.unshift({
+      severity: "auto-fixed",
+      file: `${basename2(functionsDir)}/`,
+      what: pendingRename ? `would be renamed to ${basename2(targetDir)}/` : `renamed to ${basename2(targetDir)}/`,
+      fix: pendingRename ? `Your backend functions will move to ${basename2(targetDir)}/ when you run this migration without --dry-run. Imports inside that folder are relative and will not change.` : `Your backend functions now live in ${basename2(targetDir)}/. Imports inside that folder are relative and did not change.`
+    });
+  }
+  writeFileSync5(join12(projectRoot, "MIGRATION-REPORT.md"), renderReport(plan.report));
+  if (opts.dryRun) {
+    const renameNote = pendingRename ? ` ${basename2(functionsDir)}/ would be renamed to ${basename2(targetDir)}/.` : "";
+    process.stdout.write(
+      `[dry-run] ${plan.edits.length} files would change, ${plan.scaffold.length} scaffolded.${renameNote} See MIGRATION-REPORT.md
+`
+    );
+    return 0;
+  }
+  for (const edit of plan.edits) writeFileSync5(edit.path, edit.newContent);
+  for (const file of plan.scaffold) if (!existsSync8(file.path)) writeFileSync5(file.path, file.content);
+  try {
+    const generatedDir = join12(migratedDir, "_generated");
+    rmSync3(generatedDir, { recursive: true, force: true });
+    const config = await loadConfig(projectRoot);
+    if (!existsSync8(join12(generatedDir, "server.ts"))) {
+      const stub = generateServer(
+        { tables: {}, schemaValidation: false },
+        { components: config.components.map((c) => ({ name: c.name, contextType: c.contextType, serverExports: c.serverExports })) }
+      );
+      mkdirSync5(generatedDir, { recursive: true });
+      writeFileSync5(join12(generatedDir, "server.ts"), stub.content);
+    }
+    const loaded = await loadFunctionsDir(migratedDir);
+    const { generated } = push(loaded, config.components);
+    writeGenerated3(generated.files, generatedDir);
+  } catch (e) {
+    process.stderr.write(
+      `imports migrated, but codegen failed: ${String(e)}
+See MIGRATION-REPORT.md; fix the flagged items, then run \`helipod codegen\`.
+`
+    );
+    return 1;
+  }
+  const n = plan.report.filter((r) => r.severity !== "auto-fixed").length;
+  process.stdout.write(`migrated ${plan.edits.length} files. ${n} item(s) need manual attention \u2014 see MIGRATION-REPORT.md
+`);
+  return 0;
+}
+
+// src/fleet.ts
+var FLEET_ERR_NO_PACKAGE2 = "fleet mode requires @helipod/fleet \u2014 install it (bun add @helipod/fleet).";
+function parseReshardArgs(args) {
+  let shardsRaw;
+  let databaseUrl = process.env.HELIPOD_DATABASE_URL;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--shards" && args[i + 1]) shardsRaw = args[++i];
+    else if (a === "--database-url" && args[i + 1]) databaseUrl = args[++i];
+  }
+  if (shardsRaw === void 0) {
+    return { ok: false, error: "\u2717 --shards <M> is required \u2014 e.g. --shards 4" };
+  }
+  const targetShards = Number(shardsRaw);
+  if (!Number.isInteger(targetShards) || targetShards < 1) {
+    return { ok: false, error: `\u2717 --shards must be an integer >= 1, got ${JSON.stringify(shardsRaw)}` };
+  }
+  if (!isPostgresUrl(databaseUrl)) {
+    return {
+      ok: false,
+      error: "\u2717 --database-url postgres://\u2026 is required (or HELIPOD_DATABASE_URL) \u2014 fleet reshard is Postgres-only"
+    };
+  }
+  return { ok: true, args: { targetShards, databaseUrl } };
+}
+async function reshardCommand(args) {
+  const parsed = parseReshardArgs(args);
+  if (!parsed.ok) {
+    process.stderr.write(parsed.error + "\n");
+    return 1;
+  }
+  const { targetShards, databaseUrl } = parsed.args;
+  let fleetModule;
+  try {
+    const fleetSpecifier = "@helipod/fleet";
+    fleetModule = await import(fleetSpecifier);
+  } catch {
+    process.stderr.write(`\u2717 ${FLEET_ERR_NO_PACKAGE2}
+`);
+    return 1;
+  }
+  const client = makePgClient(databaseUrl);
+  try {
+    const result = await fleetModule.reshardFleet(client, { targetShards });
+    process.stdout.write(
+      `\u2713 resharded ${result.previousShards} \u2192 ${result.newShards} shards (created: ${result.created.length ? result.created.join(", ") : "none"}, deleted: ${result.deleted.length ? result.deleted.join(", ") : "none"}, frontier floor: ${result.frontierFloor}); update HELIPOD_FLEET_SHARDS to ${result.newShards} (or unset) before restarting the fleet
+`
+    );
+    return 0;
+  } catch (e) {
+    process.stderr.write(`\u2717 ${e instanceof Error ? e.message : String(e)}
+`);
+    return 1;
+  } finally {
+    await client.close();
+  }
+}
+async function fleetCommand(args) {
+  const [sub, ...rest] = args;
+  switch (sub) {
+    case "reshard":
+      return reshardCommand(rest);
+    default:
+      process.stderr.write(
+        `\u2717 unknown fleet subcommand: ${sub ?? "(none)"}
+Usage: helipod fleet reshard --shards M --database-url <url>
+`
+      );
+      return 1;
+  }
+}
+
+// src/objectstore.ts
+import { dirname as dirname8 } from "path";
+async function objectstoreCommand(args) {
+  const sub = args[0];
+  if (sub !== "reshard") {
+    process.stderr.write(
+      `\u2717 unknown \`objectstore\` subcommand '${sub ?? ""}' \u2014 usage: helipod objectstore reshard --object-store <url> --dir <functionsDir> --shards M
+`
+    );
+    return 1;
+  }
+  return reshardCommand2(args.slice(1));
+}
+async function reshardCommand2(args) {
+  let objectStoreUrl = process.env.HELIPOD_OBJECT_STORE;
+  let dirFlag;
+  let shards;
+  const VALUE_FLAGS = /* @__PURE__ */ new Set(["--object-store", "--dir", "--shards"]);
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (!VALUE_FLAGS.has(a)) continue;
+    const val = args[i + 1];
+    if (val === void 0) {
+      process.stderr.write(`\u2717 ${a} requires a value.
+`);
+      return 1;
+    }
+    i++;
+    if (a === "--object-store") objectStoreUrl = val;
+    else if (a === "--dir") dirFlag = val;
+    else shards = Number(val);
+  }
+  if (!objectStoreUrl) {
+    process.stderr.write("\u2717 objectstore reshard requires --object-store <url> (or HELIPOD_OBJECT_STORE).\n");
+    return 1;
+  }
+  if (shards === void 0 || !Number.isInteger(shards) || shards < 1) {
+    process.stderr.write("\u2717 objectstore reshard requires --shards <M> (a positive integer).\n");
+    return 1;
+  }
+  try {
+    const resolved = resolveObjectStore(objectStoreUrl);
+    if (resolved === null) {
+      process.stderr.write(`\u2717 --object-store "${objectStoreUrl}" did not resolve to a store (empty/unset value?).
+`);
+      return 1;
+    }
+    const { functionsDir } = await resolveFunctionsDir(dirFlag, process.cwd());
+    if (!ensureFunctionsDirExists(functionsDir)) return 1;
+    const loaded = await loadFunctionsDir(functionsDir);
+    const config = await loadConfig(dirname8(functionsDir));
+    const { project } = push(loaded, config.components);
+    const shardKeyFor = (tableNumber) => project.catalog.getTableByNumber(tableNumber)?.shardKey ?? null;
+    const substrate = await loadObjectStoreSubstrateModule();
+    await resolved.objectStore.assertCasSupported();
+    const result = await substrate.reshardObjectStore({
+      objectStore: resolved.objectStore,
+      toShards: shards,
+      now: Date.now(),
+      shardKeyFor,
+      makeLocal: makeInMemorySqliteStore
+    });
+    if (result.fromShards === result.toShards) {
+      process.stdout.write(`\u2713 bucket is already at ${result.toShards} shard(s) \u2014 nothing to do.
+`);
+      return 0;
+    }
+    const perLane = Object.entries(result.perLaneCounts).map(([lane, n]) => `${lane}=${n}`).join(", ");
+    process.stdout.write(
+      `\u2713 resharded ${result.fromShards} \u2192 ${result.toShards} shard(s) (moved ${result.movedDocs} doc(s); per-lane: ${perLane}). A node booting this bucket now uses ${result.toShards} shard(s) \u2014 set --shards ${result.toShards} (or HELIPOD_FLEET_SHARDS), or drop it (the bucket's persisted count is authoritative).
+`
+    );
+    return 0;
+  } catch (e) {
+    process.stderr.write(`\u2717 ${e instanceof Error ? e.message : String(e)}
+`);
+    return 1;
+  }
+}
+
+// src/cli.ts
+function parseFlags(args) {
+  const out = {};
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--port" && args[i + 1]) out.port = Number(args[++i]);
+    else if (a === "--ip" && args[i + 1]) out.ip = args[++i];
+    else if (a === "--dir" && args[i + 1]) out.functionsDir = args[++i];
+    else if (a === "--data" && args[i + 1]) out.dataPath = args[++i];
+    else if (a === "--web" && args[i + 1]) out.webDir = args[++i];
+    else if (a === "--database-url" && args[i + 1]) out.databaseUrl = args[++i];
+    else if (a === "--storage-bucket" && args[i + 1]) out.storageBucket = args[++i];
+    else if (a === "--storage-endpoint" && args[i + 1]) out.storageEndpoint = args[++i];
+  }
+  return out;
+}
+async function devCommand(args) {
+  const flags = parseFlags(args);
+  const { functionsDir, projectRoot } = await resolveFunctionsDir(flags.functionsDir, process.cwd());
+  if (!ensureFunctionsDirExists(functionsDir)) {
+    return 1;
+  }
+  const opts = resolveDevOptions({ ...flags, functionsDir });
+  const generatedDir = join13(opts.functionsDir, "_generated");
+  const config = await loadConfig(projectRoot);
+  const envKey = process.env.HELIPOD_ADMIN_KEY?.trim();
+  if (process.env.HELIPOD_ADMIN_KEY !== void 0 && !envKey) {
+    process.stderr.write("\u26A0 HELIPOD_ADMIN_KEY is set but empty \u2014 generating an ephemeral key instead.\n");
+  }
+  const adminKey = envKey || generateAdminKey();
+  const ephemeralKey = !envKey;
+  const loopback = ["127.0.0.1", "::1", "localhost"].includes(opts.ip);
+  const { runtime, adminApi, project, generated, store, logSink, storageRoutes: storageRoutes2 } = await bootProject({
+    functionsDir: opts.functionsDir,
+    dataPath: opts.dataPath,
+    adminKey,
+    databaseUrl: opts.databaseUrl,
+    storage: { bucket: opts.storageBucket, endpoint: opts.storageEndpoint }
+  });
+  writeGenerated4(generated.files, generatedDir);
+  const dashboard = loadDashboard(ephemeralKey && loopback ? adminKey : void 0);
+  const host = new ProcessRuntimeHost();
+  const server = await host.serve(
+    runtime,
+    { port: opts.port, ip: opts.ip, webDir: opts.webDir, admin: { api: adminApi, key: adminKey }, dashboard, routes: project.routes, storageRoutes: storageRoutes2 }
+  );
+  process.stdout.write(`helipod dev \u2192 ${server.url}  (dashboard: ${server.url}/_dashboard)
+`);
+  if (!dashboard) process.stdout.write(`  (dashboard SPA not built \u2014 run \`bun run --filter @helipod/dashboard build\`)
+`);
+  process.stdout.write(`admin key \u2192 ${adminKey}
+`);
+  if (opts.webDir) process.stdout.write(`web UI \u2192 ${server.url}/
+`);
+  const watcher = createWatchLoop({
+    subscribe: (onChange) => {
+      const w = fsWatch(resolve8(opts.functionsDir), { recursive: true }, (_e, file) => {
+        if (file && !String(file).includes("_generated")) onChange();
+      });
+      return () => w.close();
+    },
+    onTrigger: async (reason) => {
+      if (reason === "initial") return;
+      try {
+        const next = push(await loadFunctionsDir(opts.functionsDir), config.components);
+        writeGenerated4(next.generated.files, generatedDir);
+        runtime.setModules(withStorageModules(next.project.moduleMap));
+        server.setRoutes(next.project.routes);
+        process.stdout.write(`\u21BB pushed (${Object.keys(next.project.moduleMap).length} functions)
+`);
+      } catch (e) {
+        process.stderr.write(`\u2717 reload failed: ${e instanceof Error ? e.message : String(e)}
+`);
+      }
+    }
+  });
+  watcher.start();
+  return new Promise(() => {
+  });
+}
+async function codegenCommand(args) {
+  const flags = parseFlags(args);
+  const { functionsDir } = await resolveFunctionsDir(flags.functionsDir, process.cwd());
+  if (!ensureFunctionsDirExists(functionsDir)) return 1;
+  const opts = resolveDevOptions({ ...flags, functionsDir });
+  const loaded = await loadFunctionsDir(opts.functionsDir);
+  const config = await loadConfig(dirname9(opts.functionsDir));
+  const { generated } = push(loaded, config.components);
+  writeGenerated4(generated.files, join13(opts.functionsDir, "_generated"));
+  process.stdout.write(`generated ${opts.functionsDir}/_generated
+`);
+  return 0;
+}
+function printHelp() {
+  process.stdout.write(
+    [
+      "helipod - the reactive backend you self-host",
+      "",
+      "Usage: helipod <command> [options]",
+      "",
+      "Commands:",
+      "  dev        Run the engine with hot reload + dashboard",
+      "  serve      Run the production server (requires HELIPOD_ADMIN_KEY)",
+      "  deploy     Deploy the app: --target <serve|cloudflare|docker|railway|fly|aws> --env <name> [--dry-run] [--check]",
+      "  build      Compile the app to a self-contained executable (bun build --compile)",
+      "  migrate    Migrate a Convex project into Helipod (imports + report)",
+      "  migrate export --url <src> --out dump.json   Export app data to a portable dump",
+      "  migrate import --url <dst> --in  dump.json   Import a dump into a deployment",
+      "  codegen    Regenerate <functionsDir>/_generated types",
+      "  fleet reshard --shards M --database-url <url>   Change a STOPPED fleet's shard count",
+      "  objectstore reshard --shards M --object-store <url> --dir <functionsDir>   Change a STOPPED object-storage deployment's shard count",
+      "  help       Show this help",
+      "",
+      "Options: --port <n>  --ip <addr>  --dir <functionsDir>  --data <dbPath>  --database-url <url>",
+      "Deploy:  --target <name>  --env <name>  --dry-run  --check   (default target: serve; default env: production)",
+      ""
+    ].join("\n")
+  );
+}
+async function runCli(argv) {
+  const [cmd, ...rest] = argv;
+  switch (cmd) {
+    case "dev":
+      return devCommand(rest);
+    case "serve":
+      return serveCommand(rest);
+    case "deploy":
+      return deployCommand(rest);
+    case "build":
+      return buildCommand(rest);
+    case "migrate":
+      return migrateCommand(rest);
+    case "codegen":
+      return codegenCommand(rest);
+    case "fleet":
+      return fleetCommand(rest);
+    case "objectstore":
+      return objectstoreCommand(rest);
+    case "help":
+    case "--help":
+    case "-h":
+    case void 0:
+      printHelp();
+      return 0;
+    default:
+      process.stderr.write(`unknown command: ${cmd}
+`);
+      printHelp();
+      return 1;
+  }
+}
+
+export {
+  loadConfig,
+  DEFAULT_FUNCTIONS_DIR,
+  resolveFunctionsDir,
+  functionsDirNotFoundMessage,
+  resolveDevOptions,
+  detectRuntime,
+  loadFunctionsDir,
+  push,
+  withStorageModules,
+  bootLoaded,
+  bootProject,
+  startDevServer,
+  ProcessRuntimeHost,
+  createWatchLoop,
+  devCommand,
+  codegenCommand,
+  runCli
+};
+//# sourceMappingURL=chunk-IBFZ2HUR.js.map