1tube 0.1.15 → 0.1.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "1tube",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "private": false,
   "description": "Self-hosted Supabase Edge Functions gateway for Deno, plus an ESLint plugin for consumers",
   "license": "MIT",

package/src/backends/workerd/backend.ts

@@ -31,7 +31,7 @@
  * braces guarantee.
  */
 
-import { isAbsolute, join, resolve as resolvePath } from "node:path";
+import { isAbsolute, join, relative, resolve as resolvePath } from "node:path";
 import { ensureDir } from "jsr:@std/fs@^1/ensure-dir";
 import { type AuthContext } from "../../registry.ts";
 import { type FunctionManifest, loadManifest } from "../../manifest.ts";
@@ -47,6 +47,14 @@ import {
   parsePrebuiltManifest,
   type PrebuiltManifest,
 } from "./prebuilt.ts";
+import {
+  copyPrebuiltRuntimeFiles,
+  defaultRuntimeOverrideRoot,
+  RuntimeOverrideStore,
+  type EditableSourceResponse,
+  type EditableFunctionSummary,
+  type SaveEditableSourceInput,
+} from "./runtime-overrides.ts";
 import { type CapnpRoute, generateCapnp } from "./capnp.ts";
 import {
   SHARED_RUNTIME_TOKEN_ENV,
@@ -76,6 +84,8 @@ export interface WorkerdBackendOptions {
    * `node_modules/` exists, else `.1tube-cache/workerd/`.
    */
   cacheDir?: string;
+  /** Writable runtime source/bundle overlay used by the admin edge editor. */
+  runtimeOverrideDir?: string;
   /** Loopback address for workerd sockets. Defaults to `"127.0.0.1"`. */
   bindAddress?: string;
   /** First port to assign to a function. Defaults to `8800`. */
@@ -84,6 +94,8 @@ export interface WorkerdBackendOptions {
   compatibilityDate?: string;
   /** Compatibility flags applied to every service. */
   compatibilityFlags?: readonly string[];
+  /** Pass `--experimental` to the workerd process. */
+  experimental?: boolean;
   /** Sourcemap mode passed to the bundler. */
   sourcemap?: boolean | "linked" | "inline";
   /** Sink for workerd's [workerd]-prefixed log lines. Defaults to stderr. */
@@ -135,8 +147,8 @@ export interface WorkerdBackendOptions {
    *
    * In this mode `functionsDir` is ignored, no bundler is created (so
    * the operator does not need esbuild's worker subprocess on the box),
-   * and `reload()` is unsupported — the artifact is sealed. HMR must
-   * not be enabled by the gateway when this is set.
+   * and runtime reloads compose the sealed artifact with admin
+   * overlays. HMR must not be enabled by the gateway when this is set.
    *
    * Bundle integrity is verified against the manifest's recorded
    * sha-256 at boot, so a tampered bundle fails fast with a clear
@@ -329,6 +341,12 @@ export interface WorkerdBackend {
    * exactly what the e2e tests assert on.
    */
   readonly lastReloadDurationMs: number | null;
+  listEditableFunctions(): Promise<EditableFunctionSummary[]>;
+  readEditableSource(name: string): Promise<EditableSourceResponse>;
+  saveEditableSource(name: string, input: SaveEditableSourceInput): Promise<WorkerdReloadResult>;
+  createEditableFunction(name: string): Promise<EditableSourceResponse>;
+  deleteEditableFunction(name: string): Promise<WorkerdReloadResult>;
+  revertEditableFunction(name: string): Promise<WorkerdReloadResult>;
   /** Tear down workerd and dispose esbuild's worker. Idempotent. */
   stop(): Promise<void>;
 }
@@ -824,6 +842,7 @@ export function createWorkerdBackend(opts: WorkerdBackendOptions): WorkerdBacken
   // Mutable state set during start(). Kept in closure scope so dispatch()
   // can reach it without an extra indirection layer.
   let bundler: Bundler | null = null;
+  let overlayBundler: Bundler | null = null;
   let process: WorkerdProcess | null = null;
   let routesByName = new Map<string, CapnpRoute>();
   let workerdVersion: string | null = null;
@@ -867,8 +886,19 @@ export function createWorkerdBackend(opts: WorkerdBackendOptions): WorkerdBacken
       ? opts.prebuiltDir
       : resolvePath(cwd, opts.prebuiltDir))
     : null;
+  const runtimeEditorEnabled = prebuiltDir !== null;
   let prebuiltManifest: PrebuiltManifest | null = null;
   let sharedRuntime: WorkerdSharedRuntime | null = null;
+  const runtimeOverrides = new RuntimeOverrideStore({
+    rootDir: opts.runtimeOverrideDir
+      ? (isAbsolute(opts.runtimeOverrideDir) ? opts.runtimeOverrideDir : resolvePath(cwd, opts.runtimeOverrideDir))
+      : defaultRuntimeOverrideRoot(cwd),
+    sourceFunctionsDir: resolvedFunctionsDir,
+    prebuiltDir,
+    getPrebuiltManifest: () => prebuiltManifest,
+    getLiveManifests: () => manifests,
+    getBundleBytes: () => bundleBytes,
+  });
 
   /**
    * Shared boot pipeline used by both `start()` and `reload()`.
@@ -916,7 +946,11 @@ export function createWorkerdBackend(opts: WorkerdBackendOptions): WorkerdBacken
     // while live mode allocates the usual node_modules/.cache slot.
     if (cacheDir === null) {
       if (prebuiltDir !== null) {
-        cacheDir = prebuiltDir;
+        cacheDir = opts.cacheDir
+          ? (isAbsolute(opts.cacheDir) ? opts.cacheDir : resolvePath(cwd, opts.cacheDir))
+          : join(await defaultCacheDir(cwd), "prebuilt-runtime");
+        await ensureDir(cacheDir);
+        await writeGitignore(cacheDir);
       } else {
         cacheDir = opts.cacheDir
           ? (isAbsolute(opts.cacheDir) ? opts.cacheDir : resolvePath(cwd, opts.cacheDir))
@@ -933,6 +967,7 @@ export function createWorkerdBackend(opts: WorkerdBackendOptions): WorkerdBacken
     // to the caller for the WorkerdReloadResult; prebuilt mode never
     // rebuilds anything so this stays empty there.
     let rebundledNames: string[] = [];
+    const overlayManifests = new Map<string, FunctionManifest>();
     if (prebuiltDir !== null) {
       // Prebuilt mode — every "bundle" already exists on disk. We
       // synthesise BundleResults from the manifest so the rest of
@@ -945,7 +980,14 @@ export function createWorkerdBackend(opts: WorkerdBackendOptions): WorkerdBacken
         // with a null manifest. Raising hard makes the bug obvious.
         throw new Error("prebuilt manifest not loaded");
       }
-      let entries = prebuiltManifest.functions;
+      await copyPrebuiltRuntimeFiles(prebuiltManifest, prebuiltDir, cacheDir!);
+      const baseNames = new Set(prebuiltManifest.functions.map((e) => e.name));
+      const overlays = runtimeEditorEnabled
+        ? await runtimeOverrides.compose(baseNames)
+        : [];
+      for (const overlay of overlays) overlayManifests.set(overlay.name, overlay.manifest);
+      const patchedNames = new Set(overlays.filter((e) => e.origin === "patched").map((e) => e.name));
+      let entries = prebuiltManifest.functions.filter((e) => !patchedNames.has(e.name));
       if (opts.only && opts.only.length > 0) {
         const allow = new Set(opts.only);
         entries = entries.filter((e) => allow.has(e.name));
@@ -967,6 +1009,22 @@ export function createWorkerdBackend(opts: WorkerdBackendOptions): WorkerdBacken
         byteLength: e.bundleBytes,
         durationMs: 0,
       }));
+      if (overlays.length > 0) {
+        if (!overlayBundler) {
+          overlayBundler = createBundler({
+            outDir: join(cacheDir!, "runtime-overrides"),
+            configPath,
+            sourcemap: "linked",
+            minify: true,
+          });
+        }
+        const overlayResults = await overlayBundler.bundleAll(
+          overlays.map((entry) => ({ name: entry.name, entrypoint: entry.entrypoint })),
+          { concurrency: opts.bundleConcurrency ?? 4 },
+        );
+        bundleResults.push(...overlayResults);
+        rebundledNames = overlayResults.map((r) => r.name);
+      }
       for (const shared of prebuiltManifest.sharedModules) {
         sharedModules.push({
           id: shared.id,
@@ -985,6 +1043,18 @@ export function createWorkerdBackend(opts: WorkerdBackendOptions): WorkerdBacken
           );
         }
       }
+      const baseNames = new Set(inputs.map((i) => i.name));
+      const overlays = runtimeEditorEnabled
+        ? await runtimeOverrides.compose(baseNames)
+        : [];
+      for (const overlay of overlays) overlayManifests.set(overlay.name, overlay.manifest);
+      if (overlays.length > 0) {
+        const overlayNames = new Set(overlays.map((entry) => entry.name));
+        inputs = [
+          ...inputs.filter((input) => !overlayNames.has(input.name)),
+          ...overlays.map((entry) => ({ name: entry.name, entrypoint: entry.entrypoint })),
+        ].sort((a, b) => a.name.localeCompare(b.name));
+      }
       if (inputs.length === 0) {
         // Empty functions dir is a legitimate state — typically a
         // fresh deployment that hasn't received its first firmware
@@ -1183,16 +1253,19 @@ export function createWorkerdBackend(opts: WorkerdBackendOptions): WorkerdBacken
       const newManifests = new Map<string, FunctionManifest>();
       if (prebuiltDir !== null && prebuiltManifest) {
         for (const e of prebuiltManifest.functions) {
-          newManifests.set(e.name, e.manifest);
+          if (!overlayManifests.has(e.name)) newManifests.set(e.name, e.manifest);
         }
       } else {
         await Promise.all(
           bundleResults.map(async (r) => {
-            const m = await loadManifest(resolvedFunctionsDir, r.name);
+            const m = overlayManifests.get(r.name) ?? await loadManifest(resolvedFunctionsDir, r.name);
             newManifests.set(r.name, m);
           }),
         );
       }
+      for (const [name, manifest] of overlayManifests) {
+        newManifests.set(name, manifest);
+      }
 
       // Mirror the Deno backend's two-mode env story:
       //   - Default: every function sees the full gateway allowlist.
@@ -1218,8 +1291,10 @@ export function createWorkerdBackend(opts: WorkerdBackendOptions): WorkerdBacken
         : [];
       const capnpInputs = bundleResults.map((r) => {
         const m = newManifests.get(r.name)!;
-        const bundleEmbedPath = prebuiltBundleFiles?.get(r.name) ??
-          r.bundlePath.split(/[\\/]/).pop()!;
+        const bundleEmbedPath = overlayManifests.has(r.name)
+          ? relative(cacheDir!, r.bundlePath).replaceAll("\\", "/")
+          : prebuiltBundleFiles?.get(r.name) ??
+            relative(cacheDir!, r.bundlePath).replaceAll("\\", "/");
         const fnEnvBindings = intersectEnvForFunction(gatewayEnvBindings, m.permissions.env, enforceManifest);
         for (const internalName of internalEnvBindings) {
           if (!fnEnvBindings.includes(internalName)) fnEnvBindings.push(internalName);
@@ -1231,7 +1306,7 @@ export function createWorkerdBackend(opts: WorkerdBackendOptions): WorkerdBacken
           // and capnp is written at dist/, so use the manifest-relative
           // path ("functions/<fn>.js") or workerd cannot resolve embeds.
           bundleBasename: bundleEmbedPath,
-          moduleFiles: prebuiltModuleFiles?.get(r.name),
+          moduleFiles: overlayManifests.has(r.name) ? undefined : prebuiltModuleFiles?.get(r.name),
           envBindings: fnEnvBindings,
         };
       });
@@ -1378,12 +1453,16 @@ export function createWorkerdBackend(opts: WorkerdBackendOptions): WorkerdBacken
       if (verboseWorkerd) {
         console.log(`[1tube] workerd verbose logging enabled (1TUBE_WORKERD_VERBOSE=1)`);
       }
+      const globalArgs = [
+        ...(verboseWorkerd ? ["-v"] : []),
+        ...(opts.experimental ? ["--experimental"] : []),
+      ];
 
       const newProcess = createWorkerdProcess({
         binary: workerdBin,
         capnpPath,
         routes: capnp.routes,
-        ...(verboseWorkerd ? { globalArgs: ["-v"] } : {}),
+        ...(globalArgs.length > 0 ? { globalArgs } : {}),
         extraArgs,
         env: sharedRuntime
           ? {
@@ -1598,6 +1677,15 @@ export function createWorkerdBackend(opts: WorkerdBackendOptions): WorkerdBacken
     return reloadInFlight;
   }
 
+  function requireRuntimeEditor(): void {
+    if (!runtimeEditorEnabled) {
+      throw new Error(
+        "edge function runtime editor is disabled outside prebuilt workerd mode; " +
+          "use HMR/source files for local development",
+      );
+    }
+  }
+
   return {
     get pid() {
       return process?.pid ?? null;
@@ -1624,6 +1712,7 @@ export function createWorkerdBackend(opts: WorkerdBackendOptions): WorkerdBacken
     async start() {
       if (started) throw new Error("workerd backend already started");
       started = true;
+      if (runtimeEditorEnabled) await runtimeOverrides.load();
 
       // Load + verify the prebuilt manifest BEFORE probing workerd, so
       // a stale / tampered artifact fails with a clear error before we
@@ -1783,16 +1872,14 @@ export function createWorkerdBackend(opts: WorkerdBackendOptions): WorkerdBacken
     },
 
     reload(changed) {
-      // Prebuilt artifacts are sealed — block every public reload
-      // request. Crash-recovery still works because the internal
-      // crash handler calls `doReload` directly (re-spawning workerd
-      // against the same on-disk bundles is legitimate; only
-      // re-bundling is forbidden).
+      // Keep the public API contract: prebuilt firmware is immutable
+      // from HMR/test callers. Runtime editor admin methods below use
+      // doReload() directly after mutating the overlay store.
       if (prebuiltDir !== null) {
         return Promise.reject(
           new Error(
-            "workerd backend is in prebuilt mode; reload is not supported. " +
-              "Re-run `1tube build` and restart the gateway to pick up changes.",
+            "workerd backend is in prebuilt mode; public reload is not supported. " +
+              "Use the runtime editor APIs for overlay hot-swaps, or promote new firmware.",
           ),
         );
       }
@@ -1840,6 +1927,44 @@ export function createWorkerdBackend(opts: WorkerdBackendOptions): WorkerdBacken
       }
     },
 
+    async listEditableFunctions() {
+      requireRuntimeEditor();
+      return await runtimeOverrides.list(new Set(names));
+    },
+
+    async readEditableSource(name) {
+      requireRuntimeEditor();
+      return await runtimeOverrides.read(name, new Set(names));
+    },
+
+    async createEditableFunction(name) {
+      requireRuntimeEditor();
+      if (names.includes(name.trim())) {
+        throw new Error(`function "${name}" exists in firmware; open Code and save a patch instead`);
+      }
+      const source = await runtimeOverrides.create(name);
+      await doReload(new Set([name]));
+      return source;
+    },
+
+    async saveEditableSource(name, input) {
+      requireRuntimeEditor();
+      await runtimeOverrides.save(name, input, new Set(names));
+      return await doReload(new Set([name]));
+    },
+
+    async deleteEditableFunction(name) {
+      requireRuntimeEditor();
+      await runtimeOverrides.deleteAdded(name);
+      return await doReload("all");
+    },
+
+    async revertEditableFunction(name) {
+      requireRuntimeEditor();
+      await runtimeOverrides.revert(name);
+      return await doReload(new Set([name]));
+    },
+
     async stop() {
       if (stopping) return;
       stopping = true;
@@ -1852,8 +1977,12 @@ export function createWorkerdBackend(opts: WorkerdBackendOptions): WorkerdBacken
         if (bundler) {
           await bundler.dispose().catch(() => {});
         }
+        if (overlayBundler && overlayBundler !== bundler) {
+          await overlayBundler.dispose().catch(() => {});
+        }
         sharedRuntime = null;
         bundler = null;
+        overlayBundler = null;
         process = null;
         manifests.clear();
       }

package/src/backends/workerd/bundler.ts

@@ -37,8 +37,8 @@
 import { dirname, join, resolve as resolvePath } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { ensureDir } from "jsr:@std/fs@^1/ensure-dir";
-import * as esbuild from "esbuild";
-import { denoPlugin } from "@deno/esbuild-plugin";
+import * as esbuild from "npm:esbuild@^0.28";
+import { denoPlugin } from "jsr:@deno/esbuild-plugin@^1.2";
 import {
   SHARED_RUNTIME_TOKEN_ENV,
   SHARED_RUNTIME_URL_ENV,

package/src/backends/workerd/prebuilt.ts

@@ -39,6 +39,8 @@ export interface PrebuiltFunctionEntry {
   moduleFiles: string[];
   /** Per-function `1tube.json` parsed at build time. */
   manifest: FunctionManifest;
+  /** Optional inspectable authored source files under `sources/<name>/`. */
+  sourceFiles?: string[];
 }
 
 export interface PrebuiltChunkEntry {
@@ -128,6 +130,9 @@ export function parsePrebuiltManifest(raw: unknown): PrebuiltManifest {
       bundleSha256,
       moduleFiles: moduleFiles.length > 0 ? moduleFiles : [bundleFile],
       manifest: parseManifest(e.manifest, /* fromFile */ true),
+      sourceFiles: Array.isArray(e.sourceFiles)
+        ? e.sourceFiles.filter((n): n is string => typeof n === "string")
+        : undefined,
     };
   });
   const chunks: PrebuiltChunkEntry[] = Array.isArray(obj.chunks)

package/src/backends/workerd/runtime-overrides.ts

@@ -0,0 +1,600 @@
+import { basename, dirname, join, normalize, relative, resolve as resolvePath } from "node:path";
+import { ensureDir } from "jsr:@std/fs@^1/ensure-dir";
+import {
+  defaultManifest,
+  MANIFEST_FILENAME,
+  parseManifest,
+  type FunctionManifest,
+} from "../../manifest.ts";
+import type { PrebuiltManifest } from "./prebuilt.ts";
+
+const NAME_RX = /^[A-Za-z][A-Za-z0-9_-]*$/;
+const OVERLAY_SCHEMA = 1;
+
+export type EditableFunctionOrigin = "manifest" | "patched" | "added";
+
+export interface RuntimeOverrideEntry {
+  name: string;
+  origin: "patched" | "added";
+  updatedAt: string;
+  files: string[];
+}
+
+interface RuntimeOverrideIndex {
+  schema: number;
+  functions: RuntimeOverrideEntry[];
+}
+
+export interface EditableFunctionSummary {
+  name: string;
+  origin: EditableFunctionOrigin;
+  files: string[];
+  manifest: FunctionManifest;
+  bundleBytes: number | null;
+  source: "overlay" | "snapshot" | "sourcemap" | "bundle" | "source-tree" | "missing";
+  degraded: boolean;
+}
+
+export interface EditableSourceFile {
+  path: string;
+  content: string;
+  language: "typescript" | "javascript" | "json" | "text";
+}
+
+export interface EditableSourceResponse {
+  name: string;
+  origin: EditableFunctionOrigin;
+  files: EditableSourceFile[];
+  selected: string;
+  degraded: boolean;
+  warning?: string;
+}
+
+export interface SaveEditableSourceInput {
+  files: Record<string, string>;
+}
+
+export interface ComposeOverlayInput {
+  baseNames: ReadonlySet<string>;
+}
+
+export interface OverlayComposeEntry {
+  name: string;
+  origin: "patched" | "added";
+  sourceDir: string;
+  entrypoint: string;
+  manifest: FunctionManifest;
+  files: string[];
+}
+
+export interface RuntimeOverrideStoreOptions {
+  rootDir: string;
+  sourceFunctionsDir: string;
+  prebuiltDir?: string | null;
+  getPrebuiltManifest?: () => PrebuiltManifest | null;
+  getLiveManifests?: () => ReadonlyMap<string, FunctionManifest>;
+  getBundleBytes?: () => ReadonlyMap<string, number>;
+}
+
+export function defaultRuntimeOverrideRoot(cwd: string): string {
+  const env = Deno.env.get("1TUBE_RUNTIME_FUNCTIONS_DIR")?.trim();
+  return env ? (isAbsolutePath(env) ? env : resolvePath(cwd, env)) : resolvePath(cwd, ".1tube-cache", "runtime-functions");
+}
+
+function isAbsolutePath(path: string): boolean {
+  return /^[A-Za-z]:[\\/]/.test(path) || path.startsWith("/") || path.startsWith("\\\\");
+}
+
+function safeName(name: string): string {
+  const trimmed = name.trim();
+  if (!NAME_RX.test(trimmed)) {
+    throw new Error(`invalid function name ${JSON.stringify(name)}; expected ${NAME_RX.source}`);
+  }
+  return trimmed;
+}
+
+function safeRelPath(path: string): string {
+  const p = path.replaceAll("\\", "/").trim();
+  if (!p || p.startsWith("/") || p.startsWith("./") || p.includes("\0")) {
+    throw new Error(`invalid source path ${JSON.stringify(path)}`);
+  }
+  const parts = p.split("/");
+  if (parts.some((part) => !part || part === "." || part === "..")) {
+    throw new Error(`invalid source path ${JSON.stringify(path)}`);
+  }
+  return parts.join("/");
+}
+
+function langFor(path: string): EditableSourceFile["language"] {
+  const lower = path.toLowerCase();
+  if (lower.endsWith(".json")) return "json";
+  if (lower.endsWith(".ts") || lower.endsWith(".tsx")) return "typescript";
+  if (lower.endsWith(".js") || lower.endsWith(".mjs") || lower.endsWith(".jsx")) return "javascript";
+  return "text";
+}
+
+async function pathExists(path: string): Promise<boolean> {
+  try {
+    await Deno.stat(path);
+    return true;
+  } catch (err) {
+    if (err instanceof Deno.errors.NotFound) return false;
+    throw err;
+  }
+}
+
+async function readTextIfExists(path: string): Promise<string | null> {
+  try {
+    return await Deno.readTextFile(path);
+  } catch (err) {
+    if (err instanceof Deno.errors.NotFound) return null;
+    throw err;
+  }
+}
+
+async function removeDirIfExists(path: string): Promise<void> {
+  try {
+    await Deno.remove(path, { recursive: true });
+  } catch (err) {
+    if (!(err instanceof Deno.errors.NotFound)) throw err;
+  }
+}
+
+async function listFiles(root: string): Promise<string[]> {
+  const out: string[] = [];
+  async function walk(dir: string) {
+    for await (const entry of Deno.readDir(dir)) {
+      if (entry.name === ".DS_Store") continue;
+      const abs = join(dir, entry.name);
+      if (entry.isDirectory) {
+        await walk(abs);
+      } else if (entry.isFile) {
+        out.push(relative(root, abs).replaceAll("\\", "/"));
+      }
+    }
+  }
+  try {
+    await walk(root);
+  } catch (err) {
+    if (!(err instanceof Deno.errors.NotFound)) throw err;
+  }
+  return out.sort((a, b) => a.localeCompare(b));
+}
+
+async function hashSha256Hex(text: string): Promise<string> {
+  const bytes = new TextEncoder().encode(text);
+  const digest = await crypto.subtle.digest("SHA-256", bytes as BufferSource);
+  return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+function parseManifestText(text: string | null): FunctionManifest {
+  if (text === null) return defaultManifest();
+  try {
+    return parseManifest(JSON.parse(text), true);
+  } catch {
+    return defaultManifest();
+  }
+}
+
+export class RuntimeOverrideStore {
+  readonly rootDir: string;
+  private readonly functionsRoot: string;
+  private readonly indexPath: string;
+  private index: RuntimeOverrideIndex = { schema: OVERLAY_SCHEMA, functions: [] };
+  private loaded = false;
+
+  constructor(private readonly opts: RuntimeOverrideStoreOptions) {
+    this.rootDir = opts.rootDir;
+    this.functionsRoot = join(opts.rootDir, "functions");
+    this.indexPath = join(opts.rootDir, "overrides.json");
+  }
+
+  async load(): Promise<void> {
+    if (this.loaded) return;
+    await ensureDir(this.functionsRoot);
+    const raw = await readTextIfExists(this.indexPath);
+    if (raw) {
+      try {
+        const parsed = JSON.parse(raw) as RuntimeOverrideIndex;
+        if (parsed.schema === OVERLAY_SCHEMA && Array.isArray(parsed.functions)) {
+          this.index = {
+            schema: OVERLAY_SCHEMA,
+            functions: parsed.functions
+              .filter((f) => NAME_RX.test(f.name) && (f.origin === "added" || f.origin === "patched"))
+              .map((f) => ({
+                name: f.name,
+                origin: f.origin,
+                updatedAt: typeof f.updatedAt === "string" ? f.updatedAt : new Date(0).toISOString(),
+                files: Array.isArray(f.files) ? f.files.map(safeRelPath).sort() : [],
+              }))
+              .sort((a, b) => a.name.localeCompare(b.name)),
+          };
+        }
+      } catch (err) {
+        console.warn(`[1tube] ignoring invalid runtime override index ${this.indexPath}: ${err}`);
+      }
+    }
+    this.loaded = true;
+    await this.persist();
+  }
+
+  async list(baseNames: ReadonlySet<string>): Promise<EditableFunctionSummary[]> {
+    await this.load();
+    const names = new Set<string>(baseNames);
+    for (const e of this.index.functions) names.add(e.name);
+    const bundleBytes = this.opts.getBundleBytes?.() ?? new Map();
+    const rows: EditableFunctionSummary[] = [];
+    for (const name of [...names].sort((a, b) => a.localeCompare(b))) {
+      const overlay = this.index.functions.find((e) => e.name === name);
+      const origin: EditableFunctionOrigin = overlay?.origin ?? "manifest";
+      const source = overlay ? "overlay" : await this.detectBaseSource(name);
+      rows.push({
+        name,
+        origin,
+        files: overlay?.files.length ? overlay.files : await this.baseFileList(name),
+        manifest: overlay ? await this.readOverlayManifest(name) : this.baseManifest(name),
+        bundleBytes: bundleBytes.get(name) ?? null,
+        source,
+        degraded: source === "bundle" || source === "missing",
+      });
+    }
+    return rows;
+  }
+
+  async read(name: string, baseNames: ReadonlySet<string>): Promise<EditableSourceResponse> {
+    await this.load();
+    name = safeName(name);
+    const overlay = this.index.functions.find((e) => e.name === name);
+    if (overlay) {
+      const files = await this.readOverlayFiles(name, overlay.files);
+      return {
+        name,
+        origin: overlay.origin,
+        files,
+        selected: files.find((f) => f.path === "index.ts")?.path ?? files[0]?.path ?? "index.ts",
+        degraded: false,
+      };
+    }
+    if (!baseNames.has(name)) throw new Error(`function "${name}" does not exist`);
+    return await this.readBaseSource(name);
+  }
+
+  async create(name: string): Promise<EditableSourceResponse> {
+    await this.load();
+    name = safeName(name);
+    if (this.index.functions.some((e) => e.name === name)) {
+      throw new Error(`function "${name}" already has a runtime override`);
+    }
+    const baseNames = new Set(this.opts.getPrebuiltManifest?.()?.functions.map((f) => f.name) ?? []);
+    if (baseNames.has(name)) {
+      throw new Error(`function "${name}" exists in firmware; open Code and save a patch instead`);
+    }
+    await this.writeFiles(name, {
+      "index.ts": [
+        "export default async function handler(req: Request): Promise<Response> {",
+        "  const body = req.method === \"GET\" ? null : await req.text();",
+        "  return Response.json({ ok: true, method: req.method, body });",
+        "}",
+        "",
+      ].join("\n"),
+      [MANIFEST_FILENAME]: JSON.stringify(defaultManifestForFile(), null, 2) + "\n",
+    });
+    await this.upsertIndex({ name, origin: "added", updatedAt: new Date().toISOString(), files: await listFiles(this.fnDir(name)) });
+    return await this.read(name, new Set());
+  }
+
+  async save(name: string, input: SaveEditableSourceInput, baseNames: ReadonlySet<string>): Promise<RuntimeOverrideEntry> {
+    await this.load();
+    name = safeName(name);
+    const existsInBase = baseNames.has(name);
+    const current = this.index.functions.find((e) => e.name === name);
+    if (!existsInBase && current?.origin !== "added") {
+      throw new Error(`function "${name}" is not in firmware; create it first`);
+    }
+    const files: Record<string, string> = {};
+    for (const [rawPath, content] of Object.entries(input.files ?? {})) {
+      files[safeRelPath(rawPath)] = String(content ?? "");
+    }
+    if (!files["index.ts"] && !files["index.js"]) {
+      throw new Error(`runtime function "${name}" must include index.ts or index.js`);
+    }
+    if (!files[MANIFEST_FILENAME]) {
+      files[MANIFEST_FILENAME] = JSON.stringify(defaultManifestForFile(), null, 2) + "\n";
+    }
+    await this.writeFiles(name, files);
+    const entry: RuntimeOverrideEntry = {
+      name,
+      origin: existsInBase ? "patched" : "added",
+      updatedAt: new Date().toISOString(),
+      files: await listFiles(this.fnDir(name)),
+    };
+    await this.upsertIndex(entry);
+    return entry;
+  }
+
+  async deleteAdded(name: string): Promise<void> {
+    await this.load();
+    name = safeName(name);
+    const entry = this.index.functions.find((e) => e.name === name);
+    if (!entry) return;
+    if (entry.origin !== "added") {
+      throw new Error(`function "${name}" is from firmware; use revert instead`);
+    }
+    await removeDirIfExists(this.fnDir(name));
+    this.index.functions = this.index.functions.filter((e) => e.name !== name);
+    await this.persist();
+  }
+
+  async revert(name: string): Promise<void> {
+    await this.load();
+    name = safeName(name);
+    const entry = this.index.functions.find((e) => e.name === name);
+    if (!entry) return;
+    if (entry.origin !== "patched") {
+      throw new Error(`function "${name}" is runtime-added; delete it instead`);
+    }
+    await removeDirIfExists(this.fnDir(name));
+    this.index.functions = this.index.functions.filter((e) => e.name !== name);
+    await this.persist();
+  }
+
+  async compose(baseNames: ReadonlySet<string>): Promise<OverlayComposeEntry[]> {
+    await this.load();
+    const out: OverlayComposeEntry[] = [];
+    for (const entry of this.index.functions) {
+      if (entry.origin === "patched" && !baseNames.has(entry.name)) {
+        entry.origin = "added";
+      }
+      const dir = this.fnDir(entry.name);
+      const entrypoint = await this.resolveEntrypoint(dir);
+      out.push({
+        name: entry.name,
+        origin: entry.origin,
+        sourceDir: dir,
+        entrypoint,
+        manifest: await this.readOverlayManifest(entry.name),
+        files: await listFiles(dir),
+      });
+    }
+    await this.persist();
+    return out.sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  private async persist(): Promise<void> {
+    await ensureDir(this.rootDir);
+    this.index.functions.sort((a, b) => a.name.localeCompare(b.name));
+    await Deno.writeTextFile(this.indexPath, JSON.stringify(this.index, null, 2) + "\n");
+  }
+
+  private async upsertIndex(entry: RuntimeOverrideEntry): Promise<void> {
+    this.index.functions = this.index.functions.filter((e) => e.name !== entry.name);
+    this.index.functions.push(entry);
+    await this.persist();
+  }
+
+  private fnDir(name: string): string {
+    return join(this.functionsRoot, safeName(name));
+  }
+
+  private async writeFiles(name: string, files: Record<string, string>): Promise<void> {
+    const dir = this.fnDir(name);
+    await removeDirIfExists(dir);
+    await ensureDir(dir);
+    for (const [path, content] of Object.entries(files)) {
+      const rel = safeRelPath(path);
+      const abs = normalize(join(dir, rel));
+      if (!abs.startsWith(dir)) throw new Error(`source path escapes function dir: ${rel}`);
+      await ensureDir(dirname(abs));
+      await Deno.writeTextFile(abs, content);
+    }
+  }
+
+  private async readOverlayManifest(name: string): Promise<FunctionManifest> {
+    return parseManifestText(await readTextIfExists(join(this.fnDir(name), MANIFEST_FILENAME)));
+  }
+
+  private async readOverlayFiles(name: string, paths: string[]): Promise<EditableSourceFile[]> {
+    const dir = this.fnDir(name);
+    const listed = paths.length ? paths : await listFiles(dir);
+    const files: EditableSourceFile[] = [];
+    for (const path of listed) {
+      files.push({
+        path,
+        content: await Deno.readTextFile(join(dir, safeRelPath(path))),
+        language: langFor(path),
+      });
+    }
+    return files.sort((a, b) => sourceSortKey(a.path).localeCompare(sourceSortKey(b.path)));
+  }
+
+  private baseManifest(name: string): FunctionManifest {
+    const prebuilt = this.opts.getPrebuiltManifest?.();
+    const fromPrebuilt = prebuilt?.functions.find((f) => f.name === name)?.manifest;
+    if (fromPrebuilt) return fromPrebuilt;
+    return this.opts.getLiveManifests?.()?.get(name) ?? defaultManifest();
+  }
+
+  private async baseFileList(name: string): Promise<string[]> {
+    const sourceDir = join(this.opts.sourceFunctionsDir, name);
+    const files = await listFiles(sourceDir);
+    if (files.length > 0) return files;
+    return [MANIFEST_FILENAME, "index.ts"];
+  }
+
+  private async detectBaseSource(name: string): Promise<EditableFunctionSummary["source"]> {
+    const sourceDir = join(this.opts.sourceFunctionsDir, name);
+    if (await pathExists(join(sourceDir, "index.ts")) || await pathExists(join(sourceDir, "index.js"))) return "source-tree";
+    const source = await this.readPrebuiltSource(name);
+    return source.source;
+  }
+
+  private async readBaseSource(name: string): Promise<EditableSourceResponse> {
+    const sourceDir = join(this.opts.sourceFunctionsDir, name);
+    const sourceFiles = await listFiles(sourceDir);
+    if (sourceFiles.length > 0) {
+      const files: EditableSourceFile[] = [];
+      for (const path of sourceFiles) {
+        files.push({
+          path,
+          content: await Deno.readTextFile(join(sourceDir, path)),
+          language: langFor(path),
+        });
+      }
+      return {
+        name,
+        origin: "manifest",
+        files: files.sort((a, b) => sourceSortKey(a.path).localeCompare(sourceSortKey(b.path))),
+        selected: files.find((f) => f.path === "index.ts")?.path ?? files[0]?.path ?? "index.ts",
+        degraded: false,
+      };
+    }
+    const fallback = await this.readPrebuiltSource(name);
+    return {
+      name,
+      origin: "manifest",
+      files: fallback.files,
+      selected: fallback.files[0]?.path ?? "index.ts",
+      degraded: fallback.source === "bundle" || fallback.source === "missing",
+      warning: fallback.warning,
+    };
+  }
+
+  private async readPrebuiltSource(name: string): Promise<{
+    source: EditableFunctionSummary["source"];
+    files: EditableSourceFile[];
+    warning?: string;
+  }> {
+    const prebuilt = this.opts.getPrebuiltManifest?.();
+    const prebuiltDir = this.opts.prebuiltDir;
+    const entry = prebuilt?.functions.find((f) => f.name === name);
+    if (!entry || !prebuiltDir) {
+      return {
+        source: "missing",
+        files: [{ path: "index.ts", content: "", language: "typescript" }],
+        warning: "Source is not available for this firmware function.",
+      };
+    }
+    const snapshot = await this.readSourceSnapshot(name);
+    if (snapshot.length > 0) return { source: "snapshot", files: snapshot };
+
+    for (const moduleFile of entry.moduleFiles.length ? entry.moduleFiles : [entry.bundleFile]) {
+      const map = await readTextIfExists(join(prebuiltDir, `${moduleFile}.map`));
+      if (!map) continue;
+      const extracted = extractSourcesContent(map);
+      if (extracted.length > 0) return { source: "sourcemap", files: extracted };
+    }
+
+    const bundleFile = entry.moduleFiles[0] ?? entry.bundleFile;
+    const bundle = await readTextIfExists(join(prebuiltDir, bundleFile));
+    if (bundle !== null) {
+      return {
+        source: "bundle",
+        files: [{ path: basename(bundleFile), content: bundle, language: "javascript" }],
+        warning: "Authored source was not packaged with this firmware; showing emitted JS fallback.",
+      };
+    }
+    return {
+      source: "missing",
+      files: [{ path: "index.ts", content: "", language: "typescript" }],
+      warning: "Source is not available for this firmware function.",
+    };
+  }
+
+  private async readSourceSnapshot(name: string): Promise<EditableSourceFile[]> {
+    const prebuiltDir = this.opts.prebuiltDir;
+    if (!prebuiltDir) return [];
+    const snapshotDir = join(prebuiltDir, "sources", name);
+    const files = await listFiles(snapshotDir);
+    const out: EditableSourceFile[] = [];
+    for (const path of files) {
+      out.push({
+        path,
+        content: await Deno.readTextFile(join(snapshotDir, path)),
+        language: langFor(path),
+      });
+    }
+    return out.sort((a, b) => sourceSortKey(a.path).localeCompare(sourceSortKey(b.path)));
+  }
+
+  private async resolveEntrypoint(dir: string): Promise<string> {
+    const ts = join(dir, "index.ts");
+    if (await pathExists(ts)) return ts;
+    const js = join(dir, "index.js");
+    if (await pathExists(js)) return js;
+    throw new Error(`runtime override at ${dir} is missing index.ts or index.js`);
+  }
+}
+
+function extractSourcesContent(rawMap: string): EditableSourceFile[] {
+  try {
+    const map = JSON.parse(rawMap) as { sources?: unknown; sourcesContent?: unknown };
+    if (!Array.isArray(map.sources) || !Array.isArray(map.sourcesContent)) return [];
+    const files: EditableSourceFile[] = [];
+    for (let i = 0; i < map.sources.length; i++) {
+      const source = map.sources[i];
+      const content = map.sourcesContent[i];
+      if (typeof source !== "string" || typeof content !== "string") continue;
+      const name = source.replace(/^file:\/+/, "").replaceAll("\\", "/").split("/").filter(Boolean).pop() ?? `source-${i}.ts`;
+      files.push({
+        path: safeRelPath(name),
+        content,
+        language: langFor(name),
+      });
+    }
+    return files.sort((a, b) => sourceSortKey(a.path).localeCompare(sourceSortKey(b.path)));
+  } catch {
+    return [];
+  }
+}
+
+function sourceSortKey(path: string): string {
+  if (path === "index.ts" || path === "index.js") return `0:${path}`;
+  if (path === MANIFEST_FILENAME) return `9:${path}`;
+  return `5:${path}`;
+}
+
+function defaultManifestForFile(): Record<string, unknown> {
+  const manifest = defaultManifest();
+  return {
+    permissions: manifest.permissions,
+    recycle: manifest.recycle,
+  };
+}
+
+export async function copyPrebuiltRuntimeFiles(prebuilt: PrebuiltManifest, prebuiltDir: string, cacheDir: string): Promise<void> {
+  await ensureDir(cacheDir);
+  const copied = new Set<string>();
+  async function copyRel(rel: string) {
+    const safe = safeRelPath(rel);
+    if (copied.has(safe)) return;
+    copied.add(safe);
+    const from = join(prebuiltDir, safe);
+    const to = join(cacheDir, safe);
+    await ensureDir(dirname(to));
+    const content = await Deno.readFile(from);
+    await Deno.writeFile(to, content);
+  }
+  for (const fn of prebuilt.functions) {
+    await copyRel(fn.bundleFile);
+    for (const moduleFile of fn.moduleFiles) await copyRel(moduleFile);
+  }
+  for (const chunk of prebuilt.chunks) await copyRel(chunk.file);
+  for (const shared of prebuilt.sharedModules) await copyRel(shared.bundleFile);
+}
+
+export async function readTextDigestFile(path: string): Promise<{ bytes: number; sha256: string }> {
+  const data = await Deno.readFile(path);
+  const digest = await crypto.subtle.digest("SHA-256", data as BufferSource);
+  return {
+    bytes: data.byteLength,
+    sha256: Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join(""),
+  };
+}
+
+export async function sourceFingerprint(files: readonly EditableSourceFile[]): Promise<string> {
+  const canonical = files
+    .map((f) => `${safeRelPath(f.path)}\0${f.content}`)
+    .sort()
+    .join("\0");
+  return await hashSha256Hex(canonical);
+}

package/src/cli/build.ts

@@ -32,7 +32,7 @@
  */
 
 import { ensureDir } from "jsr:@std/fs@^1/ensure-dir";
-import { isAbsolute, join, resolve as resolvePath } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve as resolvePath } from "node:path";
 import {
   bundleAllChunked,
   bundleSharedModule,
@@ -146,6 +146,37 @@ async function sha256Hex(bytes: Uint8Array): Promise<string> {
   return out;
 }
 
+async function copySourceSnapshot(functionsDir: string, name: string, outDir: string): Promise<string[]> {
+  const sourceRoot = join(functionsDir, name);
+  const outRoot = join(outDir, "sources", name);
+  const files: string[] = [];
+  async function walk(dir: string): Promise<void> {
+    for await (const entry of Deno.readDir(dir)) {
+      if (entry.name === "node_modules" || entry.name === ".git") continue;
+      const abs = join(dir, entry.name);
+      if (entry.isDirectory) {
+        await walk(abs);
+      } else if (entry.isFile) {
+        const rel = relative(sourceRoot, abs).replaceAll("\\", "/");
+        files.push(rel);
+        const dest = join(outRoot, rel);
+        await ensureDir(dirname(dest));
+        await Deno.copyFile(abs, dest);
+      }
+    }
+  }
+  await walk(sourceRoot);
+  return files.sort((a, b) => a.localeCompare(b));
+}
+
+async function removeDirIfExists(path: string): Promise<void> {
+  try {
+    await Deno.remove(path, { recursive: true });
+  } catch (err) {
+    if (!(err instanceof Deno.errors.NotFound)) throw err;
+  }
+}
+
 /**
  * Build every function under `functionsDir` into `outDir`. Idempotent
  * w.r.t. the on-disk artifact — running twice with the same inputs
@@ -180,6 +211,7 @@ async function buildOnce(opts: BuildOptions): Promise<BuildResult> {
   }
 
   await ensureDir(outDir);
+  await removeDirIfExists(join(outDir, "sources"));
 
   // Bundles live under `dist/functions/` to mirror the `.1tube`
   // firmware payload layout. Manifest stays at `dist/manifest.json`
@@ -274,6 +306,7 @@ async function buildOnce(opts: BuildOptions): Promise<BuildResult> {
       const bytes = await Deno.readFile(r.bundlePath);
       const sha = await sha256Hex(bytes);
       const manifest = await loadManifest(functionsDir, r.name);
+      const sourceFiles = await copySourceSnapshot(functionsDir, r.name, outDir);
       opts.onProgress?.({
         phase: "hash-function",
         current: idx + 1,
@@ -296,6 +329,7 @@ async function buildOnce(opts: BuildOptions): Promise<BuildResult> {
         bundleSha256: sha,
         moduleFiles: chunkedFn?.moduleFiles ?? [bundleFile],
         manifest,
+        sourceFiles,
       };
     }),
   );

package/src/cli/package.ts

@@ -242,6 +242,21 @@ async function collectDistFiles(
     if (!(err instanceof Deno.errors.NotFound)) throw err;
   }
 
+  for (const fn of manifest.functions) {
+    for (const sourceFile of fn.sourceFiles ?? []) {
+      const src = join(distDir, "sources", fn.name, sourceFile);
+      try {
+        const fileStat = await Deno.stat(src);
+        if (fileStat.isFile) {
+          const rel = `sources/${fn.name}/${sourceFile}`.replace(/\\/g, "/");
+          plan.push({ src, zipPath: `dist/${rel}`, size: fileStat.size });
+        }
+      } catch (err) {
+        if (!(err instanceof Deno.errors.NotFound)) throw err;
+      }
+    }
+  }
+
   const plannedZipPaths = new Set(plan.map((p) => p.zipPath));
   for (const fn of manifest.functions) {
     const expected = `dist/${fn.bundleFile}`;

package/src/server.ts

@@ -16,7 +16,7 @@
 // cleanly when launched from a host project's node_modules — bare
 // specifiers would otherwise require the host's deno.json to mirror our
 // import map. Same convention applies to every src/ file.
-import { Hono } from "npm:hono@4";
+import { Hono, type Context } from "npm:hono@4";
 import { bodyLimit } from "npm:hono@4/body-limit";
 import { relative, sep as SEPARATOR } from "node:path";
 import { currentRequestStorage, FunctionRegistry } from "./registry.ts";
@@ -149,6 +149,12 @@ interface CliOpts {
    * Off by default — workerd uses V8's defaults.
    */
   workerdMaxHeapMB?: number;
+  /** Workerd compatibility date passed to generated config.capnp files. */
+  workerdCompatibilityDate?: string;
+  /** Workerd compatibility flags passed to generated config.capnp files. */
+  workerdCompatibilityFlags?: readonly string[];
+  /** Pass `--experimental` to the workerd process itself. */
+  workerdExperimental?: boolean;
   /**
    * Path to a `1tube build`-produced artifact directory. When set,
    * the workerd backend skips esbuild entirely and serves the
@@ -219,6 +225,12 @@ function parseArgs(): CliOpts {
     const n = parseInt(v, 10);
     return Number.isFinite(n) && n > 0 ? n : undefined;
   })();
+  let workerdCompatibilityDate: string | undefined = Deno.env.get("1TUBE_WORKERD_COMPAT_DATE") || undefined;
+  const workerdCompatibilityFlags: string[] = (Deno.env.get("1TUBE_WORKERD_COMPAT_FLAGS") ?? "")
+    .split(",")
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);
+  let workerdExperimental = envFlag("1TUBE_WORKERD_EXPERIMENTAL");
   let port = parseInt(Deno.env.get("PORT") || "3100", 10);
   let host = (Deno.env.get("1TUBE_HOST") || "127.0.0.1").trim();
   let functionsPath = Deno.env.get("FUNCTIONS_PATH") || "./supabase/functions";
@@ -302,6 +314,18 @@ function parseArgs(): CliOpts {
     } else if (a.startsWith("--workerd-max-heap-mb=")) {
       const n = parseInt(a.slice("--workerd-max-heap-mb=".length), 10);
       if (Number.isFinite(n) && n > 0) workerdMaxHeapMB = n;
+    } else if (a === "--compat-date" && args[i + 1]) {
+      workerdCompatibilityDate = args[++i];
+    } else if (a.startsWith("--compat-date=")) {
+      workerdCompatibilityDate = a.slice("--compat-date=".length);
+    } else if (a === "--compat-flag" && args[i + 1]) {
+      workerdCompatibilityFlags.push(args[++i]);
+    } else if (a.startsWith("--compat-flag=")) {
+      workerdCompatibilityFlags.push(a.slice("--compat-flag=".length));
+    } else if (a === "--workerd-experimental" || a === "--workerd-experimental=true") {
+      workerdExperimental = true;
+    } else if (a === "--workerd-experimental=false" || a === "--no-workerd-experimental") {
+      workerdExperimental = false;
     } else if (a === "--kill-stale-workerd" || a === "--kill-stale-workerd=true") {
       // Boolean flag — accept both bare-flag and explicit `=true` forms
       // so we don't surprise scripts that programmatically generate
@@ -348,6 +372,9 @@ function parseArgs(): CliOpts {
     workerdBasePort,
     workerdInspector,
     workerdMaxHeapMB,
+    workerdCompatibilityDate,
+    workerdCompatibilityFlags,
+    workerdExperimental,
     killStaleWorkerd,
     prebuiltDir,
   };
@@ -424,6 +451,17 @@ function enforceProdSecrets() {
 const opts = parseArgs();
 const internalKey = Deno.env.get("INTERNAL_KEY")?.trim() || undefined;
 
+function isInternalRequest(req: Request): boolean {
+  if (!internalKey) return false;
+  const header = req.headers.get("Authorization");
+  const match = header?.match(/^Bearer\s+(.+)$/i);
+  return match?.[1]?.trim() === internalKey;
+}
+
+function requireInternal(c: Context): Response | null {
+  return isInternalRequest(c.req.raw) ? null : c.json({ error: "Forbidden" }, 403);
+}
+
 if (opts.dev) {
   applyDevDefaults();
 } else {
@@ -703,6 +741,15 @@ if (opts.backend === "workerd") {
       `[1tube] auto-kill leftover workerd: ON (--kill-stale-workerd)`,
     );
   }
+  if (opts.workerdCompatibilityDate || (opts.workerdCompatibilityFlags?.length ?? 0) > 0) {
+    console.log(
+      `[1tube] workerd compatibility: date=${opts.workerdCompatibilityDate ?? "default"} ` +
+        `flags=${(opts.workerdCompatibilityFlags ?? []).join(",") || "default"}`,
+    );
+  }
+  if (opts.workerdExperimental) {
+    console.log(`[1tube] workerd process experimental mode: ON (--experimental)`);
+  }
   workerdBackend = createWorkerdBackend({
     functionsDir: opts.functionsPath,
     // The bundler resolves npm: / jsr: / https: specifiers via Deno's
@@ -716,6 +763,11 @@ if (opts.backend === "workerd") {
     ...(opts.workerdBasePort ? { basePort: opts.workerdBasePort } : {}),
     ...(opts.workerdInspector ? { inspectorAddr: opts.workerdInspector } : {}),
     ...(opts.workerdMaxHeapMB ? { maxHeapMB: opts.workerdMaxHeapMB } : {}),
+    ...(opts.workerdCompatibilityDate ? { compatibilityDate: opts.workerdCompatibilityDate } : {}),
+    ...((opts.workerdCompatibilityFlags?.length ?? 0) > 0
+      ? { compatibilityFlags: opts.workerdCompatibilityFlags }
+      : {}),
+    ...(opts.workerdExperimental ? { experimental: true } : {}),
     ...(opts.killStaleWorkerd ? { killStaleWorkerd: true } : {}),
     ...(opts.prebuiltDir ? { prebuiltDir: opts.prebuiltDir } : {}),
     sourcemap: opts.dev ? "inline" : "linked",
@@ -1307,6 +1359,69 @@ app.get(
   }),
 );
 
+async function runFunctionAdmin(c: Context, action: (backend: WorkerdBackend) => Promise<Response>): Promise<Response> {
+  const forbidden = requireInternal(c);
+  if (forbidden) return forbidden;
+  if (!workerdBackend) {
+    return c.json({ error: "Edge function editor is available only with backend=workerd" }, 503);
+  }
+  try {
+    return await action(workerdBackend);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ error: message }, 400);
+  }
+}
+
+app.get("/1tube/api/functions", (c) =>
+  runFunctionAdmin(c, async (backend) => c.json({
+    functions: await backend.listEditableFunctions(),
+  }))
+);
+
+app.get("/1tube/api/functions/:name/source", (c) =>
+  runFunctionAdmin(c, async (backend) => c.json(await backend.readEditableSource(c.req.param("name"))))
+);
+
+app.post("/1tube/api/functions", (c) =>
+  runFunctionAdmin(c, async (backend) => {
+    const body = await c.req.json().catch(() => ({})) as { name?: unknown };
+    if (typeof body.name !== "string" || body.name.trim().length === 0) {
+      return c.json({ error: "Missing function name" }, 400);
+    }
+    const source = await backend.createEditableFunction(body.name);
+    return c.json({ source, functions: await backend.listEditableFunctions() }, 201);
+  })
+);
+
+app.put("/1tube/api/functions/:name/source", (c) =>
+  runFunctionAdmin(c, async (backend) => {
+    const body = await c.req.json().catch(() => ({})) as { files?: unknown };
+    if (!body.files || typeof body.files !== "object" || Array.isArray(body.files)) {
+      return c.json({ error: "Expected JSON body { files: { path: content } }" }, 400);
+    }
+    const reload = await backend.saveEditableSource(
+      c.req.param("name"),
+      { files: body.files as Record<string, string> },
+    );
+    return c.json({ reload, functions: await backend.listEditableFunctions() });
+  })
+);
+
+app.delete("/1tube/api/functions/:name", (c) =>
+  runFunctionAdmin(c, async (backend) => {
+    const reload = await backend.deleteEditableFunction(c.req.param("name"));
+    return c.json({ reload, functions: await backend.listEditableFunctions() });
+  })
+);
+
+app.post("/1tube/api/functions/:name/revert", (c) =>
+  runFunctionAdmin(c, async (backend) => {
+    const reload = await backend.revertEditableFunction(c.req.param("name"));
+    return c.json({ reload, functions: await backend.listEditableFunctions() });
+  })
+);
+
 // Root liveness probe — intentionally minimal so we don't leak the registered
 // function count or endpoint map to unauthenticated callers.
 app.get("/", (c) => c.json({ status: "ok" }));