@mediamonks/canopy-cli 0.7.42 → 0.7.43

package/dist/{src-RUf3Gfuh.mjs → src-CScXotBB.mjs}

@@ -839,7 +839,7 @@ function realtimeRouter(config) {
 * How a project's backend addresses the platform — the one definition.
 *
 * Three hosts run project workers and each builds this request itself: the
-* Workers-for-Platforms shim (apps/api/src/platform/wfp-shim.ts), the Node
+* Workers-for-Platforms shim (packages/data-plane/src/worker-shim.ts), the Node
 * runtime (apps/project-runtime/src/canopy-fetch.ts), and `canopy dev`
 * (packages/cli/src/dev-worker.ts). They had three copies of the header
 * shaping, and the two that hold a worker token had two copies of the
@@ -931,5 +931,731 @@ function stampWorkerHeaders(headers, ctx) {
 	else headers.delete("x-canopy-channel");
 	return headers;
 }
+String.raw`// Canopy Workers-for-Platforms shim (generated by canopy-api — do not edit).
+import { AsyncLocalStorage } from "node:async_hooks";
+import worker from "./bundle.mjs";
+
+// Platform bindings the user env gets wrapped rather than raw. Hiding them is
+// tidiness, not protection: each is the project's own or scoped outside this
+// isolate (see the header).
+const INTERNAL_KEYS = new Set(["__CANOPY_DB", "__CANOPY_BLOB", "__CANOPY_API_URL", "__CANOPY_GATEWAY"]);
+
+// The sealed credential the gateway put on the inbound request in place of
+// the visitor's Canopy cookies / agent token. Only ProjectGateway opens it.
+const CREDENTIAL_HANDLE_HEADER = "x-canopy-credential-handle";
+
+// Workers Logs flattens console args and drops an Error's message line —
+// log the stack as a plain string (its first line is "Error: <message>") so
+// the entry matches what Node's console shows on GCP.
+function describeError(err) {
+  return err && err.stack ? String(err.stack) : String(err);
+}
+
+// Transcribed from IDENTITY_STAMP_HEADERS in @mediamonks/canopy-data-plane.
+const IDENTITY_STAMP_HEADERS = [
+  "x-canopy-user-sub",
+  "x-canopy-user-email",
+  "x-canopy-user-name",
+  "x-canopy-identity-kind",
+  "x-canopy-identity-id",
+  "x-canopy-identity-email",
+  "x-canopy-identity-name",
+];
+
+function userFromHeaders(headers) {
+  const sub = (headers.get("x-canopy-user-sub") || "").trim();
+  if (!sub) return null;
+  return {
+    sub,
+    email: (headers.get("x-canopy-user-email") || "").trim(),
+    name: (headers.get("x-canopy-user-name") || "").trim(),
+  };
+}
+
+// env.CALLER (worker-caller-identity) — transcribed from
+// project-runtime/src/user.ts: everyone the wall let through, client-password
+// visitors included, from headers older shims never read.
+function callerFromHeaders(headers) {
+  const kind = (headers.get("x-canopy-identity-kind") || "").trim();
+  const id = (headers.get("x-canopy-identity-id") || "").trim();
+  if ((kind !== "monk" && kind !== "external") || !id) return null;
+  return {
+    kind,
+    id,
+    email: (headers.get("x-canopy-identity-email") || "").trim(),
+    name: (headers.get("x-canopy-identity-name") || "").trim(),
+    agent: headers.get("x-canopy-caller") === "agent",
+  };
+}
+
+function callerFromUser(user) {
+  return user ? { kind: "monk", id: user.sub, email: user.email, name: user.name, agent: false } : null;
+}
+
+function rewriteCanopyUrl(raw, apiUrl) {
+  const base = apiUrl.replace(/\/$/, "");
+  let path;
+  let search = "";
+  try {
+    const u = new URL(raw, "http://canopy.local");
+    path = u.pathname;
+    search = u.search;
+  } catch {
+    path = raw.startsWith("/") ? raw : "/" + raw;
+  }
+  if (path.startsWith("/_api/")) path = path.slice("/_api".length);
+  // The data plane is the only plane a project may address (R-01): a
+  // /control/v1 path folds under /data/v1, where it 404s instead of running a
+  // control-plane call as whoever is visiting. isControlPlanePath refuses it
+  // before it gets here; this is the belt to that brace.
+  if (!path.startsWith("/data/v1/")) {
+    path = "/data/v1" + (path.startsWith("/") ? path : "/" + path);
+  }
+  return base + path + search;
+}
+
+// Whether a project asked for the control plane, which is never theirs to call.
+function isControlPlanePath(raw) {
+  let path;
+  try {
+    path = new URL(raw, "http://canopy.local").pathname;
+  } catch {
+    path = raw.startsWith("/") ? raw : "/" + raw;
+  }
+  if (path.startsWith("/_api/")) path = path.slice("/_api".length);
+  return path === "/control/v1" || path.startsWith("/control/v1/");
+}
+
+// Canopy's own cookies — platform credentials, never tenant-readable (R-01).
+const CANOPY_COOKIE_NAMES = ["canopy_session", "canopy_client", "canopy_agent"];
+
+// Strip Canopy's credentials from the request the bundle gets — a
+// transcription of redactCanopyCredentials in @mediamonks/canopy-data-plane,
+// plus the credential handle. A sealed backend's request carries no raw
+// credential to begin with (the gateway sealed it); this keeps ordinary code
+// from seeing even the handle. An app's own cookies and its own Authorization
+// scheme survive untouched.
+function redactCanopyCredentials(headers) {
+  const cookie = headers.get("cookie");
+  if (cookie !== null) {
+    const parts = cookie.split(";");
+    const kept = [];
+    for (const part of parts) {
+      const name = part.split("=")[0].trim();
+      if (name !== "" && CANOPY_COOKIE_NAMES.indexOf(name) === -1) kept.push(part);
+    }
+    const rest = kept.join(";").trim();
+    if (rest === "") headers.delete("cookie");
+    else headers.set("cookie", rest);
+  }
+  const auth = headers.get("authorization");
+  if (auth && auth.startsWith("Bearer cnpy_")) headers.delete("authorization");
+  // A tools call's agent token (docs/49) is a credential like the cookie.
+  headers.delete("x-canopy-agent-credential");
+  headers.delete(CREDENTIAL_HANDLE_HEADER);
+  return headers;
+}
+
+// upstream is the __CANOPY_GATEWAY service binding to the gateway's
+// ProjectGateway entrypoint: a plain fetch to the api host would be a
+// same-zone subrequest, which Cloudflare sends to the zone's origin (a dummy A
+// record) instead of back into the gateway. The global-fetch fallback only
+// exists for hosts without the binding (tests).
+//
+// The entrypoint does the rest from props canopy-api set at upload: forces
+// the project and channel, refuses anything but /data/v1, opens the handle
+// and applies the one credential rule (applyWorkerCredentials) with the
+// worker token, which is never in this isolate. All this side sends is the
+// call, the handle the request arrived with, and its traceparent.
+function createCanopyFetch(apiUrl, inboundHeaders, upstream) {
+  const fetchImpl =
+    upstream && typeof upstream.fetch === "function" ? upstream.fetch.bind(upstream) : fetch;
+  return async (input, init) => {
+    const rawUrl =
+      typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    if (isControlPlanePath(rawUrl)) {
+      return new Response(
+        JSON.stringify({
+          error: "control_plane_forbidden",
+          detail:
+            "env.CANOPY.fetch reaches the data plane only — /control/v1 is not available to project code",
+        }),
+        { status: 403, headers: { "content-type": "application/json" } },
+      );
+    }
+    const url = rewriteCanopyUrl(rawUrl, apiUrl);
+
+    const headers = new Headers(input instanceof Request ? input.headers : init && init.headers);
+    headers.delete("host");
+    // Identity stamps are for the worker env only — never relay to canopy-api.
+    for (const name of IDENTITY_STAMP_HEADERS) headers.delete(name);
+    // Credentials are the platform's to choose, from the handle alone; nothing
+    // the bundle sets here is ever one.
+    headers.delete("cookie");
+    headers.delete("authorization");
+    headers.delete("x-canopy-agent-credential");
+    headers.delete("x-canopy-worker-attest");
+    const handle = inboundHeaders.get(CREDENTIAL_HANDLE_HEADER);
+    if (handle) headers.set(CREDENTIAL_HANDLE_HEADER, handle);
+    else headers.delete(CREDENTIAL_HANDLE_HEADER);
+    // Trace continuity (docs/42 §3.1): the inbound platform traceparent wins;
+    // the bundle never supplies one.
+    const traceparent = inboundHeaders.get("traceparent");
+    if (traceparent) headers.set("traceparent", traceparent);
+    else headers.delete("traceparent");
+
+    const method = (input instanceof Request ? input.method : init && init.method) || "GET";
+    const body = input instanceof Request ? input.body : init && init.body;
+    const outbound = {
+      method,
+      headers,
+      body: body || undefined,
+      redirect: input instanceof Request ? input.redirect : init && init.redirect,
+    };
+    if (body) outbound.duplex = "half";
+    return fetchImpl(url, outbound);
+  };
+}
+
+// env.DB — one query() contract on every host. The dialect field mirrors
+// canopy.db.dialect() (D15): raw SQL is the target's own. D1 carries no
+// dialect, so it reads as sqlite; the Google Cloud runtime's binding says
+// postgres.
+function wrapDb(d1) {
+  if (!d1) return null;
+  return {
+    dialect: d1.dialect || "sqlite",
+    async query(text, params) {
+      const res = await d1
+        .prepare(text)
+        .bind(...(params || []))
+        .all();
+      const rows = res.results || [];
+      const changes = res.meta && typeof res.meta.changes === "number" ? res.meta.changes : 0;
+      // pg parity: returned rows for reads, affected rows for writes.
+      return { rows, rowCount: rows.length > 0 ? rows.length : changes };
+    },
+  };
+}
+
+// Collapse traversal/empty segments and pin the key under the prefix
+// (port of project-runtime/src/blob.ts normalizeBlobKey).
+function normalizeBlobKey(prefix, key) {
+  const cleaned = String(key)
+    .replace(/\\/g, "/")
+    .split("/")
+    .filter((part) => part && part !== "." && part !== "..")
+    .join("/");
+  return prefix + cleaned;
+}
+
+// env.BLOB — the channel's own bucket, every key forced under the channel's
+// prefix so keys keep the shape the platform's blob routes use. The bucket
+// holds nothing but this channel's objects, so the raw binding is no prize.
+function wrapBlob(bucket, prefix) {
+  if (!bucket) return null;
+  return {
+    prefix,
+    async put(key, body, contentType) {
+      await bucket.put(
+        normalizeBlobKey(prefix, key),
+        body,
+        contentType ? { httpMetadata: { contentType } } : undefined,
+      );
+    },
+    async get(key) {
+      const object = await bucket.get(normalizeBlobKey(prefix, key));
+      if (!object) return null;
+      const body = new Uint8Array(await object.arrayBuffer());
+      const contentType = object.httpMetadata && object.httpMetadata.contentType;
+      return contentType ? { body, contentType } : { body };
+    },
+    async list(sub) {
+      const full = sub ? normalizeBlobKey(prefix, sub) : prefix;
+      const out = [];
+      let cursor;
+      do {
+        const page = await bucket.list({ prefix: full, cursor });
+        for (const object of page.objects) {
+          out.push({ key: object.key.slice(prefix.length), size: object.size });
+        }
+        cursor = page.truncated ? page.cursor : undefined;
+      } while (cursor);
+      return out;
+    },
+    async delete(key) {
+      await bucket.delete(normalizeBlobKey(prefix, key));
+    },
+  };
+}
+
+// --- Platform blob channel (POST /__canopy/blob) ----------------------------
+// The operation and key ride in headers so a put's body can stream straight
+// into the bucket; list and purge take a JSON body. Object metadata comes back
+// as JSON in x-canopy-blob-meta (get) or the body (head, list). Keys are the
+// bucket's own, untouched: the bucket holds this channel's objects only.
+
+const BLOB_MARKER = { "x-canopy-blob": "1" };
+const BLOB_PURGE_BATCH = 1000;
+
+function blobJson(body, status) {
+  return new Response(JSON.stringify(body), {
+    status: status || 200,
+    headers: { "content-type": "application/json", ...BLOB_MARKER },
+  });
+}
+
+function blobMeta(object) {
+  const md5 = object.checksums && object.checksums.md5;
+  return {
+    key: object.key,
+    size: object.size,
+    uploaded: object.uploaded instanceof Date ? object.uploaded.toISOString() : String(object.uploaded),
+    contentType: (object.httpMetadata && object.httpMetadata.contentType) || null,
+    md5: md5 ? btoa(String.fromCharCode(...new Uint8Array(md5))) : null,
+  };
+}
+
+async function handleBlobChannel(request, bucket) {
+  if (!bucket) return blobJson({ error: "no_bucket" }, 503);
+  const op = request.headers.get("x-canopy-blob-op") || "";
+  const key = request.headers.get("x-canopy-blob-key") || "";
+  try {
+    if (op === "get" || op === "head") {
+      const object = op === "get" ? await bucket.get(key) : await bucket.head(key);
+      if (!object) return blobJson({ error: "not_found" }, 404);
+      if (op === "head") return blobJson(blobMeta(object));
+      return new Response(object.body, {
+        headers: { "x-canopy-blob-meta": JSON.stringify(blobMeta(object)), ...BLOB_MARKER },
+      });
+    }
+    if (op === "put") {
+      const contentType = request.headers.get("x-canopy-blob-content-type");
+      await bucket.put(
+        key,
+        await request.arrayBuffer(),
+        contentType ? { httpMetadata: { contentType } } : undefined,
+      );
+      return blobJson({ ok: true });
+    }
+    if (op === "delete") {
+      await bucket.delete(key);
+      return blobJson({ ok: true });
+    }
+    if (op === "list") {
+      const params = await request.json().catch(() => ({}));
+      const page = await bucket.list({
+        prefix: typeof params.prefix === "string" ? params.prefix : undefined,
+        cursor: typeof params.cursor === "string" ? params.cursor : undefined,
+        include: ["httpMetadata"],
+      });
+      return blobJson({
+        objects: page.objects.map(blobMeta),
+        truncated: page.truncated,
+        cursor: page.truncated ? page.cursor : null,
+      });
+    }
+    if (op === "purge") {
+      // One page per call so a large bucket can't outrun a request's limits;
+      // the caller repeats while more remain.
+      const params = await request.json().catch(() => ({}));
+      const page = await bucket.list({
+        prefix: typeof params.prefix === "string" ? params.prefix : undefined,
+        limit: BLOB_PURGE_BATCH,
+      });
+      const keys = page.objects.map((o) => o.key);
+      if (keys.length > 0) await bucket.delete(keys);
+      return blobJson({ deleted: keys.length, more: page.truncated });
+    }
+    return blobJson({ error: "unknown_op" }, 400);
+  } catch (err) {
+    return blobJson(
+      { error: "blob_error", detail: err instanceof Error ? err.message : String(err) },
+      500,
+    );
+  }
+}
+
+// --- Self-fetch loopback (docs/27) -----------------------------------------
+// A worker fetching its own /api/* — the ported-Next.js BASE_URL idiom — is
+// re-entered in-process instead of leaving the isolate: outbound it would die
+// on the egress allowlist, and even allowed it would hit the auth wall with
+// no session. Identity rides AsyncLocalStorage per inbound request (never a
+// closure — the userland patch this replaces bled users across concurrent
+// requests). Transcribed from project-runtime/src/self-fetch.ts, which this
+// module cannot import (it ships standalone beside the bundle);
+// wfp-shim.test.ts and project-runtime's self-fetch.test.ts run matching
+// cases so the two can't drift silently.
+
+const SELF_FETCH_DEPTH_HEADER = "x-canopy-self-fetch-depth";
+const SELF_FETCH_MAX_DEPTH = 8;
+// Everything that says who is calling (CALLER_IDENTITY_HEADERS in
+// project-runtime/src/user.ts): the user and caller stamps plus the agent mark.
+const IDENTITY_HEADERS = [...IDENTITY_STAMP_HEADERS, "x-canopy-caller"];
+
+const selfFetchContext = new AsyncLocalStorage();
+
+function isSelfApiPath(pathname) {
+  return pathname === "/api" || pathname.startsWith("/api/");
+}
+
+function identityHeaders(headers) {
+  const identity = new Headers();
+  for (const name of IDENTITY_HEADERS) {
+    const value = headers.get(name);
+    if (value) identity.set(name, value);
+  }
+  return identity;
+}
+
+function selfFetchDepth(headers) {
+  const depth = Number.parseInt(headers.get(SELF_FETCH_DEPTH_HEADER) || "", 10);
+  return Number.isInteger(depth) && depth > 0 ? depth : 0;
+}
+
+// Hostnames that are "self" for this worker: the channel's own public host
+// (live: <slug>.<domain> plus v<N>-dot-<slug> pinned hosts — a pin only
+// selects assets, /api/* still dispatches to the live worker; staging:
+// staging-dot-<slug> only — the plain host is a *different* backend), and
+// localhost/127.0.0.1 on any port, ported code's BASE_URL fallback. Derived
+// from the api host (api.<domain>) the shim already has as a binding.
+function createSelfHostMatcher(apiUrl, projectSlug, channel) {
+  let parentDomain = "";
+  try {
+    const apiHost = new URL(apiUrl).hostname;
+    parentDomain = apiHost.slice(apiHost.indexOf(".") + 1).toLowerCase();
+  } catch {
+    // No usable api host — only the localhost fallbacks match.
+  }
+  const slug = projectSlug.toLowerCase();
+  return (hostname) => {
+    const host = hostname.toLowerCase();
+    if (host === "localhost" || host === "127.0.0.1") return true;
+    if (!slug || !parentDomain || !host.endsWith("." + parentDomain)) return false;
+    const label = host.slice(0, host.length - parentDomain.length - 1);
+    if (label.includes(".")) return false;
+    if (channel === "staging") return label === "staging-dot-" + slug;
+    if (label === slug) return true;
+    const pinned = /^v\d+-dot-(.+)$/.exec(label);
+    return Boolean(pinned) && pinned[1] === slug;
+  };
+}
+
+function loopbackError(code, detail, status) {
+  return new Response(JSON.stringify({ error: code, detail }), {
+    status,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+let passthroughFetch = null;
+
+async function selfFetchInterceptor(input, init) {
+  const context = selfFetchContext.getStore();
+  if (context) {
+    let url = null;
+    try {
+      url =
+        typeof input === "string" ? new URL(input) : input instanceof URL ? input : new URL(input.url);
+    } catch {
+      // Relative URL — not a self-origin fetch; let the real fetch decide.
+    }
+    if (
+      url &&
+      (url.protocol === "http:" || url.protocol === "https:") &&
+      context.matchesSelf(url.hostname) &&
+      isSelfApiPath(url.pathname)
+    ) {
+      const depth = context.depth + 1;
+      if (depth > SELF_FETCH_MAX_DEPTH) {
+        console.error("self-fetch loop: " + url.pathname + " exceeded depth " + SELF_FETCH_MAX_DEPTH);
+        return loopbackError(
+          "self_fetch_loop",
+          "self-fetch recursion exceeded " + SELF_FETCH_MAX_DEPTH + " — /api routes are fetching each other in a cycle",
+          508,
+        );
+      }
+      // The caller's method/headers/body pass through; identity headers are
+      // overwritten from the tracked inbound context — same posture as the
+      // gateway, which never trusts a caller's own identity bag.
+      const request = new Request(input, init);
+      for (const name of IDENTITY_HEADERS) request.headers.delete(name);
+      for (const pair of context.identity) request.headers.set(pair[0], pair[1]);
+      request.headers.set(SELF_FETCH_DEPTH_HEADER, String(depth));
+      try {
+        return await invokeWorkerFetch(request, context.env, context.ctx);
+      } catch (err) {
+        // Over the network the caller would have seen the runtime's JSON 500,
+        // not a rejection — keep that shape for the in-process path.
+        console.error("self-fetch loopback failed: " + describeError(err));
+        return loopbackError("worker_error", err instanceof Error ? err.message : String(err), 500);
+      }
+    }
+  }
+  return (passthroughFetch || fetch)(input, init);
+}
+
+// Installed lazily and re-asserted per invocation: cheap (one comparison),
+// and it stays the outermost wrapper even if something else patched
+// globalThis.fetch after us. env.CANOPY.fetch rides the gateway service
+// binding, never global fetch, so it can't be shadowed by this.
+function ensureSelfFetchInterceptor() {
+  if (globalThis.fetch !== selfFetchInterceptor) {
+    passthroughFetch = globalThis.fetch.bind(globalThis);
+    globalThis.fetch = selfFetchInterceptor;
+  }
+}
+
+function runWithSelfFetchContext(env, ctx, identity, depth, credentials, fn) {
+  ensureSelfFetchInterceptor();
+  return selfFetchContext.run(
+    {
+      matchesSelf: createSelfHostMatcher(
+        env.__CANOPY_API_URL || "",
+        env.PROJECT_SLUG || "",
+        env.CANOPY_CHANNEL || "live",
+      ),
+      identity,
+      depth,
+      credentials,
+      env,
+      ctx,
+    },
+    fn,
+  );
+}
+
+function invokeWorkerFetch(request, env, ctx) {
+  // The inbound credential handle is for CANOPY.fetch, not the bundle (R-01):
+  // keep it for CANOPY.fetch and hand the bundle a copy without it. On a
+  // loopback the outermost request's handle is the one that counts — bundle
+  // code has none of its own to re-supply.
+  const existing = selfFetchContext.getStore();
+  const credentials = existing ? existing.credentials : new Headers(request.headers);
+  const userRequest = new Request(request);
+  redactCanopyCredentials(userRequest.headers);
+  return runWithSelfFetchContext(
+    env,
+    ctx,
+    identityHeaders(request.headers),
+    selfFetchDepth(request.headers),
+    credentials,
+    () => worker.fetch(userRequest, buildEnv(env, userRequest, credentials), ctx),
+  );
+}
+// ---------------------------------------------------------------------------
+
+// The request arg is the redacted copy the bundle sees; inboundHeaders carries
+// the credential handle CANOPY.fetch relays (R-01, wfp-binding-isolation).
+function buildEnv(env, request, inboundHeaders) {
+  const out = {};
+  for (const key of Object.keys(env)) {
+    if (!INTERNAL_KEYS.has(key)) out[key] = env[key];
+  }
+  const apiUrl = env.__CANOPY_API_URL || "";
+  const slug = env.PROJECT_SLUG || "";
+  // Every deploy binds BLOB_PREFIX with __CANOPY_BLOB; no prefix, no blob
+  // (the db-only shim has neither). Never derived from the slug: it can change.
+  const blobPrefix = env.BLOB_PREFIX || "";
+  out.CANOPY = { fetch: createCanopyFetch(apiUrl, inboundHeaders, env.__CANOPY_GATEWAY) };
+  out.DB = wrapDb(env.__CANOPY_DB);
+  out.BLOB = blobPrefix ? wrapBlob(env.__CANOPY_BLOB, blobPrefix) : null;
+  // Verified monk identity from the gateway; null for cron / anonymous.
+  out.USER = userFromHeaders(request.headers);
+  // Everyone the gateway let through, client-password visitors included.
+  out.CALLER = callerFromHeaders(request.headers);
+  out.PROJECT_SLUG = slug;
+  out.BLOB_PREFIX = blobPrefix;
+  return out;
+}
+
+export default {
+  async fetch(request, env, ctx) {
+    const url = new URL(request.url);
+
+    if (url.pathname === "/__canopy/health") {
+      return Response.json({
+        ok: true,
+        service: "canopy-wfp-shim",
+        project: env.PROJECT_SLUG || "",
+        scheduled: typeof worker.scheduled === "function",
+        slack: typeof worker.slack === "function",
+      });
+    }
+
+    // Slack traffic for the project's own app (docs/33 §6), delivered by
+    // canopy-api through the dispatch binding after signature verification.
+    // Kept in lockstep with the twin branch in project-runtime/src/loader.ts.
+    // Platform database channel (docs/43 §5.5): canopy-data runs the project's
+    // SDK statements through THIS script's own D1 binding instead of the REST
+    // API — a dispatch hop plus a binding call, not an HTTPS round trip to
+    // api.cloudflare.com. Reachable only through the DISPATCH binding (the
+    // gateway forwards /api/* alone), and the raw binding never leaves this
+    // closure: the bundle still sees only env.DB. The marker header lets the
+    // caller tell this route apart from a bundle that answered the same path
+    // under an older shim, which never saw it.
+    if (url.pathname === "/__canopy/db" && request.method === "POST") {
+      const dbHeaders = { "content-type": "application/json", "x-canopy-db": "1" };
+      const d1 = env.__CANOPY_DB;
+      if (!d1) {
+        return new Response(JSON.stringify({ error: "no_database" }), {
+          status: 503,
+          headers: dbHeaders,
+        });
+      }
+      let body;
+      try {
+        body = await request.json();
+      } catch {
+        body = null;
+      }
+      const statements = body && Array.isArray(body.statements) ? body.statements : null;
+      const sql = body && typeof body.sql === "string" ? body.sql : null;
+      if (!statements && !sql) {
+        return new Response(JSON.stringify({ error: "invalid_body" }), {
+          status: 400,
+          headers: dbHeaders,
+        });
+      }
+      try {
+        let res;
+        if (statements) {
+          // One D1 batch: atomic, one round trip — the doc-store DDL, a reset.
+          const batch = await d1.batch(statements.map((s) => d1.prepare(s)));
+          res = batch[batch.length - 1] || { results: [], meta: {} };
+        } else {
+          res = await d1
+            .prepare(sql)
+            .bind(...(Array.isArray(body.params) ? body.params : []))
+            .all();
+        }
+        const changes = res.meta && typeof res.meta.changes === "number" ? res.meta.changes : 0;
+        return new Response(JSON.stringify({ results: res.results || [], meta: { changes } }), {
+          headers: dbHeaders,
+        });
+      } catch (err) {
+        return new Response(
+          JSON.stringify({ error: "sql_error", detail: err instanceof Error ? err.message : String(err) }),
+          { status: 400, headers: dbHeaders },
+        );
+      }
+    }
+    // Platform blob channel (wfp-binding-isolation): each channel's blobs live
+    // in a bucket of its own that only this script binds, so canopy-data and
+    // canopy-api reach them through here — the SDK and browser blob module,
+    // signed downloads, usage, teardown. Dispatch-only like /__canopy/db; the
+    // marker header tells this route apart from a bundle answering the path.
+    if (url.pathname === "/__canopy/blob" && request.method === "POST") {
+      return handleBlobChannel(request, env.__CANOPY_BLOB);
+    }
+    if (url.pathname === "/__canopy/slack" && request.method === "POST") {
+      if (typeof worker.slack !== "function") {
+        return Response.json(
+          { error: "no_slack_handler", detail: "export slack() next to fetch" },
+          { status: 501 },
+        );
+      }
+      const body = await request.json().catch(() => ({}));
+      const kind = body.kind;
+      if (kind !== "event" && kind !== "command") {
+        return Response.json({ error: "missing_kind" }, { status: 400 });
+      }
+      const event = {
+        kind,
+        teamId: typeof body.teamId === "string" ? body.teamId : "",
+        appId: typeof body.appId === "string" ? body.appId : "",
+        payload: typeof body.payload === "object" && body.payload !== null ? body.payload : {},
+        ...(typeof body.responseUrl === "string" ? { responseUrl: body.responseUrl } : {}),
+        ...(typeof body.slackUser === "object" && body.slackUser !== null
+          ? { user: body.slackUser }
+          : {}),
+      };
+      const workerEnv = buildEnv(env, request, new Headers(request.headers));
+      // Inside the platform's own workspace the caller maps to their Canopy
+      // user, delivered pre-resolved by canopy-api (docs/33 §6); any other
+      // workspace, or an unknown caller, is nobody.
+      workerEnv.USER =
+        typeof body.user === "object" && body.user !== null && typeof body.user.sub === "string"
+          ? { sub: body.user.sub, email: body.user.email || "", name: body.user.name || "" }
+          : null;
+      workerEnv.CALLER = callerFromUser(workerEnv.USER);
+      try {
+        // Empty identity, like scheduled: a self-fetch loops back as nobody.
+        const result = await runWithSelfFetchContext(env, ctx, new Headers(), 0, new Headers(), () =>
+          worker.slack(event, workerEnv, ctx),
+        );
+        // A command handler's return value rides back to canopy-api, which
+        // relays it to Slack inside the ack window when it arrives in time.
+        return Response.json(
+          result === undefined || result === null ? { ok: true } : { ok: true, result },
+        );
+      } catch (err) {
+        console.error("slack handler failed: " + describeError(err));
+        return Response.json(
+          { error: "slack_failed", detail: err instanceof Error ? err.message : String(err) },
+          { status: 500 },
+        );
+      }
+    }
+
+    if (url.pathname === "/__canopy/scheduled" && request.method === "POST") {
+      if (typeof worker.scheduled !== "function") {
+        return Response.json(
+          { error: "no_scheduled_handler", detail: "export scheduled() next to fetch" },
+          { status: 501 },
+        );
+      }
+      const body = await request.json().catch(() => ({}));
+      const name = typeof body.name === "string" ? body.name : "";
+      const cron = typeof body.cron === "string" ? body.cron : "";
+      if (!name) return Response.json({ error: "missing_name" }, { status: 400 });
+      const event = {
+        name,
+        cron,
+        scheduledTime: typeof body.scheduledTime === "number" ? body.scheduledTime : Date.now(),
+        type: "scheduled",
+      };
+      const workerEnv = buildEnv(env, request, new Headers(request.headers));
+      // Cron has no monk session, and no caller at all.
+      workerEnv.USER = null;
+      workerEnv.CALLER = null;
+      try {
+        // Empty identity: a self-fetch during scheduled() loops back with
+        // env.USER null, like a real request from nobody (docs/27).
+        await runWithSelfFetchContext(env, ctx, new Headers(), 0, new Headers(), () =>
+          worker.scheduled(event, workerEnv, ctx),
+        );
+        return Response.json({ ok: true, name, cron });
+      } catch (err) {
+        console.error("scheduled handler failed " + name + ": " + describeError(err));
+        return Response.json(
+          { error: "scheduled_failed", detail: err instanceof Error ? err.message : String(err) },
+          { status: 500 },
+        );
+      }
+    }
+
+    if (typeof worker.fetch !== "function") {
+      return Response.json(
+        { error: "no_fetch_handler", detail: "worker bundle must default-export fetch()" },
+        { status: 501 },
+      );
+    }
+    // Frameworks (Hono etc.) catch their own route errors; this guards raw
+    // workers whose fetch() throws — one ERROR log entry with the stack
+    // (docs/17) and a JSON 500, instead of the throw escaping to the gateway
+    // as a generic 502 backend_unavailable. Parity with the GCP loader.
+    try {
+      return await invokeWorkerFetch(request, env, ctx);
+    } catch (err) {
+      console.error("worker fetch failed: " + describeError(err));
+      return Response.json(
+        { error: "worker_error", detail: err instanceof Error ? err.message : String(err) },
+        { status: 500 },
+      );
+    }
+  },
+};
+`;
 //#endregion
 export { realtimeRouter as a, META_COLUMNS as c, stampWorkerHeaders as i, blobRouter as l, WORKER_ATTEST_HEADER as n, dbRouter as o, redactCanopyCredentials as r, hasPrivateNames as s, CALLER_HEADER as t };