@cybernetyx1/atlasflow-runtime 0.1.0

package/dist/routing/index.js

@@ -0,0 +1,2184 @@
+import {
+  advanceWorkflow,
+  approveGate,
+  cronMatches,
+  decideToolApprovalState,
+  dispatchWorkflow,
+  genId,
+  getDefaultPersistence,
+  invokeAgent,
+  isChannelDefinition,
+  isToolApprovalRequiredError,
+  recoverRuns,
+  startWorkflow,
+  waitingGate,
+  waitingToolApproval
+} from "../chunk-RF6W3TKJ.js";
+import "../chunk-4DU4GJ2X.js";
+import {
+  isJsonStreamContentType,
+  normalizeStreamContentType,
+  streamMessageBytes
+} from "../chunk-M4JW76IL.js";
+import "../chunk-S7RZJMCF.js";
+import "../chunk-HO6QHSUS.js";
+
+// src/routing/index.ts
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+
+// src/event-offset.ts
+var COMPONENT_PAD = 16;
+var ZERO_COMPONENT = "0".repeat(COMPONENT_PAD);
+function formatEventOffset(index) {
+  if (index === -1) return "-1";
+  return `${ZERO_COMPONENT}_${String(index).padStart(COMPONENT_PAD, "0")}`;
+}
+function parseEventOffset(offset) {
+  if (offset === "-1") return -1;
+  if (/^-?\d+$/.test(offset)) return Number(offset);
+  const match = /^\d+_(\d+)$/.exec(offset);
+  if (!match) throw new Error(`Invalid event stream offset: ${offset}`);
+  return Number(match[1]);
+}
+
+// src/routing/index.ts
+var STREAM_OFFSET_HEADER = "Stream-Next-Offset";
+var STREAM_CURSOR_HEADER = "Stream-Cursor";
+var STREAM_UP_TO_DATE_HEADER = "Stream-Up-To-Date";
+var STREAM_CLOSED_HEADER = "Stream-Closed";
+var STREAM_SEQ_HEADER = "Stream-Seq";
+var STREAM_TTL_HEADER = "Stream-TTL";
+var STREAM_EXPIRES_AT_HEADER = "Stream-Expires-At";
+var STREAM_FORKED_FROM_HEADER = "Stream-Forked-From";
+var STREAM_FORK_OFFSET_HEADER = "Stream-Fork-Offset";
+var STREAM_SSE_DATA_ENCODING_HEADER = "stream-sse-data-encoding";
+var PRODUCER_ID_HEADER = "Producer-Id";
+var PRODUCER_EPOCH_HEADER = "Producer-Epoch";
+var PRODUCER_SEQ_HEADER = "Producer-Seq";
+var PRODUCER_EXPECTED_SEQ_HEADER = "Producer-Expected-Seq";
+var PRODUCER_RECEIVED_SEQ_HEADER = "Producer-Received-Seq";
+var STREAM_EXPOSE_HEADERS = `${STREAM_OFFSET_HEADER}, ${STREAM_CURSOR_HEADER}, ${STREAM_UP_TO_DATE_HEADER}, ${STREAM_CLOSED_HEADER}, ${STREAM_SEQ_HEADER}, ${STREAM_TTL_HEADER}, ${STREAM_EXPIRES_AT_HEADER}, ${STREAM_FORKED_FROM_HEADER}, ${STREAM_FORK_OFFSET_HEADER}, ${STREAM_SSE_DATA_ENCODING_HEADER}, ${PRODUCER_ID_HEADER}, ${PRODUCER_EPOCH_HEADER}, ${PRODUCER_SEQ_HEADER}, ${PRODUCER_EXPECTED_SEQ_HEADER}, ${PRODUCER_RECEIVED_SEQ_HEADER}, etag, content-type, location`;
+var DURABLE_STREAM_LONG_POLL_MS = 25e3;
+var DEFAULT_SUBSCRIPTION_LEASE_TTL_MS = 3e4;
+var MIN_SUBSCRIPTION_LEASE_TTL_MS = 1e3;
+var MAX_SUBSCRIPTION_LEASE_TTL_MS = 6e5;
+var RATE_LIMIT_BUCKETS = /* @__PURE__ */ new Map();
+var nextRateLimitScope = 0;
+function requireApiKey(options = {}) {
+  return async (c, next) => {
+    const env = requestEnv(c);
+    const expected = options.token ?? env.ATLASFLOW_API_KEY;
+    if (!expected) {
+      const open = typeof options.allowUnconfigured === "function" ? options.allowUnconfigured(env) : options.allowUnconfigured === true;
+      if (open) return next();
+      return c.json(
+        {
+          ok: false,
+          error: {
+            code: "auth_unconfigured",
+            message: "API-key auth is enabled but no token is configured. Set ATLASFLOW_API_KEY (or ATLASFLOW_MODE=local for open local development)."
+          }
+        },
+        503
+      );
+    }
+    const header = c.req.header(options.header ?? "authorization") ?? "";
+    const presented = header.replace(/^Bearer\s+/i, "");
+    if (!timingSafeEqualStr(presented, expected)) {
+      const scoped = await verifyRequestScopedToken(presented, c, env, expected, options.scopedTokens);
+      if (scoped.ok) return next();
+      return c.json({ ok: false, error: { code: "unauthorized", message: "invalid or missing API key" } }, 401);
+    }
+    return next();
+  };
+}
+async function mintScopedToken(options) {
+  if (!options.secret) throw new Error("mintScopedToken: secret is required");
+  const now = Math.floor((options.now?.() ?? Date.now()) / 1e3);
+  const exp = options.expiresAt instanceof Date ? Math.floor(options.expiresAt.getTime() / 1e3) : typeof options.expiresAt === "number" ? Math.floor(options.expiresAt) : now + (options.ttlSeconds ?? 300);
+  if (exp <= now) throw new Error("mintScopedToken: expiration must be in the future");
+  const claims = {
+    v: 1,
+    iat: now,
+    exp,
+    ...options.subject ? { sub: options.subject } : {},
+    ...options.audience ? { aud: options.audience } : {},
+    ...options.scopes?.length ? { scopes: [...new Set(options.scopes)].sort() } : {},
+    ...options.agents?.length ? { agents: [...new Set(options.agents)].sort() } : {},
+    ...options.instanceIds?.length ? { instanceIds: [...new Set(options.instanceIds)].sort() } : {}
+  };
+  const payload = base64UrlEncodeJson(claims);
+  const signature = await signScopedToken(options.secret, payload);
+  return `afst.v1.${payload}.${signature}`;
+}
+function scopedTokensFromEnv(env = defaultEnv()) {
+  const enabled = (env.ATLASFLOW_BROWSER_TOKENS ?? "").toLowerCase() === "true";
+  const secret = env.ATLASFLOW_BROWSER_TOKEN_SECRET;
+  if (!enabled && !secret) return false;
+  return {
+    ...secret ? { secret } : {},
+    ...env.ATLASFLOW_BROWSER_TOKEN_AUDIENCE ? { audience: env.ATLASFLOW_BROWSER_TOKEN_AUDIENCE } : {}
+  };
+}
+function corsFromEnv(env = defaultEnv()) {
+  const raw = env.ATLASFLOW_CORS_ORIGINS?.trim();
+  if (!raw) return false;
+  const origins = raw === "*" ? "*" : raw.split(",").map((origin) => origin.trim()).filter(Boolean);
+  if (origins !== "*" && origins.length === 0) return false;
+  return { origins };
+}
+function rateLimitFromEnv(env = defaultEnv()) {
+  const enabled = (env.ATLASFLOW_RATE_LIMIT_ENABLED ?? "true").trim().toLowerCase();
+  if (["0", "false", "off", "no"].includes(enabled)) return false;
+  const windowMs = positiveInt(env.ATLASFLOW_RATE_LIMIT_WINDOW_MS, 6e4);
+  const limit = positiveInt(env.ATLASFLOW_RATE_LIMIT_RPM, 120);
+  if (limit <= 0) return false;
+  return {
+    scope: env.ATLASFLOW_RATE_LIMIT_SCOPE?.trim() || "default",
+    limit,
+    windowMs,
+    burst: positiveInt(env.ATLASFLOW_RATE_LIMIT_BURST, Math.max(1, Math.min(limit, 30))),
+    maxKeys: positiveInt(env.ATLASFLOW_RATE_LIMIT_MAX_KEYS, 1e4)
+  };
+}
+function rateLimit(source = {}) {
+  const localScope = `app:${++nextRateLimitScope}`;
+  let requestCount = 0;
+  return async (c, next) => {
+    const env = requestEnv(c);
+    const options = resolveRateLimitOptions(source, env, localScope);
+    if (!options) return next();
+    const url = new URL(c.req.url);
+    const route = rateLimitRoute(c.req.method, url.pathname);
+    if (!route) return next();
+    const tokenHash = rateLimitTokenHash(c.req.raw);
+    const input = { request: c.req.raw, url, env, route, clientIp: clientIp(c.req.raw), tokenHash };
+    const key = `${options.scope}:${options.key?.(input) ?? `${input.clientIp}:${tokenHash}:${route}`}`;
+    if (!key) return next();
+    const decision = consumeRateLimitBucket(RATE_LIMIT_BUCKETS, key, options);
+    if (!decision.ok) return rateLimitResponse(decision);
+    if (++requestCount % 500 === 0) pruneRateLimitBuckets(RATE_LIMIT_BUCKETS, options);
+    await next();
+    c.res.headers.set("x-ratelimit-limit", String(decision.limit));
+    c.res.headers.set("x-ratelimit-remaining", String(decision.remaining));
+    c.res.headers.set("x-ratelimit-reset", String(decision.resetSeconds));
+  };
+}
+function timingSafeEqualStr(a, b) {
+  if (a.length !== b.length) return false;
+  let mismatch = 0;
+  for (let i = 0; i < a.length; i++) mismatch |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return mismatch === 0;
+}
+function requestEnv(c) {
+  const base = defaultEnv();
+  const workerEnv = c.env ?? {};
+  return { ...base, ...workerEnv };
+}
+function defaultEnv() {
+  return typeof process !== "undefined" && process.env ? process.env : {};
+}
+function positiveInt(raw, fallback) {
+  if (raw === void 0 || raw.trim() === "") return fallback;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+function resolveRateLimitOptions(source, env, fallbackScope) {
+  const resolved = typeof source === "function" ? source(env) : source;
+  if (!resolved) return false;
+  const scope = resolved.scope?.trim() || fallbackScope;
+  const limit = Math.max(1, Math.floor(resolved.limit ?? 120));
+  const windowMs = Math.max(1, Math.floor(resolved.windowMs ?? 6e4));
+  const burst = Math.max(1, Math.floor(resolved.burst ?? Math.min(limit, 30)));
+  const maxKeys = Math.max(1, Math.floor(resolved.maxKeys ?? 1e4));
+  return { scope, limit, windowMs, burst, maxKeys, key: resolved.key };
+}
+function rateLimitRoute(method, pathname) {
+  const normalizedMethod = method.toUpperCase();
+  if (normalizedMethod === "OPTIONS") return void 0;
+  if ((normalizedMethod === "GET" || normalizedMethod === "HEAD") && (pathname === "/" || pathname === "/health" || pathname === "/docs")) return void 0;
+  const parts = pathname.split("/").filter(Boolean);
+  if (!parts.length) return void 0;
+  if (parts[0] === "channels") return `channels:${parts[1] ?? "*"}`;
+  if (parts[0] === "agents") return `agents:${parts[1] ?? "*"}`;
+  if (parts[0] === "sessions") return "sessions";
+  if (parts[0] === "runs") return normalizedMethod === "POST" ? `runs:${parts[1] ?? "*"}` : "runs:read";
+  if (parts[0] === "workflows") return `workflows:${parts[1] ?? "*"}`;
+  if (parts[0] === "streams") return normalizedMethod === "GET" || normalizedMethod === "HEAD" ? "streams:read" : "streams:write";
+  if (parts[0] === "admin") return "admin";
+  return `${normalizedMethod}:${parts[0]}`;
+}
+function clientIp(request) {
+  const cf = request.headers.get("cf-connecting-ip")?.trim();
+  if (cf) return cf;
+  const forwarded = request.headers.get("x-forwarded-for")?.split(",")[0]?.trim();
+  if (forwarded) return forwarded;
+  return request.headers.get("x-real-ip")?.trim() || "unknown";
+}
+function rateLimitTokenHash(request) {
+  const token = bearerTokenFromHeader(request.headers.get("authorization")) ?? request.headers.get("x-atlasflow-channel-token") ?? "";
+  return token ? shortHash(token) : "anon";
+}
+function bearerTokenFromHeader(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) return void 0;
+  return trimmed.replace(/^Bearer\s+/i, "");
+}
+function shortHash(value) {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i++) {
+    hash ^= value.charCodeAt(i);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+function consumeRateLimitBucket(buckets, key, options) {
+  const now = Date.now();
+  const refillPerMs = options.limit / options.windowMs;
+  const existing = buckets.get(key);
+  const bucket = existing ?? { tokens: options.burst, updatedAt: now };
+  if (existing) {
+    const elapsed = Math.max(0, now - bucket.updatedAt);
+    bucket.tokens = Math.min(options.burst, bucket.tokens + elapsed * refillPerMs);
+    bucket.updatedAt = now;
+  }
+  if (bucket.tokens < 1) {
+    buckets.set(key, bucket);
+    const retrySeconds = Math.max(1, Math.ceil((1 - bucket.tokens) / refillPerMs / 1e3));
+    return { ok: false, limit: options.limit, retrySeconds, resetSeconds: retrySeconds };
+  }
+  bucket.tokens -= 1;
+  buckets.set(key, bucket);
+  const resetSeconds = Math.max(1, Math.ceil((options.burst - bucket.tokens) / refillPerMs / 1e3));
+  return { ok: true, limit: options.limit, remaining: Math.floor(bucket.tokens), resetSeconds };
+}
+function pruneRateLimitBuckets(buckets, options) {
+  if (buckets.size <= options.maxKeys) return;
+  const cutoff = Date.now() - options.windowMs * 2;
+  for (const [key, bucket] of buckets) {
+    if (bucket.updatedAt < cutoff) buckets.delete(key);
+    if (buckets.size <= options.maxKeys) return;
+  }
+  for (const key of buckets.keys()) {
+    buckets.delete(key);
+    if (buckets.size <= options.maxKeys) return;
+  }
+}
+function rateLimitResponse(decision) {
+  return new Response(JSON.stringify({ ok: false, error: { code: "rate_limited", message: "Too many requests. Retry later." } }), {
+    status: 429,
+    headers: {
+      "content-type": "application/json",
+      "retry-after": String(decision.retrySeconds),
+      "x-ratelimit-limit": String(decision.limit),
+      "x-ratelimit-remaining": "0",
+      "x-ratelimit-reset": String(decision.resetSeconds)
+    }
+  });
+}
+async function verifyRequestScopedToken(token, c, env, apiKey, source) {
+  const options = resolveScopedTokenOptions(source, env);
+  if (!options) return { ok: false, message: "scoped tokens are not enabled" };
+  const secret = options.secret ?? env.ATLASFLOW_BROWSER_TOKEN_SECRET ?? apiKey;
+  if (!secret) return { ok: false, message: "scoped token secret is not configured" };
+  const claims = await verifyScopedToken(token, secret, options);
+  if (!claims.ok) return claims;
+  const access = scopedTokenAllowsRequest(claims.claims, c);
+  return access.ok ? { ok: true } : { ok: false, message: access.message };
+}
+function resolveScopedTokenOptions(source, env) {
+  const resolved = typeof source === "function" ? source(env) : source;
+  if (!resolved) return false;
+  if (resolved === true) return {};
+  return resolved;
+}
+async function verifyScopedToken(token, secret, options) {
+  const parts = token.split(".");
+  if (parts.length !== 4 || parts[0] !== "afst" || parts[1] !== "v1") return { ok: false, message: "not an AtlasFlow scoped token" };
+  const payload = parts[2];
+  const signature = parts[3];
+  const expected = await signScopedToken(secret, payload);
+  if (!timingSafeEqualStr(signature, expected)) return { ok: false, message: "invalid scoped token signature" };
+  const claims = parseScopedTokenPayload(payload);
+  if (!claims) return { ok: false, message: "invalid scoped token payload" };
+  const now = Math.floor((options.now?.() ?? Date.now()) / 1e3);
+  const leeway = options.leewaySeconds ?? 15;
+  if (claims.exp + leeway < now) return { ok: false, message: "scoped token expired" };
+  if (options.audience && claims.aud !== options.audience) return { ok: false, message: "scoped token audience mismatch" };
+  return { ok: true, claims };
+}
+function parseScopedTokenPayload(payload) {
+  try {
+    const raw = JSON.parse(base64UrlDecodeText(payload));
+    if (raw.v !== 1 || typeof raw.exp !== "number" || !Number.isFinite(raw.exp)) return void 0;
+    for (const key of ["scopes", "agents", "instanceIds"]) {
+      const value = raw[key];
+      if (value !== void 0 && (!Array.isArray(value) || value.some((item) => typeof item !== "string"))) return void 0;
+    }
+    if (raw.sub !== void 0 && typeof raw.sub !== "string") return void 0;
+    if (raw.aud !== void 0 && typeof raw.aud !== "string") return void 0;
+    if (raw.iat !== void 0 && typeof raw.iat !== "number") return void 0;
+    return raw;
+  } catch {
+    return void 0;
+  }
+}
+function scopedTokenAllowsRequest(claims, c) {
+  const route = scopedRequest(c);
+  if (!route) return { ok: false, message: "scoped token cannot access this route" };
+  const scopes = new Set(claims.scopes ?? []);
+  if (!scopes.has("*") && !route.scopes.some((scope) => scopes.has(scope))) {
+    return { ok: false, message: `scoped token lacks ${route.scopes[0]} access` };
+  }
+  if (route.agent && claims.agents?.length && !claims.agents.includes(route.agent)) {
+    return { ok: false, message: `scoped token cannot access agent ${route.agent}` };
+  }
+  if (route.instanceId && claims.instanceIds?.length && !claims.instanceIds.includes(route.instanceId)) {
+    return { ok: false, message: `scoped token cannot access instance ${route.instanceId}` };
+  }
+  return { ok: true };
+}
+function scopedRequest(c) {
+  const url = new URL(c.req.url);
+  const method = c.req.method.toUpperCase();
+  const parts = url.pathname.split("/").filter(Boolean);
+  if (parts[0] === "agents") {
+    if (parts.length === 1 && method === "GET") return { scopes: ["agents:list"] };
+    if (parts.length >= 3 && method === "POST") {
+      return { scopes: ["agents:invoke"], agent: decodeURIComponent(parts[1]), instanceId: decodeURIComponent(parts[2]) };
+    }
+  }
+  if (parts[0] === "runs") {
+    if (parts.length === 2 && method === "POST") return { scopes: ["runs:write"], agent: decodeURIComponent(parts[1]) };
+    if (parts.length === 2 && method === "GET") return { scopes: ["runs:read"] };
+    if (parts.length === 3 && parts[2] === "events" && (method === "GET" || method === "HEAD")) return { scopes: ["runs:read"] };
+    if (parts.length === 3 && parts[2] === "approve" && method === "POST") return { scopes: ["runs:approve"] };
+  }
+  if (parts[0] === "workflows" && parts.length === 2 && method === "POST") return { scopes: ["runs:write"], agent: decodeURIComponent(parts[1]) };
+  if (parts[0] === "streams") {
+    if (method === "GET" || method === "HEAD") return { scopes: ["streams:read"] };
+    if (method === "PUT" || method === "POST" || method === "DELETE") return { scopes: ["streams:write"] };
+  }
+  if (parts[0] === "admin") return { scopes: ["admin:*"] };
+  return void 0;
+}
+async function signScopedToken(secret, payload) {
+  const bytes = new TextEncoder().encode(secret);
+  const data = new TextEncoder().encode(payload);
+  const subtle = webCryptoSubtle();
+  const key = await subtle.importKey("raw", bytes, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  const signature = await subtle.sign("HMAC", key, data);
+  return base64UrlEncodeBytes(new Uint8Array(signature));
+}
+function webCryptoSubtle() {
+  const candidate = globalThis.crypto?.subtle;
+  if (!candidate) throw new Error("Scoped browser tokens require Web Crypto support.");
+  return candidate;
+}
+function base64UrlEncodeJson(value) {
+  return base64UrlEncodeBytes(new TextEncoder().encode(JSON.stringify(value)));
+}
+function base64UrlEncodeBytes(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  const base64 = typeof btoa === "function" ? btoa(binary) : Buffer.from(bytes).toString("base64");
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function base64UrlDecodeText(value) {
+  const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "=");
+  const binary = typeof atob === "function" ? atob(padded) : Buffer.from(padded, "base64").toString("binary");
+  const bytes = Uint8Array.from(binary, (ch) => ch.charCodeAt(0));
+  return new TextDecoder().decode(bytes);
+}
+function corsMiddleware(source) {
+  return async (c, next) => {
+    const cors = resolveCorsOptions(source, requestEnv(c));
+    if (!cors) return next();
+    const headers = corsResponseHeaders(c, cors);
+    if (c.req.method.toUpperCase() === "OPTIONS") {
+      return new Response(null, { status: headers ? 204 : 403, headers: headers ?? void 0 });
+    }
+    await next();
+    if (!headers) return;
+    for (const [key, value] of Object.entries(headers)) c.res.headers.set(key, value);
+  };
+}
+function resolveCorsOptions(source, env) {
+  return typeof source === "function" ? source(env) ?? false : source;
+}
+function corsResponseHeaders(c, options) {
+  const origin = c.req.header("origin");
+  if (!origin) return void 0;
+  const allowOrigin = allowedCorsOrigin(origin, options);
+  if (!allowOrigin) return void 0;
+  const requestedHeaders = c.req.header("access-control-request-headers");
+  const headers = {
+    "access-control-allow-origin": allowOrigin,
+    "access-control-allow-methods": (options.methods ?? ["GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS"]).join(", "),
+    "access-control-allow-headers": requestedHeaders ?? (options.headers ?? defaultCorsHeaders()).join(", "),
+    "access-control-expose-headers": [.../* @__PURE__ */ new Set([STREAM_EXPOSE_HEADERS, ...options.exposeHeaders ?? []])].join(", "),
+    vary: "Origin"
+  };
+  if (options.credentials) headers["access-control-allow-credentials"] = "true";
+  if (options.maxAgeSeconds !== void 0) headers["access-control-max-age"] = String(options.maxAgeSeconds);
+  return headers;
+}
+function allowedCorsOrigin(origin, options) {
+  if (options.origins === "*") return options.credentials ? origin : "*";
+  return options.origins.includes(origin) ? origin : void 0;
+}
+function defaultCorsHeaders() {
+  return [
+    "authorization",
+    "content-type",
+    "last-event-id",
+    STREAM_SEQ_HEADER,
+    STREAM_CLOSED_HEADER,
+    STREAM_TTL_HEADER,
+    STREAM_EXPIRES_AT_HEADER,
+    STREAM_FORKED_FROM_HEADER,
+    STREAM_FORK_OFFSET_HEADER,
+    PRODUCER_ID_HEADER,
+    PRODUCER_EPOCH_HEADER,
+    PRODUCER_SEQ_HEADER,
+    PRODUCER_EXPECTED_SEQ_HEADER
+  ];
+}
+function keepAlive(c, promise) {
+  try {
+    c.executionCtx?.waitUntil?.(promise);
+  } catch {
+  }
+}
+function mountChannels(app, channels, ctx) {
+  for (const [name, channel] of Object.entries(channels)) {
+    const path = channelPath(name, channel);
+    const methods = channelMethods(channel);
+    for (const method of methods) {
+      app.on(method, path, (c) => dispatchChannel(c, name, channel, ctx));
+    }
+  }
+}
+async function dispatchChannel(c, name, channel, ctx) {
+  const result = await channel.handle({
+    channel: name,
+    request: c.req.raw,
+    url: new URL(c.req.url),
+    env: requestEnv(c),
+    json: () => safeJsonValue(c.req.raw),
+    text: () => c.req.text()
+  });
+  if (result instanceof Response) return result;
+  const envelope = channelEnvelope(result);
+  if (!envelope.ok) return c.json({ ok: false, error: { code: "bad_channel_result", message: envelope.message } }, 500);
+  const dispatch = envelope.dispatch;
+  const agentName = dispatch.agent ?? ctx.defaultAgentName;
+  if (!agentName) return c.json({ ok: false, error: { code: "ambiguous_agent", message: "Channel dispatch requires an agent when more than one agent is deployed." } }, 400);
+  const agent = ctx.agents[agentName];
+  if (!agent) return c.json({ ok: false, error: { code: "unknown_agent", message: `No agent "${agentName}"` } }, 404);
+  const images = promptImages(dispatch.images);
+  if (!images.ok) return c.json({ ok: false, error: { code: "bad_request", message: images.message } }, 400);
+  const common = {
+    agent,
+    agentName,
+    instanceId: dispatch.continuationToken,
+    runId: dispatch.runId,
+    message: dispatch.message,
+    payload: dispatch.payload,
+    images: images.value,
+    persistence: ctx.persistence,
+    env: requestEnv(c),
+    ...ctx.shared
+  };
+  if (dispatch.mode === "sync") {
+    try {
+      const run = await invokeAgent({ ...common, signal: c.req.raw.signal });
+      return c.json({ ok: true, channel: name, continuationToken: dispatch.continuationToken, runId: run.runId, data: run.text, result: run.data, usage: run.usage });
+    } catch (err) {
+      if (isToolApprovalRequiredError(err)) return toolApprovalWaitingResponse(c, err);
+      return c.json({ ok: false, ...errorPayload(err) }, 500);
+    }
+  }
+  const { runId, done } = await dispatchWorkflow(common);
+  keepAlive(c, done);
+  return c.json(
+    {
+      ok: true,
+      channel: name,
+      continuationToken: dispatch.continuationToken,
+      runId,
+      status: "queued",
+      ...channelResponseFields(envelope.response),
+      ...streamCoordinates(c, runId)
+    },
+    channelStatus(envelope.status)
+  );
+}
+function routeContext(agents, persistence, shared, defaultEnv2) {
+  const resolve = (name, opts = {}) => {
+    const agent = agents[name];
+    if (!agent) throw new Error(`No agent "${name}"`);
+    return {
+      agent,
+      agentName: name,
+      instanceId: opts.instanceId ?? opts.runId ?? genId("run"),
+      message: opts.message,
+      payload: opts.payload,
+      env: opts.env ?? defaultEnv2,
+      signal: opts.signal,
+      runId: opts.runId,
+      onEvent: opts.onEvent,
+      persistence,
+      ...shared
+    };
+  };
+  return {
+    agents,
+    persistence,
+    invoke: (name, opts) => invokeAgent(resolve(name, opts)),
+    dispatch: (name, opts) => dispatchWorkflow(resolve(name, opts))
+  };
+}
+function createApp(options) {
+  const app = new Hono();
+  const persistence = options.persistence ?? getDefaultPersistence();
+  const agents = options.agents;
+  const personas = options.personas ?? options.subagents;
+  const shared = { baseInstructions: options.baseInstructions, sharedPersonas: personas, engine: options.engine, durability: options.durability };
+  const workflows = normalizeWorkflows(options.workflows);
+  const channels = normalizeChannels(options.channels);
+  const defaultAgentName = singleAgentName(agents);
+  const workflowCtx = (env, mount) => buildWorkflowCtx(options, persistence, env, mount);
+  app.onError(
+    (err, c) => c.json({ ok: false, error: { code: "internal_error", message: err instanceof Error ? err.message : String(err) } }, 500)
+  );
+  if (options.cors) app.use("*", corsMiddleware(options.cors));
+  if (options.rateLimit) app.use("*", rateLimit(options.rateLimit));
+  options.routes?.(app, routeContext(agents, persistence, shared));
+  mountChannels(app, channels, { agents, persistence, shared, defaultAgentName });
+  app.get("/", (c) => c.json({ name: "atlasflow", agents: Object.keys(agents), docs: "/docs" }));
+  app.get("/health", (c) => c.json({ status: "ok" }));
+  app.get(
+    "/docs",
+    (c) => c.json({
+      name: "AtlasFlow HTTP API",
+      version: 1,
+      auth: "Bearer token in the `authorization` header (ATLASFLOW_API_KEY). /health and /docs are open; everything else is gated.",
+      endpoints: [
+        { method: "GET", path: "/health", auth: false, returns: '{ "status": "ok" }' },
+        { method: "GET", path: "/docs", auth: false, returns: "this document" },
+        { method: "GET", path: "/agents", auth: true, returns: "{ items: [{ name, triggers }], workflows: [name], channels: [name] } \u2014 every persona/agent, authored workflow, and ingress channel deployed here" },
+        {
+          method: "POST",
+          path: "/channels/:name",
+          auth: false,
+          body: "channel-specific webhook/event body",
+          returns: "202 { runId, continuationToken } for background dispatch, or 200 { runId, data, result, usage } when the channel requests sync mode. Channel handlers perform their own platform signature verification."
+        },
+        {
+          method: "POST",
+          path: "/agents/:name/:id",
+          auth: true,
+          body: '{ "message"?: string, "payload"?: any, "images"?: [{ "data": "base64-or-data-url", "mime_type"?: "image/png" }] }',
+          modes: {
+            sync: "default \u2014 returns { ok, runId, data (final text), result (structured), usage }",
+            stream: 'send header "accept: text/event-stream" \u2014 Server-Sent Events (run_start, text_delta, tool_call, rule_triggered, ... then a terminal `result` event)',
+            background: 'send header "x-webhook: true" \u2014 returns 202 { runId }; poll /admin/runs/:runId'
+          },
+          notes: ":id is the conversation instance \u2014 reuse it to continue a session, change it for a fresh one"
+        },
+        {
+          method: "POST",
+          path: "/sessions/:id/messages",
+          auth: true,
+          body: '{ "message"?: string, "payload"?: any, "images"?: [{ "data": "base64-or-data-url", "mime_type"?: "image/png" }] }',
+          returns: "Single-agent alias for /agents/:name/:id. Available only when this deployment has exactly one agent."
+        },
+        {
+          method: "POST",
+          path: "/runs?wait=result",
+          auth: true,
+          body: '{ "message"?: string, "payload"?: any, "images"?: [{ "data": "base64-or-data-url", "mime_type"?: "image/png" }], "wait"?: boolean }',
+          returns: "Single-agent alias for /runs/:name. Available only when this deployment has exactly one agent."
+        },
+        {
+          method: "POST",
+          path: "/runs/:name?wait=result",
+          auth: true,
+          body: '{ "message"?: string, "payload"?: any, "images"?: [{ "data": "base64-or-data-url", "mime_type"?: "image/png" }], "wait"?: boolean }',
+          returns: '202 { runId, status: "queued" } for background dispatch, 202 { runId, status: "waiting_approval", approval } when an approval-marked tool parks, or 200 { runId, data, result, usage } when wait mode completes. For an authored workflow name: { runId, status: "waiting_approval", gate } when parked at a human gate. Steps read the payload as {{steps.payload.text}}.'
+        },
+        {
+          method: "GET",
+          path: "/runs/:runId?meta",
+          auth: true,
+          returns: "RunRecord: { runId, agent, status, result, error, kind, state, images? }"
+        },
+        {
+          method: "GET/HEAD",
+          path: "/runs/:runId/events?offset=<opaque>&follow=true",
+          auth: true,
+          returns: "AtlasFlow envelope JSON with ?format=atlas, legacy SSE with Accept: text/event-stream, or Durable Streams read metadata/body when called as a plain stream endpoint. Reconnect with Last-Event-ID or ?offset=<event.offset>; numeric ?after=N remains supported for legacy callers."
+        },
+        {
+          method: "PUT/GET/HEAD/POST/DELETE",
+          path: "/streams/*",
+          auth: true,
+          returns: "Writable Durable Streams-compatible public streams. Create with PUT, duplicate creates return 409 CONFLICT_EXISTS, fork with Stream-Forked-From/Stream-Fork-Offset, append or close with POST, coordinate writers with Stream-Seq or Producer-* headers, read with ?offset=<opaque>, inspect with HEAD, and delete with DELETE. Pull-wake and HTTPS-only webhook subscriptions live under /streams/__ds/subscriptions/*; webhook callbacks block localhost/private destinations, DNS resolutions to private addresses, and sensitive headers by default. Run event streams remain framework-owned and read-only."
+        },
+        {
+          method: "POST",
+          path: "/runs/:runId/approve",
+          auth: true,
+          body: '{ "approved": boolean, "gate"?: string, "approval"?: string, "note"?: string }',
+          returns: "{ runId, status, data?, approval? } \u2014 records the human decision on a workflow gate or approval-marked tool; approval resumes execution"
+        },
+        { method: "GET", path: "/admin/runs?limit=N", auth: true, returns: "{ items: RunRecord[] } \u2014 newest first" },
+        { method: "GET", path: "/admin/runs/:runId", auth: true, returns: "RunRecord: { runId, agent, status (queued|running|waiting_approval|success|failed|interrupted), result, error, kind, state }" },
+        { method: "GET", path: "/admin/runs/:runId/events", auth: true, returns: "{ items: AtlasEvent[] } \u2014 the full event log: tool_call/tool_result, rule_triggered, turn usage, task/skill activity" },
+        { method: "GET", path: "/admin/metrics", auth: true, returns: "{ ok, metrics } when an in-process metrics observer is configured" }
+      ],
+      sdk: "npm: @cybernetyx1/atlasflow-sdk \u2014 createAtlasFlowClient({ baseUrl, apiKey })"
+    })
+  );
+  if (options.auth) {
+    app.use("/agents/*", options.auth);
+    app.use("/sessions/*", options.auth);
+    app.use("/runs", options.auth);
+    app.use("/runs/*", options.auth);
+    app.use("/workflows/*", options.auth);
+    app.use("/admin/*", options.auth);
+    app.use("/streams/*", options.auth);
+  }
+  app.get(
+    "/agents",
+    (c) => c.json({
+      items: Object.keys(agents).map((name) => ({ name, triggers: options.triggers?.[name] ?? { webhook: true } })),
+      workflows: Object.keys(workflows),
+      channels: Object.keys(channels)
+    })
+  );
+  const invokeInteractive = async (c, name, id) => {
+    if (!name) return c.json({ ok: false, error: { code: "ambiguous_agent", message: "This route is only available when exactly one agent is deployed." } }, 400);
+    const agent = agents[name];
+    if (!agent) return c.json({ ok: false, error: { code: "unknown_agent", message: `No agent "${name}"` } }, 404);
+    const body = await safeJson(c.req.raw);
+    const message = typeof body?.message === "string" ? body.message : void 0;
+    const images = promptImages(body?.images);
+    if (!images.ok) return c.json({ ok: false, error: { code: "bad_request", message: images.message } }, 400);
+    const common = { agent, agentName: name, instanceId: id, message, payload: body?.payload, images: images.value, persistence, env: requestEnv(c), ...shared };
+    if (c.req.header("x-webhook") === "true") {
+      const { runId, done } = await dispatchWorkflow(common);
+      keepAlive(c, done);
+      return c.json({ ok: true, runId, status: "queued", ...streamCoordinates(c, runId) }, 202);
+    }
+    if (c.req.header("accept")?.includes("text/event-stream")) {
+      return streamSSE(c, async (stream) => {
+        const abort = new AbortController();
+        stream.onAbort(() => abort.abort(new Error("client disconnected")));
+        const queue = [];
+        let done = false;
+        let wake;
+        const invocation = invokeAgent({ ...common, signal: abort.signal, onEvent: (e) => {
+          queue.push(e);
+          wake?.();
+        } }).finally(() => {
+          done = true;
+          wake?.();
+        });
+        while (!done || queue.length > 0) {
+          const e = queue.shift();
+          if (e) await stream.writeSSE({ event: e.type, data: JSON.stringify(e) });
+          else await new Promise((r) => wake = r);
+        }
+        const result = await invocation.catch((err) => ({ error: errorPayload(err).error }));
+        await stream.writeSSE({ event: "result", data: JSON.stringify({ type: "result", ...result }) });
+      });
+    }
+    try {
+      const result = await invokeAgent({ ...common, signal: c.req.raw.signal });
+      return c.json({ ok: true, runId: result.runId, data: result.text, result: result.data, usage: result.usage });
+    } catch (err) {
+      if (isToolApprovalRequiredError(err)) return toolApprovalWaitingResponse(c, err);
+      return c.json({ ok: false, ...errorPayload(err) }, 500);
+    }
+  };
+  app.post("/agents/:name/:id", (c) => invokeInteractive(c, c.req.param("name"), c.req.param("id")));
+  app.post("/sessions/:id/messages", (c) => invokeInteractive(c, defaultAgentName, c.req.param("id")));
+  const dispatchRun = async (c) => {
+    const name = c.req.param("name") ?? defaultAgentName;
+    if (!name) return c.json({ ok: false, error: { code: "ambiguous_agent", message: "POST /runs is only available when exactly one agent is deployed. Use /runs/:name instead." } }, 400);
+    const body = await safeJson(c.req.raw);
+    const mount = workflows[name];
+    if (mount) {
+      const result = await startWorkflow(mount.def, workflowCtx(requestEnv(c), mount), { payload: body?.payload });
+      return c.json(
+        { ok: result.status !== "failed", runId: result.runId, status: result.status, ...streamCoordinates(c, result.runId), ...result.gate ? { gate: result.gate } : {} },
+        result.status === "failed" ? 500 : 202
+      );
+    }
+    const agent = agents[name];
+    if (!agent) return c.json({ ok: false, error: { code: "unknown_agent", message: `No agent or workflow "${name}"` } }, 404);
+    const message = typeof body?.message === "string" ? body.message : void 0;
+    const images = promptImages(body?.images);
+    if (!images.ok) return c.json({ ok: false, error: { code: "bad_request", message: images.message } }, 400);
+    const waitQuery = c.req.query("wait");
+    const wait = body?.wait === true || waitQuery === "result" || waitQuery === "true";
+    const runId = genId("run");
+    const common = {
+      agent,
+      agentName: name,
+      instanceId: runId,
+      runId,
+      payload: body?.payload,
+      images: images.value,
+      message,
+      persistence,
+      env: requestEnv(c),
+      ...shared
+    };
+    if (wait) {
+      try {
+        const result = await invokeAgent(common);
+        return c.json({ ok: true, runId: result.runId, result: result.data, data: result.text, usage: result.usage });
+      } catch (err) {
+        if (isToolApprovalRequiredError(err)) return toolApprovalWaitingResponse(c, err);
+        return c.json({ ok: false, ...errorPayload(err) }, 500);
+      }
+    }
+    const { done } = await dispatchWorkflow(common);
+    keepAlive(c, done);
+    return c.json({ ok: true, runId, status: "queued", ...streamCoordinates(c, runId) }, 202);
+  };
+  app.post("/runs", dispatchRun);
+  app.post("/runs/:name", dispatchRun);
+  app.post("/workflows/:name", dispatchRun);
+  app.get("/runs/:runId", async (c) => {
+    const run = await persistence.runs.get(c.req.param("runId"));
+    return run ? c.json(run) : c.json({ ok: false, error: { code: "not_found", message: "no such run" } }, 404);
+  });
+  app.on("HEAD", "/runs/:runId/events", async (c) => {
+    const runId = c.req.param("runId");
+    const run = await persistence.runs.get(runId);
+    if (!run) return new Response(null, { status: 404, headers: { "content-type": "application/json" } });
+    const events = (await persistence.runs.events(runId)).sort((a, b) => a.index - b.index);
+    const offset = tailOffset(events);
+    const closed = isEventStreamClosed(run, events);
+    return new Response(null, {
+      status: 200,
+      headers: eventStreamHeaders({ runId, startOffset: "-1", offset, upToDate: true, closed, cursor: streamCursor(runId, offset, closed), head: true })
+    });
+  });
+  app.get("/runs/:runId/events", async (c) => {
+    const runId = c.req.param("runId");
+    let run = await persistence.runs.get(runId);
+    if (!run) return c.json({ ok: false, error: { code: "not_found", message: "no such run" } }, 404);
+    let allEvents = (await persistence.runs.events(runId)).sort((a, b) => a.index - b.index);
+    if (c.req.method === "HEAD") {
+      const offset = tailOffset(allEvents);
+      const closed2 = isEventStreamClosed(run, allEvents);
+      return new Response(null, {
+        status: 200,
+        headers: eventStreamHeaders({ runId, startOffset: "-1", offset, upToDate: true, closed: closed2, cursor: streamCursor(runId, offset, closed2), head: true })
+      });
+    }
+    const cursor = eventCursor(c, runId, allEvents);
+    if (!cursor.ok) return c.json({ ok: false, error: cursor.error }, 400);
+    const after = cursor.value;
+    const limit = eventLimit(c);
+    const durableMode = durableStreamMode(c);
+    const live = c.req.query("live");
+    if ((live === "long-poll" || live === "sse") && c.req.query("offset") == null && c.req.query("cursor") == null && c.req.header("last-event-id") == null) {
+      return durableMode ? new Response("live reads require offset", { status: 400, headers: { "content-type": "text/plain" } }) : c.json({ ok: false, error: { code: "bad_request", message: "live reads require offset" } }, 400);
+    }
+    if (durableMode && live === "sse") return streamDurableEvents(c, persistence, run, allEvents, after);
+    if (durableMode && live === "long-poll" && isCaughtUp(after, allEvents)) {
+      let closed2 = isEventStreamClosed(run, allEvents);
+      let timedOut = false;
+      if (!closed2) {
+        const waited = await waitForRunEvents(persistence, runId, after, longPollTimeoutMs(c));
+        run = waited.run ?? run;
+        allEvents = waited.events;
+        closed2 = isEventStreamClosed(run, allEvents);
+        timedOut = waited.timedOut;
+      }
+      if (timedOut || closed2 && isCaughtUp(after, allEvents)) {
+        const offset = tailOffset(allEvents, after);
+        return new Response(null, {
+          status: 204,
+          headers: eventStreamHeaders({ runId, startOffset: formatEventOffset(after), offset, upToDate: true, closed: closed2, cursor: streamCursor(runId, offset, closed2) })
+        });
+      }
+    }
+    const closed = isEventStreamClosed(run, allEvents);
+    if (durableMode) {
+      const { items, nextOffset, upToDate } = selectEventsAfter(allEvents, after, { limit, tail: eventTail(c) });
+      return jsonResponse(items.map(withOffset), {
+        headers: eventStreamHeaders({ runId, startOffset: formatEventOffset(after), offset: nextOffset, upToDate, closed: closed && upToDate, cursor: live === "long-poll" ? streamCursor(runId, nextOffset, closed && upToDate) : void 0 })
+      });
+    }
+    if (!c.req.header("accept")?.includes("text/event-stream")) {
+      const { items, nextOffset, upToDate } = selectEventsAfter(allEvents, after, { limit, tail: eventTail(c) });
+      return jsonResponse(
+        { items: items.map(withOffset), nextOffset, upToDate, closed },
+        { headers: eventStreamHeaders({ runId, startOffset: formatEventOffset(after), offset: nextOffset, upToDate, closed: closed && upToDate }) }
+      );
+    }
+    const follow = c.req.query("follow") !== "false";
+    return streamSSE(c, async (stream) => {
+      let cursor2 = after;
+      let aborted = false;
+      let terminalPolls = 0;
+      stream.onAbort(() => {
+        aborted = true;
+      });
+      for (; ; ) {
+        const events = (await persistence.runs.events(runId)).filter((e) => e.index > cursor2).sort((a, b) => a.index - b.index);
+        for (const event of events) {
+          cursor2 = event.index;
+          await stream.writeSSE({ id: formatEventOffset(event.index), event: event.type, data: JSON.stringify(withOffset(event)) });
+        }
+        const latest = await persistence.runs.get(runId);
+        if (aborted || !follow || !latest) break;
+        const sawTerminalEvent = events.some((event) => event.type === "run_end" || event.type === "run_error");
+        if (latest.status !== "running" && latest.status !== "queued") {
+          if (sawTerminalEvent || terminalPolls++ >= 3) break;
+          await routeSleep(50);
+          continue;
+        }
+        terminalPolls = 0;
+        await routeSleep(250);
+      }
+    });
+  });
+  app.put("/streams/__ds/subscriptions/:subscriptionId", async (c) => {
+    const subscriptions = persistence.subscriptions;
+    if (!subscriptions) return subscriptionJsonError(501, "INVALID_REQUEST", "Durable Streams subscriptions are not configured");
+    const input = await subscriptionCreateInput(c);
+    if (!input.ok) return subscriptionJsonError(400, "INVALID_REQUEST", input.message);
+    const result = await subscriptions.createOrConfirm(c.req.param("subscriptionId"), input.value);
+    if (!result.ok) return subscriptionStoreError(result);
+    return c.json(subscriptionResponse(result.value.subscription), result.value.created ? 201 : 200);
+  });
+  app.get("/streams/__ds/subscriptions/:subscriptionId", async (c) => {
+    const subscriptions = persistence.subscriptions;
+    if (!subscriptions) return subscriptionJsonError(501, "INVALID_REQUEST", "Durable Streams subscriptions are not configured");
+    const subscription = await subscriptions.get(c.req.param("subscriptionId"));
+    return subscription ? c.json(subscriptionResponse(subscription)) : subscriptionJsonError(404, "SUBSCRIPTION_NOT_FOUND", "Subscription not found");
+  });
+  app.delete("/streams/__ds/subscriptions/:subscriptionId", async (c) => {
+    const subscriptions = persistence.subscriptions;
+    if (!subscriptions) return subscriptionJsonError(501, "INVALID_REQUEST", "Durable Streams subscriptions are not configured");
+    await subscriptions.delete(c.req.param("subscriptionId"));
+    return new Response(null, { status: 204 });
+  });
+  app.post("/streams/__ds/subscriptions/:subscriptionId/streams", async (c) => {
+    const subscriptions = persistence.subscriptions;
+    if (!subscriptions) return subscriptionJsonError(501, "INVALID_REQUEST", "Durable Streams subscriptions are not configured");
+    const body = await readJsonObject(c.req.raw);
+    const streams = body?.streams;
+    if (!Array.isArray(streams) || streams.length === 0 || streams.some((stream) => typeof stream !== "string" || stream.length === 0)) {
+      return subscriptionJsonError(400, "INVALID_REQUEST", "streams must be a non-empty string array");
+    }
+    const ok = await subscriptions.addExplicitStreams(c.req.param("subscriptionId"), streams);
+    return ok ? new Response(null, { status: 204 }) : subscriptionJsonError(404, "SUBSCRIPTION_NOT_FOUND", "Subscription not found");
+  });
+  app.delete("/streams/__ds/subscriptions/:subscriptionId/streams/*", async (c) => {
+    const subscriptions = persistence.subscriptions;
+    if (!subscriptions) return subscriptionJsonError(501, "INVALID_REQUEST", "Durable Streams subscriptions are not configured");
+    const streamPath = subscriptionStreamRoutePath(c);
+    const ok = await subscriptions.removeExplicitStream(c.req.param("subscriptionId"), streamPath);
+    return ok ? new Response(null, { status: 204 }) : subscriptionJsonError(404, "SUBSCRIPTION_NOT_FOUND", "Subscription not found");
+  });
+  app.post("/streams/__ds/subscriptions/:subscriptionId/claim", async (c) => {
+    const subscriptions = persistence.subscriptions;
+    if (!subscriptions) return subscriptionJsonError(501, "INVALID_REQUEST", "Durable Streams subscriptions are not configured");
+    const body = await readJsonObject(c.req.raw);
+    const worker = body?.worker;
+    if (typeof worker !== "string" || worker.length === 0) {
+      return subscriptionJsonError(400, "INVALID_REQUEST", "worker must be a non-empty string");
+    }
+    const result = await subscriptions.claim(c.req.param("subscriptionId"), worker);
+    if (!result.ok) return subscriptionStoreError(result);
+    return c.json(subscriptionClaimResponse(result.value), 200);
+  });
+  app.post("/streams/__ds/subscriptions/:subscriptionId/ack", async (c) => {
+    const subscriptions = persistence.subscriptions;
+    if (!subscriptions) return subscriptionJsonError(501, "INVALID_REQUEST", "Durable Streams subscriptions are not configured");
+    const token = bearerToken(c);
+    if (!token) return subscriptionJsonError(401, "TOKEN_INVALID", "Missing or malformed Authorization header");
+    const input = await readJsonObject(c.req.raw);
+    const result = await subscriptions.ack(c.req.param("subscriptionId"), token, subscriptionAckInput(input));
+    if (!result.ok) return subscriptionStoreError(result);
+    return c.json({ ok: true, next_wake: result.value.nextWake }, 200);
+  });
+  app.post("/streams/__ds/subscriptions/:subscriptionId/release", async (c) => {
+    const subscriptions = persistence.subscriptions;
+    if (!subscriptions) return subscriptionJsonError(501, "INVALID_REQUEST", "Durable Streams subscriptions are not configured");
+    const token = bearerToken(c);
+    if (!token) return subscriptionJsonError(401, "TOKEN_INVALID", "Missing or malformed Authorization header");
+    const input = await readJsonObject(c.req.raw);
+    const result = await subscriptions.release(c.req.param("subscriptionId"), token, subscriptionAckInput(input));
+    if (!result.ok) return subscriptionStoreError(result);
+    return new Response(null, { status: 204 });
+  });
+  app.on("HEAD", "/streams/*", async (c) => {
+    const path = publicStreamPath(c);
+    if (!path.ok) return streamText(path.message, path.status);
+    const record = await persistence.streams.get(path.value);
+    if (!record) return streamText("Stream not found", 404);
+    return new Response(null, {
+      status: 200,
+      headers: publicStreamHeaders({
+        path: path.value,
+        contentType: record.contentType,
+        startOffset: "-1",
+        offset: record.currentOffset,
+        upToDate: true,
+        closed: record.closed,
+        cursor: publicStreamCursorToken(path.value, record.currentOffset, record.closed),
+        head: true,
+        ttlSeconds: record.ttlSeconds,
+        expiresAt: record.expiresAt
+      })
+    });
+  });
+  app.put("/streams/*", async (c) => {
+    const path = publicStreamPath(c);
+    if (!path.ok) return streamText(path.message, path.status);
+    const existing = await persistence.streams.get(path.value);
+    if (existing) {
+      return streamJsonError(
+        "CONFLICT_EXISTS",
+        "Stream already exists",
+        409,
+        publicStreamHeaders({
+          path: path.value,
+          contentType: existing.contentType,
+          startOffset: "-1",
+          offset: existing.currentOffset,
+          upToDate: true,
+          closed: existing.closed,
+          ttlSeconds: existing.ttlSeconds,
+          expiresAt: existing.expiresAt
+        })
+      );
+    }
+    const parsed = streamCreateHeaders(c);
+    if (!parsed.ok) return streamText(parsed.message, 400);
+    const fork = streamForkHeaders(c);
+    if (!fork.ok) return streamText(fork.message, 400);
+    const body = new Uint8Array(await c.req.raw.arrayBuffer());
+    try {
+      const { record, created } = await persistence.streams.create(path.value, {
+        contentType: parsed.contentType,
+        ttlSeconds: parsed.ttlSeconds,
+        expiresAt: parsed.expiresAt,
+        initialData: body.length ? body : void 0,
+        closed: parsed.closed,
+        fork: fork.fork
+      });
+      if (!created) {
+        return streamJsonError(
+          "CONFLICT_EXISTS",
+          "Stream already exists",
+          409,
+          publicStreamHeaders({
+            path: path.value,
+            contentType: record.contentType,
+            startOffset: "-1",
+            offset: record.currentOffset,
+            upToDate: true,
+            closed: record.closed,
+            ttlSeconds: record.ttlSeconds,
+            expiresAt: record.expiresAt
+          })
+        );
+      }
+      if (body.length > 0) {
+        const messages = await persistence.streams.messages(path.value);
+        await persistence.subscriptions?.notifyStreamAppend(path.value, messages[messages.length - 1]);
+      }
+      const headers = publicStreamHeaders({
+        path: path.value,
+        contentType: record.contentType,
+        startOffset: "-1",
+        offset: record.currentOffset,
+        upToDate: true,
+        closed: record.closed,
+        ttlSeconds: record.ttlSeconds,
+        expiresAt: record.expiresAt
+      });
+      if (created) headers.location = new URL(`/streams/${encodePublicStreamPath(path.value)}`, c.req.url).toString();
+      return new Response(null, { status: created ? 201 : 200, headers });
+    } catch (err) {
+      return streamError(err);
+    }
+  });
+  app.get("/streams/*", async (c) => {
+    const path = publicStreamPath(c);
+    if (!path.ok) return streamText(path.message, path.status);
+    let record = await persistence.streams.get(path.value);
+    if (!record) return streamText("Stream not found", 404);
+    let messages = await persistence.streams.messages(path.value);
+    if (c.req.method === "HEAD") {
+      return new Response(null, {
+        status: 200,
+        headers: publicStreamHeaders({
+          path: path.value,
+          contentType: record.contentType,
+          startOffset: "-1",
+          offset: record.currentOffset,
+          upToDate: true,
+          closed: record.closed,
+          cursor: publicStreamCursorToken(path.value, record.currentOffset, record.closed),
+          head: true,
+          ttlSeconds: record.ttlSeconds,
+          expiresAt: record.expiresAt
+        })
+      });
+    }
+    const cursor = publicStreamCursor(c, record, path.value);
+    if (!cursor.ok) return streamText(cursor.message, 400);
+    const after = cursor.value;
+    const live = c.req.query("live");
+    if ((live === "long-poll" || live === "sse") && c.req.query("offset") == null && c.req.query("cursor") == null && c.req.header("last-event-id") == null) {
+      return streamText("live reads require offset", 400);
+    }
+    if (live === "sse") return streamPublicDurableStream(c, persistence, path.value, record, messages, after);
+    if (live === "long-poll" && isStreamCaughtUp(after, messages)) {
+      let timedOut = false;
+      if (!record.closed) {
+        const waited = await waitForPublicStreamMessages(persistence, path.value, after, longPollTimeoutMs(c));
+        record = waited.record ?? record;
+        messages = waited.messages;
+        timedOut = waited.timedOut;
+      }
+      if (timedOut || record.closed && isStreamCaughtUp(after, messages)) {
+        const offset = publicStreamTailOffset(messages, after);
+        return new Response(null, {
+          status: 204,
+          headers: publicStreamHeaders({
+            path: path.value,
+            contentType: record.contentType,
+            startOffset: formatEventOffset(after),
+            offset,
+            upToDate: true,
+            closed: record.closed,
+            cursor: publicStreamCursorToken(path.value, offset, record.closed),
+            ttlSeconds: record.ttlSeconds,
+            expiresAt: record.expiresAt
+          })
+        });
+      }
+    }
+    const { items, nextOffset, upToDate } = selectStreamMessagesAfter(messages, after, eventLimit(c));
+    return new Response(publicStreamBody(record, items), {
+      status: 200,
+      headers: publicStreamHeaders({
+        path: path.value,
+        contentType: record.contentType,
+        startOffset: formatEventOffset(after),
+        offset: nextOffset,
+        upToDate,
+        closed: record.closed && upToDate,
+        cursor: live === "long-poll" ? publicStreamCursorToken(path.value, nextOffset, record.closed && upToDate) : void 0,
+        ttlSeconds: record.ttlSeconds,
+        expiresAt: record.expiresAt
+      })
+    });
+  });
+  app.post("/streams/*", async (c) => {
+    const path = publicStreamPath(c);
+    if (!path.ok) return streamText(path.message, path.status);
+    const producer = streamProducerHeaders(c);
+    if (!producer.ok) return streamText(producer.message, 400);
+    const seq = streamSeqHeader(c);
+    if (!seq.ok) return streamText(seq.message, 400);
+    const close = c.req.header(STREAM_CLOSED_HEADER)?.toLowerCase() === "true";
+    const body = new Uint8Array(await c.req.raw.arrayBuffer());
+    const record = await persistence.streams.get(path.value);
+    if (!record) return streamText("Stream not found", 404);
+    if (body.length === 0 && close) {
+      if (seq.value !== void 0) return streamText(`${STREAM_SEQ_HEADER} requires a non-empty append body`, 400);
+      if (producer.producer) {
+        const closed2 = await persistence.streams.closeWithProducer(path.value, producer.producer);
+        if (!closed2) return streamText("Stream not found", 404);
+        return streamProducerWriteResponse({ path: path.value, producer: producer.producer, result: closed2, acceptedStatus: 200 });
+      }
+      const closed = await persistence.streams.close(path.value);
+      if (!closed) return streamText("Stream not found", 404);
+      return new Response(null, {
+        status: 204,
+        headers: publicStreamHeaders({
+          path: path.value,
+          contentType: closed.contentType,
+          startOffset: "-1",
+          offset: closed.currentOffset,
+          upToDate: true,
+          closed: true,
+          ttlSeconds: closed.ttlSeconds,
+          expiresAt: closed.expiresAt
+        })
+      });
+    }
+    if (body.length === 0) return streamText("Empty body", 400);
+    if (record.closed && !producer.producer) {
+      return streamText(
+        "Stream is closed",
+        409,
+        publicStreamHeaders({ path: path.value, contentType: record.contentType, startOffset: "-1", offset: record.currentOffset, upToDate: true, closed: true })
+      );
+    }
+    const contentType = c.req.header("content-type");
+    if (!contentType) return streamText("Content-Type header is required", 400);
+    try {
+      if (producer.producer) {
+        const appended2 = await persistence.streams.appendWithProducer(path.value, body, { contentType, close, producer: producer.producer, seq: seq.value });
+        if (!appended2) return streamText("Stream not found", 404);
+        if (appended2.message && appended2.producerResult?.status === "accepted") await persistence.subscriptions?.notifyStreamAppend(path.value, appended2.message);
+        return streamProducerWriteResponse({
+          path: path.value,
+          producer: producer.producer,
+          result: appended2,
+          acceptedStatus: 200,
+          offset: appended2.message?.offset
+        });
+      }
+      const appended = await persistence.streams.append(path.value, body, { contentType, close, seq: seq.value });
+      if (!appended) return streamText("Stream not found", 404);
+      await persistence.subscriptions?.notifyStreamAppend(path.value, appended.message);
+      return new Response(null, {
+        status: 204,
+        headers: publicStreamHeaders({
+          path: path.value,
+          contentType: appended.record.contentType,
+          startOffset: "-1",
+          offset: appended.message.offset,
+          upToDate: true,
+          closed: appended.record.closed,
+          ttlSeconds: appended.record.ttlSeconds,
+          expiresAt: appended.record.expiresAt
+        })
+      });
+    } catch (err) {
+      const latest = await persistence.streams.get(path.value);
+      return streamError(
+        err,
+        latest ? publicStreamHeaders({ path: path.value, contentType: latest.contentType, startOffset: "-1", offset: latest.currentOffset, upToDate: true, closed: latest.closed }) : void 0
+      );
+    }
+  });
+  app.delete("/streams/*", async (c) => {
+    const path = publicStreamPath(c);
+    if (!path.ok) return streamText(path.message, path.status);
+    const deleted = await persistence.streams.delete(path.value);
+    if (deleted) await persistence.subscriptions?.notifyStreamDelete(path.value);
+    return deleted ? new Response(null, { status: 204 }) : streamText("Stream not found", 404);
+  });
+  app.post("/runs/:runId/approve", async (c) => {
+    const runId = c.req.param("runId");
+    const record = await persistence.runs.get(runId);
+    const body = await safeJson(c.req.raw);
+    if (!record) return c.json({ ok: false, error: { code: "not_found", message: "no such run" } }, 404);
+    if (record.kind === "workflow") {
+      const mount = workflows[record.agent];
+      if (!mount) return c.json({ ok: false, error: { code: "unknown_workflow", message: `workflow "${record.agent}" is not registered` } }, 404);
+      const gate = body?.gate ?? waitingGate(mount.def, record)?.id;
+      if (!gate || typeof body?.approved !== "boolean") {
+        return c.json({ ok: false, error: { code: "bad_request", message: 'body must include {"approved": true|false} (and optionally "gate", "note")' } }, 400);
+      }
+      try {
+        const result = await approveGate(mount.def, workflowCtx(requestEnv(c), mount), runId, { gate, approved: body.approved, note: body?.note });
+        return c.json({ ok: result.status !== "failed", runId, status: result.status, ...result.gate ? { gate: result.gate } : {}, ...result.text !== void 0 ? { data: result.text } : {} });
+      } catch (err) {
+        return c.json({ ok: false, error: { code: "approve_failed", message: err instanceof Error ? err.message : String(err) } }, 409);
+      }
+    }
+    const pending = waitingToolApproval(record);
+    if (!pending) return c.json({ ok: false, error: { code: "not_waiting_approval", message: `Run "${runId}" has no pending tool approval.` } }, 409);
+    if (typeof body?.approved !== "boolean") {
+      return c.json({ ok: false, error: { code: "bad_request", message: 'body must include {"approved": true|false} (and optionally "approval", "note")' } }, 400);
+    }
+    const agent = agents[record.agent];
+    if (!agent) return c.json({ ok: false, error: { code: "unknown_agent", message: `agent "${record.agent}" is not registered` } }, 404);
+    try {
+      const { state, approval } = decideToolApprovalState(record, {
+        approval: typeof body?.approval === "string" ? body.approval : pending.id,
+        approved: body.approved,
+        note: body.note
+      });
+      if (!body.approved) {
+        const endedAt = Date.now();
+        await persistence.runs.update(runId, {
+          status: "failed",
+          state,
+          error: { code: "tool_rejected", message: `Tool "${approval.tool}" was rejected${approval.note ? `: ${approval.note}` : "."}` },
+          endedAt
+        });
+        await appendRouteEvent(persistence, runId, { type: "tool_approval_decided", approval: approval.id, tool: approval.tool, approved: false, runId, timestamp: endedAt });
+        await appendRouteEvent(persistence, runId, { type: "run_error", code: "tool_rejected", message: `Tool "${approval.tool}" was rejected.`, runId, timestamp: endedAt });
+        await appendRouteEvent(persistence, runId, { type: "run_end", ok: false, runId, timestamp: endedAt });
+        return c.json({ ok: false, runId, status: "failed", approval: publicToolApproval(approval) }, 409);
+      }
+      await persistence.runs.update(runId, { status: "running", state, error: void 0, endedAt: void 0 });
+      try {
+        const result = await invokeAgent({
+          agent,
+          agentName: record.agent,
+          instanceId: record.instanceId,
+          runId,
+          runResume: true,
+          message: record.message,
+          payload: record.payload,
+          images: record.images,
+          persistence,
+          env: requestEnv(c),
+          ...shared
+        });
+        return c.json({ ok: true, runId, status: "success", data: result.text, result: result.data, usage: result.usage });
+      } catch (err) {
+        if (isToolApprovalRequiredError(err)) return toolApprovalWaitingResponse(c, err);
+        return c.json({ ok: false, ...errorPayload(err) }, 500);
+      }
+    } catch (err) {
+      return c.json({ ok: false, error: { code: "approve_failed", message: err instanceof Error ? err.message : String(err) } }, 409);
+    }
+  });
+  app.get("/admin/agents", (c) => c.json({ items: Object.keys(agents).map((name) => ({ name })) }));
+  app.get("/admin/runs", async (c) => {
+    const status = runStatus(c.req.query("status"));
+    if (status === false) return c.json({ ok: false, error: { code: "bad_request", message: "status must be queued, running, waiting_approval, success, failed, or interrupted" } }, 400);
+    const limit = runListLimit(c);
+    const agent = nonEmpty(c.req.query("agent"));
+    return c.json({ items: await persistence.runs.list({ limit, ...status ? { status } : {}, ...agent ? { agent } : {} }) });
+  });
+  app.get("/admin/runs/:runId", async (c) => {
+    const run = await persistence.runs.get(c.req.param("runId"));
+    return run ? c.json(run) : c.json({ ok: false, error: { code: "not_found", message: "no such run" } }, 404);
+  });
+  app.get("/admin/runs/:runId/events", async (c) => {
+    return c.json({ items: await persistence.runs.events(c.req.param("runId")) });
+  });
+  if (options.metrics) {
+    app.get("/admin/metrics", (c) => c.json({ ok: true, metrics: options.metrics.snapshot() }));
+  }
+  return app;
+}
+async function safeJson(req) {
+  try {
+    return await req.json();
+  } catch {
+    return void 0;
+  }
+}
+async function safeJsonValue(req) {
+  try {
+    return await req.json();
+  } catch {
+    return void 0;
+  }
+}
+function promptImages(value) {
+  if (value === void 0) return { ok: true, value: void 0 };
+  if (!Array.isArray(value)) return { ok: false, message: "images must be an array" };
+  const images = [];
+  for (const [index, item] of value.entries()) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return { ok: false, message: `images[${index}] must be an object` };
+    const record = item;
+    const rawData = typeof record.data === "string" ? record.data : typeof record.data_base64 === "string" ? record.data_base64 : void 0;
+    if (!rawData) return { ok: false, message: `images[${index}].data must be a base64 string or data URL` };
+    const parsed = parseImageData(rawData);
+    const mimeType = parsed.mimeType ?? (typeof record.mime_type === "string" ? record.mime_type : typeof record.mimeType === "string" ? record.mimeType : void 0);
+    if (!mimeType || !/^image\/[A-Za-z0-9.+-]+$/.test(mimeType)) return { ok: false, message: `images[${index}].mime_type must be an image MIME type` };
+    if (!isLikelyBase64(parsed.data)) return { ok: false, message: `images[${index}].data must be base64 encoded` };
+    images.push({ data: parsed.data, mimeType });
+  }
+  return { ok: true, value: images };
+}
+function parseImageData(value) {
+  const trimmed = value.trim();
+  const match = /^data:([^;,]+)(?:;[^,]*)?;base64,(.*)$/is.exec(trimmed);
+  if (match) return { mimeType: match[1], data: match[2].replace(/\s/g, "") };
+  return { data: trimmed.replace(/\s/g, "") };
+}
+function isLikelyBase64(value) {
+  return value.length > 0 && value.length % 4 === 0 && /^[A-Za-z0-9+/]+={0,2}$/.test(value);
+}
+async function readJsonObject(req) {
+  try {
+    const value = await req.json();
+    return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function durableStreamMode(c) {
+  const format = c.req.query("format");
+  if (format === "atlas") return false;
+  if (format === "stream") return true;
+  const live = c.req.query("live");
+  if (live === "long-poll" || live === "sse") return true;
+  return (c.req.query("offset") != null || c.req.query("cursor") != null) && c.req.query("limit") == null && c.req.query("tail") == null && c.req.query("follow") == null && c.req.query("after") == null && c.req.query("since") == null;
+}
+function jsonResponse(body, options = {}) {
+  return new Response(JSON.stringify(body), {
+    status: options.status ?? 200,
+    headers: { "content-type": "application/json", ...options.headers ?? {} }
+  });
+}
+function subscriptionJsonError(status, code, message, extra = {}) {
+  return jsonResponse({ error: { code, message, ...extra } }, { status });
+}
+function subscriptionStoreError(result) {
+  if (result.ok) throw new Error("subscriptionStoreError called with an ok result");
+  const { code, message, currentHolder, generation } = result.error;
+  return jsonResponse(
+    {
+      error: {
+        code,
+        message,
+        ...currentHolder !== void 0 ? { current_holder: currentHolder } : {},
+        ...generation !== void 0 ? { generation } : {}
+      }
+    },
+    { status: result.status }
+  );
+}
+async function subscriptionCreateInput(c) {
+  const body = await readJsonObject(c.req.raw);
+  if (!body) return { ok: false, message: "Request body must be a JSON object" };
+  if (body.type !== "pull-wake" && body.type !== "webhook") return { ok: false, message: 'type must be "pull-wake" or "webhook"' };
+  const pattern = typeof body.pattern === "string" && body.pattern.length > 0 ? normalizeSubscriptionRoutePath(body.pattern) : void 0;
+  const streams = Array.isArray(body.streams) && body.streams.length > 0 ? body.streams.map((stream) => typeof stream === "string" ? normalizeSubscriptionRoutePath(stream) : null) : [];
+  if (streams.some((stream) => stream === null)) return { ok: false, message: "streams must contain only strings" };
+  if (!pattern && streams.length === 0) return { ok: false, message: "At least one of pattern or streams is required" };
+  if (body.type === "webhook") {
+    const webhookUrl = typeof body.webhook_url === "string" ? body.webhook_url : typeof body.url === "string" ? body.url : void 0;
+    if (!webhookUrl || !isHttpUrl(webhookUrl)) return { ok: false, message: "webhook subscriptions require an http(s) webhook_url" };
+    const headers = subscriptionWebhookHeaders(body.webhook_headers ?? body.headers);
+    if (!headers.ok) return { ok: false, message: headers.message };
+    return {
+      ok: true,
+      value: {
+        type: "webhook",
+        ...pattern ? { pattern } : {},
+        streams,
+        webhookUrl,
+        ...Object.keys(headers.value).length > 0 ? { webhookHeaders: headers.value } : {},
+        ...typeof body.description === "string" ? { description: body.description } : {}
+      }
+    };
+  }
+  const wakeStream = typeof body.wake_stream === "string" && body.wake_stream.length > 0 ? normalizeSubscriptionRoutePath(body.wake_stream) : void 0;
+  if (!wakeStream) return { ok: false, message: "pull-wake subscriptions require wake_stream" };
+  const leaseTtl = body.lease_ttl_ms === void 0 ? DEFAULT_SUBSCRIPTION_LEASE_TTL_MS : body.lease_ttl_ms;
+  if (typeof leaseTtl !== "number" || !Number.isInteger(leaseTtl) || leaseTtl < MIN_SUBSCRIPTION_LEASE_TTL_MS || leaseTtl > MAX_SUBSCRIPTION_LEASE_TTL_MS) {
+    return { ok: false, message: "lease_ttl_ms must be an integer from 1000 to 600000" };
+  }
+  return {
+    ok: true,
+    value: {
+      type: "pull-wake",
+      ...pattern ? { pattern } : {},
+      streams,
+      wakeStream,
+      leaseTtlMs: leaseTtl,
+      ...typeof body.description === "string" ? { description: body.description } : {}
+    }
+  };
+}
+function subscriptionResponse(record) {
+  return {
+    id: record.id,
+    subscription_id: record.id,
+    type: record.type,
+    pattern: record.pattern,
+    streams: record.streams.map((stream) => ({
+      path: stream.path,
+      link_type: stream.linkTypes.includes("explicit") ? "explicit" : "glob",
+      acked_offset: stream.ackedOffset
+    })),
+    wake_stream: record.wakeStream,
+    lease_ttl_ms: record.leaseTtlMs,
+    webhook_url: record.webhookUrl,
+    webhook_last_success_at: record.webhookLastSuccessAt,
+    webhook_last_error: record.webhookLastError,
+    created_at: record.createdAt,
+    status: record.status,
+    description: record.description
+  };
+}
+function subscriptionClaimResponse(claim) {
+  return {
+    wake_id: claim.wakeId,
+    generation: claim.generation,
+    token: claim.token,
+    streams: claim.streams.map(subscriptionStreamInfoResponse),
+    lease_ttl_ms: claim.leaseTtlMs
+  };
+}
+function subscriptionStreamInfoResponse(stream) {
+  return {
+    path: stream.path,
+    link_type: stream.linkType,
+    acked_offset: stream.ackedOffset,
+    tail_offset: stream.tailOffset,
+    has_pending: stream.hasPending
+  };
+}
+function subscriptionAckInput(input) {
+  const body = input ?? {};
+  const rawAcks = Array.isArray(body.acks) ? body.acks : void 0;
+  return {
+    wakeId: typeof body.wake_id === "string" ? body.wake_id : typeof body.wakeId === "string" ? body.wakeId : void 0,
+    generation: typeof body.generation === "number" && Number.isInteger(body.generation) ? body.generation : void 0,
+    acks: rawAcks?.map((ack) => {
+      const item = ack && typeof ack === "object" ? ack : {};
+      return {
+        ...typeof item.stream === "string" ? { stream: item.stream } : {},
+        ...typeof item.path === "string" ? { path: item.path } : {},
+        offset: typeof item.offset === "string" ? item.offset : ""
+      };
+    }),
+    done: body.done === true
+  };
+}
+function bearerToken(c) {
+  const header = c.req.header("subscription-token") ?? c.req.header("x-subscription-token") ?? c.req.header("authorization");
+  if (!header) return null;
+  return header.startsWith("Bearer ") ? header.slice("Bearer ".length) : header;
+}
+function errorPayload(err) {
+  return {
+    error: {
+      code: typeof err?.code === "string" ? err.code : "agent_error",
+      message: err instanceof Error ? err.message : String(err)
+    }
+  };
+}
+function toolApprovalWaitingResponse(c, err) {
+  return c.json({ ok: true, runId: err.runId, status: "waiting_approval", approval: publicToolApproval(err.approval) }, 202);
+}
+function publicToolApproval(approval) {
+  return {
+    id: approval.id,
+    tool: approval.tool,
+    arguments: approval.arguments,
+    ...approval.reason ? { reason: approval.reason } : {},
+    requestedAt: approval.requestedAt,
+    status: approval.status
+  };
+}
+async function appendRouteEvent(persistence, runId, event) {
+  const index = await persistence.runs.eventCount?.(runId) ?? (await persistence.runs.events(runId)).length;
+  await persistence.runs.appendEvent(runId, { ...event, index, timestamp: event.timestamp ?? Date.now() });
+}
+function channelEnvelope(result) {
+  const record = objectRecord(result);
+  if (!record) return { ok: false, message: "channel handler must return a dispatch envelope or Response" };
+  const dispatch = objectRecord(record.dispatch) ? record.dispatch : record;
+  if (typeof dispatch.continuationToken !== "string" || !dispatch.continuationToken.trim()) {
+    return { ok: false, message: "channel dispatch must include a non-empty continuationToken" };
+  }
+  if (dispatch.agent !== void 0 && typeof dispatch.agent !== "string") return { ok: false, message: "channel dispatch agent must be a string" };
+  if (dispatch.message !== void 0 && typeof dispatch.message !== "string") return { ok: false, message: "channel dispatch message must be a string" };
+  if (dispatch.runId !== void 0 && typeof dispatch.runId !== "string") return { ok: false, message: "channel dispatch runId must be a string" };
+  if (dispatch.mode !== void 0 && dispatch.mode !== "background" && dispatch.mode !== "sync") {
+    return { ok: false, message: "channel dispatch mode must be background or sync" };
+  }
+  const status = typeof record.status === "number" && Number.isInteger(record.status) ? record.status : void 0;
+  return { ok: true, dispatch, response: "dispatch" in record ? record.response : void 0, status };
+}
+function channelResponseFields(value) {
+  if (value === void 0) return {};
+  const record = objectRecord(value);
+  return record ? { response: record } : { response: value };
+}
+function channelStatus(status) {
+  switch (status) {
+    case 200:
+    case 201:
+    case 202:
+    case 400:
+    case 401:
+    case 403:
+    case 404:
+    case 409:
+    case 422:
+    case 500:
+      return status;
+    default:
+      return 202;
+  }
+}
+function objectRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function subscriptionStreamRoutePath(c) {
+  const marker = `/streams/__ds/subscriptions/${encodeURIComponent(c.req.param("subscriptionId") ?? "")}/streams/`;
+  const pathname = new URL(c.req.url).pathname;
+  const raw = pathname.startsWith(marker) ? pathname.slice(marker.length) : "";
+  return normalizeSubscriptionRoutePath(decodeURIComponent(raw));
+}
+function normalizeSubscriptionRoutePath(path) {
+  return path.replace(/^\/+/, "").replace(/\/+$/, "").split("/").filter((part) => part.length > 0 && part !== "." && part !== "..").join("/");
+}
+function isHttpUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function subscriptionWebhookHeaders(value) {
+  if (value === void 0) return { ok: true, value: {} };
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { ok: false, message: "webhook headers must be an object" };
+  const headers = {};
+  for (const [key, headerValue] of Object.entries(value)) {
+    if (typeof headerValue !== "string") return { ok: false, message: "webhook headers must contain only string values" };
+    if (!/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(key)) return { ok: false, message: `Invalid webhook header name: ${key}` };
+    headers[key] = headerValue;
+  }
+  return { ok: true, value: headers };
+}
+async function streamDurableEvents(c, persistence, run, initialEvents, after) {
+  const runId = run.runId;
+  return streamSSE(c, async (stream) => {
+    let cursor = after;
+    let aborted = false;
+    let lastControlAt = 0;
+    stream.onAbort(() => {
+      aborted = true;
+    });
+    let latest = run;
+    let knownEvents = initialEvents;
+    for (; ; ) {
+      const events = knownEvents.filter((event) => event.index > cursor).sort((a, b) => a.index - b.index);
+      for (const event of events) {
+        cursor = event.index;
+        await stream.writeSSE({ event: "data", data: JSON.stringify(withOffset(event)) });
+      }
+      latest = await persistence.runs.get(runId) ?? void 0;
+      const closed = !latest || isEventStreamClosed(latest, knownEvents);
+      const offset = formatEventOffset(cursor);
+      const upToDate = isCaughtUp(cursor, knownEvents);
+      const now = Date.now();
+      if (events.length > 0 || closed || lastControlAt === 0 || now - lastControlAt > 15e3) {
+        const control = { streamNextOffset: offset };
+        if (closed && upToDate) control.streamClosed = true;
+        else {
+          control.streamCursor = streamCursor(runId, offset, false);
+          if (upToDate) control.upToDate = true;
+        }
+        await stream.writeSSE({ event: "control", data: JSON.stringify(control) });
+        lastControlAt = now;
+      }
+      if (aborted || closed && upToDate) break;
+      await routeSleep(250);
+      knownEvents = (await persistence.runs.events(runId)).sort((a, b) => a.index - b.index);
+    }
+  });
+}
+async function streamPublicDurableStream(c, persistence, path, initialRecord, initialMessages, after) {
+  const binarySse = !isSseTextCompatibleStreamContentType(initialRecord.contentType);
+  if (binarySse) c.header(STREAM_SSE_DATA_ENCODING_HEADER, "base64");
+  return streamSSE(c, async (stream) => {
+    let cursor = after;
+    let aborted = false;
+    let lastControlAt = 0;
+    let record = initialRecord;
+    let messages = initialMessages;
+    stream.onAbort(() => {
+      aborted = true;
+    });
+    for (; ; ) {
+      const next = messages.filter((message) => message.index > cursor).sort((a, b) => a.index - b.index);
+      for (const message of next) {
+        cursor = message.index;
+        for (const data of publicStreamSseData(record, message, binarySse)) {
+          await stream.writeSSE({ event: "data", data });
+        }
+      }
+      record = await persistence.streams.get(path) ?? record;
+      const offset = formatEventOffset(cursor);
+      const upToDate = isStreamCaughtUp(cursor, messages);
+      const now = Date.now();
+      if (next.length > 0 || record.closed || lastControlAt === 0 || now - lastControlAt > 15e3) {
+        const control = { streamNextOffset: offset };
+        if (record.closed && upToDate) control.streamClosed = true;
+        else {
+          control.streamCursor = publicStreamCursorToken(path, offset, false);
+          if (upToDate) control.upToDate = true;
+        }
+        await stream.writeSSE({ event: "control", data: JSON.stringify(control) });
+        lastControlAt = now;
+      }
+      if (aborted || record.closed && upToDate) break;
+      await routeSleep(250);
+      messages = await persistence.streams.messages(path);
+    }
+  });
+}
+async function waitForPublicStreamMessages(persistence, path, after, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let record = await persistence.streams.get(path) ?? void 0;
+  let messages = await persistence.streams.messages(path);
+  while (Date.now() < deadline && record && !record.closed && isStreamCaughtUp(after, messages)) {
+    await routeSleep(100);
+    record = await persistence.streams.get(path) ?? void 0;
+    messages = await persistence.streams.messages(path);
+  }
+  return { record, messages, timedOut: isStreamCaughtUp(after, messages) && (!record || !record.closed) };
+}
+async function waitForRunEvents(persistence, runId, after, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let run = await persistence.runs.get(runId) ?? void 0;
+  let events = (await persistence.runs.events(runId)).sort((a, b) => a.index - b.index);
+  while (Date.now() < deadline && run && !isEventStreamClosed(run, events) && isCaughtUp(after, events)) {
+    await routeSleep(100);
+    run = await persistence.runs.get(runId) ?? void 0;
+    events = (await persistence.runs.events(runId)).sort((a, b) => a.index - b.index);
+  }
+  return { run, events, timedOut: isCaughtUp(after, events) && (!run || !isEventStreamClosed(run, events)) };
+}
+function eventCursor(c, runId, events) {
+  const cursor = c.req.query("cursor");
+  if (cursor != null) {
+    try {
+      const value = parseScopedCursor(cursor, "run", runId);
+      const rawOffset = c.req.query("offset");
+      if (rawOffset && rawOffset !== "now" && parseEventOffset(rawOffset) !== value) {
+        return {
+          ok: false,
+          error: {
+            code: "invalid_offset",
+            message: "event stream cursor does not match offset"
+          }
+        };
+      }
+      return { ok: true, value };
+    } catch (err) {
+      return {
+        ok: false,
+        error: {
+          code: "invalid_offset",
+          message: err instanceof Error ? err.message : `Invalid event stream cursor: ${cursor}`
+        }
+      };
+    }
+  }
+  const raw = c.req.header("last-event-id") ?? c.req.query("offset") ?? c.req.query("after") ?? c.req.query("since");
+  if (raw === "now") return { ok: true, value: events?.at(-1)?.index ?? -1 };
+  if (raw == null) return { ok: true, value: -1 };
+  try {
+    return { ok: true, value: parseEventOffset(raw) };
+  } catch (err) {
+    return {
+      ok: false,
+      error: {
+        code: "invalid_offset",
+        message: err instanceof Error ? err.message : `Invalid event stream offset: ${raw}`
+      }
+    };
+  }
+}
+function eventLimit(c) {
+  const raw = Number(c.req.query("limit") ?? "1000");
+  if (!Number.isFinite(raw) || raw <= 0) return 1e3;
+  return Math.min(Math.floor(raw), 1e3);
+}
+function eventTail(c) {
+  const raw = c.req.query("tail");
+  if (raw == null) return void 0;
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? Math.min(Math.floor(n), 1e3) : void 0;
+}
+function longPollTimeoutMs(c) {
+  const raw = Number(c.req.query("timeout") ?? DURABLE_STREAM_LONG_POLL_MS);
+  if (!Number.isFinite(raw) || raw <= 0) return DURABLE_STREAM_LONG_POLL_MS;
+  return Math.min(Math.floor(raw), DURABLE_STREAM_LONG_POLL_MS);
+}
+function publicStreamPath(c) {
+  const prefix = "/streams/";
+  const encoded = new URL(c.req.url).pathname.slice(prefix.length);
+  if (!encoded) return { ok: false, status: 400, message: "stream path is required" };
+  let value;
+  try {
+    value = decodeURIComponent(encoded);
+  } catch {
+    return { ok: false, status: 400, message: "stream path is not valid percent-encoding" };
+  }
+  return validatePublicStreamPath(value);
+}
+function validatePublicStreamPath(value) {
+  const parts = value.split("/");
+  if (value.length > 512 || parts.some((part) => part === "" || part === "." || part === "..")) {
+    return { ok: false, status: 400, message: "stream path is invalid" };
+  }
+  if (value === "__ds" || value.startsWith("__ds/")) {
+    return { ok: false, status: 400, message: "stream path uses a reserved prefix" };
+  }
+  return { ok: true, value };
+}
+function publicStreamReferencePath(raw, requestUrl) {
+  const value = raw.trim();
+  if (!value) return { ok: false, message: `${STREAM_FORKED_FROM_HEADER} is required` };
+  let encoded = value;
+  if (value.startsWith("/") || /^[a-z][a-z\d+.-]*:/i.test(value)) {
+    let pathname;
+    try {
+      pathname = new URL(value, requestUrl).pathname;
+    } catch {
+      return { ok: false, message: `${STREAM_FORKED_FROM_HEADER} is not a valid URL` };
+    }
+    const marker = "/streams/";
+    const index = pathname.indexOf(marker);
+    if (index < 0) return { ok: false, message: `${STREAM_FORKED_FROM_HEADER} must reference a /streams/* path` };
+    encoded = pathname.slice(index + marker.length);
+  }
+  let decoded;
+  try {
+    decoded = decodeURIComponent(encoded);
+  } catch {
+    return { ok: false, message: `${STREAM_FORKED_FROM_HEADER} is not valid percent-encoding` };
+  }
+  const path = validatePublicStreamPath(decoded);
+  return path.ok ? path : { ok: false, message: path.message };
+}
+function encodePublicStreamPath(path) {
+  return path.split("/").map(encodeURIComponent).join("/");
+}
+function streamCreateHeaders(c) {
+  const ttlRaw = c.req.header(STREAM_TTL_HEADER);
+  const expiresAt = c.req.header(STREAM_EXPIRES_AT_HEADER);
+  if (ttlRaw && expiresAt) return { ok: false, message: `Cannot specify both ${STREAM_TTL_HEADER} and ${STREAM_EXPIRES_AT_HEADER}` };
+  let ttlSeconds;
+  if (ttlRaw !== void 0) {
+    if (!/^(0|[1-9]\d*)$/.test(ttlRaw)) return { ok: false, message: `Invalid ${STREAM_TTL_HEADER} value` };
+    ttlSeconds = Number(ttlRaw);
+    if (!Number.isSafeInteger(ttlSeconds) || ttlSeconds < 0) return { ok: false, message: `Invalid ${STREAM_TTL_HEADER} value` };
+  }
+  if (expiresAt !== void 0 && Number.isNaN(new Date(expiresAt).getTime())) {
+    return { ok: false, message: `Invalid ${STREAM_EXPIRES_AT_HEADER} timestamp` };
+  }
+  return {
+    ok: true,
+    ...c.req.header("content-type") !== void 0 ? { contentType: normalizeStreamContentType(c.req.header("content-type") ?? void 0) } : {},
+    ...ttlSeconds !== void 0 ? { ttlSeconds } : {},
+    ...expiresAt !== void 0 ? { expiresAt } : {},
+    closed: c.req.header(STREAM_CLOSED_HEADER)?.toLowerCase() === "true"
+  };
+}
+function streamForkHeaders(c) {
+  const from = c.req.header(STREAM_FORKED_FROM_HEADER);
+  const offset = c.req.header(STREAM_FORK_OFFSET_HEADER);
+  if (from === void 0) {
+    if (offset !== void 0) return { ok: false, message: `${STREAM_FORK_OFFSET_HEADER} requires ${STREAM_FORKED_FROM_HEADER}` };
+    return { ok: true };
+  }
+  const path = publicStreamReferencePath(from, c.req.url);
+  if (!path.ok) return path;
+  return { ok: true, fork: { path: path.value, ...offset !== void 0 ? { offset } : {} } };
+}
+function streamProducerHeaders(c) {
+  const producerId = c.req.header(PRODUCER_ID_HEADER);
+  const epochRaw = c.req.header(PRODUCER_EPOCH_HEADER);
+  const seqRaw = c.req.header(PRODUCER_SEQ_HEADER);
+  const supplied = [producerId, epochRaw, seqRaw].filter((value) => value !== void 0).length;
+  if (supplied === 0) return { ok: true };
+  if (supplied !== 3) {
+    return { ok: false, message: `${PRODUCER_ID_HEADER}, ${PRODUCER_EPOCH_HEADER}, and ${PRODUCER_SEQ_HEADER} must be supplied together` };
+  }
+  const id = producerId?.trim();
+  if (!id) return { ok: false, message: `Invalid ${PRODUCER_ID_HEADER} value` };
+  const epoch = parseProducerInteger(epochRaw, PRODUCER_EPOCH_HEADER);
+  if (!epoch.ok) return epoch;
+  const seq = parseProducerInteger(seqRaw, PRODUCER_SEQ_HEADER);
+  if (!seq.ok) return seq;
+  return { ok: true, producer: { producerId: id, epoch: epoch.value, seq: seq.value } };
+}
+function streamSeqHeader(c) {
+  const seq = c.req.header(STREAM_SEQ_HEADER);
+  if (seq === void 0) return { ok: true };
+  if (seq.length === 0) return { ok: false, message: `Invalid ${STREAM_SEQ_HEADER} value` };
+  return { ok: true, value: seq };
+}
+function parseProducerInteger(value, header) {
+  if (value === void 0 || !/^(0|[1-9]\d*)$/.test(value)) return { ok: false, message: `Invalid ${header} value` };
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed < 0) return { ok: false, message: `Invalid ${header} value` };
+  return { ok: true, value: parsed };
+}
+function publicStreamCursor(c, record, path) {
+  const cursor = c.req.query("cursor");
+  if (cursor != null) {
+    try {
+      const value = parseScopedCursor(cursor, "stream", encodePublicStreamPath(path));
+      const rawOffset = c.req.query("offset");
+      if (rawOffset && rawOffset !== "now" && parsePublicStreamOffset(rawOffset) !== value) return { ok: false, message: "stream cursor does not match offset" };
+      return { ok: true, value };
+    } catch (err) {
+      return { ok: false, message: err instanceof Error ? err.message : `Invalid stream cursor: ${cursor}` };
+    }
+  }
+  const raw = c.req.header("last-event-id") ?? c.req.query("offset");
+  if (raw === "now") return { ok: true, value: parsePublicStreamOffset(record.currentOffset) };
+  if (raw == null) return { ok: true, value: -1 };
+  try {
+    return { ok: true, value: parsePublicStreamOffset(raw) };
+  } catch (err) {
+    return { ok: false, message: err instanceof Error ? err.message : `Invalid stream offset: ${raw}` };
+  }
+}
+function parsePublicStreamOffset(offset) {
+  try {
+    return parseEventOffset(offset);
+  } catch {
+    throw new Error(`Invalid stream offset: ${offset}`);
+  }
+}
+function parseScopedCursor(cursor, kind, scope) {
+  const prefix = `${kind}:${scope}:`;
+  if (!cursor.startsWith(prefix)) throw new Error(`Invalid ${kind} cursor scope`);
+  let offset = cursor.slice(prefix.length);
+  if (offset.endsWith(":closed")) offset = offset.slice(0, -":closed".length);
+  return parseEventOffset(offset);
+}
+function selectStreamMessagesAfter(messages, after, limit) {
+  const source = messages.filter((message) => message.index > after);
+  const items = source.slice(0, limit);
+  const lastDelivered = items.at(-1)?.index ?? after;
+  return { items, nextOffset: formatEventOffset(lastDelivered), upToDate: items.length >= source.length };
+}
+function publicStreamTailOffset(messages, fallback = -1) {
+  return formatEventOffset(messages.at(-1)?.index ?? fallback);
+}
+function isStreamCaughtUp(after, messages) {
+  return (messages.at(-1)?.index ?? -1) <= after;
+}
+function publicStreamBody(record, messages) {
+  if (isJsonStreamContentType(record.contentType)) {
+    return JSON.stringify(messages.flatMap(publicStreamJsonValues));
+  }
+  const chunks = messages.map(streamMessageBytes);
+  const size = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+  const merged = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    merged.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return merged;
+}
+function publicStreamJsonValues(message) {
+  const parsed = JSON.parse(new TextDecoder().decode(streamMessageBytes(message)));
+  return Array.isArray(parsed) ? parsed : [parsed];
+}
+function publicStreamSseData(record, message, binarySse = false) {
+  if (binarySse) return [bytesToBase64(streamMessageBytes(message))];
+  if (isJsonStreamContentType(record.contentType)) return publicStreamJsonValues(message).map((value) => JSON.stringify(value));
+  return [new TextDecoder().decode(streamMessageBytes(message))];
+}
+function isSseTextCompatibleStreamContentType(contentType) {
+  const normalized = normalizeStreamContentType(contentType);
+  return normalized === "application/json" || normalized.startsWith("text/");
+}
+function bytesToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 32768) {
+    binary += String.fromCharCode(...bytes.slice(i, i + 32768));
+  }
+  return btoa(binary);
+}
+function publicStreamHeaders(input) {
+  const headers = {
+    "content-type": input.contentType,
+    "cache-control": "no-store",
+    "access-control-expose-headers": STREAM_EXPOSE_HEADERS,
+    [STREAM_OFFSET_HEADER]: input.offset,
+    etag: publicStreamEtag(input.path, input.startOffset, input.offset, input.closed)
+  };
+  if (input.upToDate) headers[STREAM_UP_TO_DATE_HEADER] = "true";
+  if (input.closed) headers[STREAM_CLOSED_HEADER] = "true";
+  if (input.cursor && !input.closed) headers[STREAM_CURSOR_HEADER] = input.cursor;
+  if (input.ttlSeconds !== void 0) headers[STREAM_TTL_HEADER] = String(input.ttlSeconds);
+  if (input.expiresAt !== void 0) headers[STREAM_EXPIRES_AT_HEADER] = input.expiresAt;
+  if (input.head) headers["content-length"] = "0";
+  return headers;
+}
+function streamProducerWriteResponse(input) {
+  const record = input.result.record;
+  const producerResult = input.result.producerResult;
+  const headers = {
+    ...publicStreamHeaders({
+      path: input.path,
+      contentType: record.contentType,
+      startOffset: "-1",
+      offset: input.offset ?? record.currentOffset,
+      upToDate: true,
+      closed: record.closed,
+      ttlSeconds: record.ttlSeconds,
+      expiresAt: record.expiresAt
+    }),
+    ...streamProducerResultHeaders(input.producer, producerResult)
+  };
+  switch (producerResult?.status) {
+    case "accepted":
+      return new Response(null, { status: input.acceptedStatus, headers });
+    case "duplicate":
+      return new Response(null, { status: 204, headers });
+    case "stale_epoch":
+      return streamText("Stale producer epoch", 403, headers);
+    case "invalid_epoch_seq":
+      return streamText("New producer epoch must start with sequence 0", 400, headers);
+    case "sequence_gap":
+      return streamText("Producer sequence gap", 409, headers);
+    case "stream_closed":
+      return streamText("Stream is closed", 409, { ...headers, [STREAM_CLOSED_HEADER]: "true" });
+    default:
+      return streamText("Producer state error", 500, headers);
+  }
+}
+function streamProducerResultHeaders(producer, result) {
+  if (!result) return {};
+  switch (result.status) {
+    case "accepted":
+      return {
+        [PRODUCER_EPOCH_HEADER]: String(result.proposedState.epoch),
+        [PRODUCER_SEQ_HEADER]: String(result.proposedState.lastSeq)
+      };
+    case "duplicate":
+      return {
+        [PRODUCER_EPOCH_HEADER]: String(producer.epoch),
+        [PRODUCER_SEQ_HEADER]: String(producer.seq)
+      };
+    case "stale_epoch":
+      return { [PRODUCER_EPOCH_HEADER]: String(result.currentEpoch) };
+    case "sequence_gap":
+      return {
+        [PRODUCER_EXPECTED_SEQ_HEADER]: String(result.expectedSeq),
+        [PRODUCER_RECEIVED_SEQ_HEADER]: String(result.receivedSeq)
+      };
+    case "invalid_epoch_seq":
+    case "stream_closed":
+      return {};
+  }
+}
+function publicStreamCursorToken(path, offset, closed) {
+  return `stream:${encodePublicStreamPath(path)}:${offset}${closed ? ":closed" : ""}`;
+}
+function publicStreamEtag(path, startOffset, offset, closed) {
+  return `"stream:${encodePublicStreamPath(path)}:${startOffset}:${offset}${closed ? ":closed" : ""}"`;
+}
+function streamText(text, status, headers = {}) {
+  return new Response(text, { status, headers: { ...headers, "content-type": "text/plain" } });
+}
+function streamJsonError(code, message, status, headers = {}) {
+  return new Response(JSON.stringify({ ok: false, error: { code, message } }), {
+    status,
+    headers: { ...headers, "content-type": "application/json" }
+  });
+}
+function streamError(err, headers) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (message.includes("fork source not found")) return streamText("Fork source stream not found", 404, headers);
+  if (message.includes("Fork offset is beyond source tail")) return streamText("Fork offset is beyond source tail", 409, headers);
+  if (message.includes("already exists")) return streamJsonError("CONFLICT_EXISTS", "Stream already exists", 409, headers);
+  if (message.includes("Content-type mismatch")) return streamText("Content-type mismatch", 409, headers);
+  if (message.includes("stream is closed")) return streamText("Stream is closed", 409, { ...headers ?? {}, [STREAM_CLOSED_HEADER]: "true" });
+  if (message.includes("Stream sequence conflict")) return streamText("Stream sequence conflict", 409, headers);
+  if (message.includes("Invalid JSON")) return streamText("Invalid JSON", 400, headers);
+  if (message.includes("Invalid Stream-Seq")) return streamText("Invalid Stream-Seq", 400, headers);
+  if (message.includes("Empty arrays")) return streamText("Empty arrays are not allowed", 400, headers);
+  if (message.includes("limit exceeded")) return streamText("Stream message limit exceeded", 413, headers);
+  return streamText(message, 400, headers);
+}
+function runListLimit(c) {
+  const raw = Number(c.req.query("limit") ?? "50");
+  if (!Number.isFinite(raw) || raw <= 0) return 50;
+  return Math.min(Math.floor(raw), 1e3);
+}
+function runStatus(value) {
+  if (value == null || value === "") return void 0;
+  if (value === "queued" || value === "running" || value === "waiting_approval" || value === "success" || value === "failed" || value === "interrupted") return value;
+  return false;
+}
+function nonEmpty(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function selectEventsAfter(events, after, opts) {
+  const source = after === -1 && opts.tail != null ? events.slice(-opts.tail) : events.filter((event) => event.index > after);
+  const items = source.slice(0, opts.limit);
+  const lastDelivered = items.at(-1)?.index ?? after;
+  return {
+    items,
+    nextOffset: formatEventOffset(lastDelivered),
+    upToDate: items.length >= source.length
+  };
+}
+function withOffset(event) {
+  return { ...event, offset: formatEventOffset(event.index) };
+}
+function tailOffset(events, fallback = -1) {
+  return formatEventOffset(events.at(-1)?.index ?? fallback);
+}
+function isCaughtUp(after, events) {
+  return (events.at(-1)?.index ?? -1) <= after;
+}
+function isRunStreamClosed(status) {
+  return status === "success" || status === "failed" || status === "interrupted";
+}
+function isEventStreamClosed(run, events) {
+  return isRunStreamClosed(run.status) && events.some((event) => event.type === "run_end" || event.type === "run_error");
+}
+function routeSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function eventStreamHeaders(input) {
+  const headers = {
+    "content-type": "application/json",
+    "cache-control": "no-store",
+    "access-control-expose-headers": STREAM_EXPOSE_HEADERS,
+    [STREAM_OFFSET_HEADER]: input.offset,
+    etag: eventStreamEtag(input.runId, input.startOffset, input.offset, input.closed)
+  };
+  if (input.upToDate) headers[STREAM_UP_TO_DATE_HEADER] = "true";
+  if (input.closed) headers[STREAM_CLOSED_HEADER] = "true";
+  if (input.cursor && !input.closed) headers[STREAM_CURSOR_HEADER] = input.cursor;
+  if (input.head) headers["content-length"] = "0";
+  return headers;
+}
+function streamCursor(runId, offset, closed) {
+  return `run:${runId}:${offset}${closed ? ":closed" : ""}`;
+}
+function eventStreamEtag(runId, startOffset, offset, closed) {
+  return `"${runId}:${startOffset}:${offset}${closed ? ":closed" : ""}"`;
+}
+function streamCoordinates(c, runId) {
+  return {
+    streamUrl: new URL(`/runs/${encodeURIComponent(runId)}/events`, c.req.url).toString(),
+    offset: formatEventOffset(-1)
+  };
+}
+function buildWorkflowCtx(options, persistence, env, mount) {
+  return {
+    agents: options.agents,
+    profiles: [...mount.profiles ?? [], ...options.personas ?? options.subagents ?? []],
+    defaultModel: mount.defaultModel,
+    defaultPersona: mount.defaultPersona,
+    skills: mount.skills,
+    bindings: mount.bindings,
+    persistence,
+    engine: options.engine,
+    env,
+    baseInstructions: options.baseInstructions
+  };
+}
+async function recoverAppRuns(options, env) {
+  const persistence = options.persistence ?? getDefaultPersistence();
+  const recovered = await recoverRuns(options.agents, { persistence, engine: options.engine, env });
+  const workflows = normalizeWorkflows(options.workflows);
+  const running = await persistence.runs.list({ status: "running" });
+  for (const record of running) {
+    if (record.kind !== "workflow") continue;
+    const mount = workflows[record.agent];
+    if (!mount) {
+      await persistence.runs.update(record.runId, { status: "interrupted", endedAt: Date.now() });
+      continue;
+    }
+    void advanceWorkflow(mount.def, buildWorkflowCtx(options, persistence, env, mount), record.runId).catch(() => {
+    });
+    recovered.push(record.runId);
+  }
+  return recovered;
+}
+function normalizeWorkflows(input) {
+  const out = {};
+  for (const [name, value] of Object.entries(input ?? {})) {
+    out[name] = "def" in value ? value : { def: value };
+  }
+  return out;
+}
+function normalizeChannels(input) {
+  const out = {};
+  for (const [name, channel] of Object.entries(input ?? {})) {
+    if (!isChannelDefinition(channel)) throw new Error(`Invalid channel "${name}": expected defineChannel({ handle })`);
+    out[name] = channel;
+  }
+  return out;
+}
+function channelPath(name, channel) {
+  if (channel.path) return channel.path.startsWith("/") ? channel.path : `/channels/${channel.path}`;
+  if (!/^[A-Za-z0-9_-]+$/.test(name)) throw new Error(`Invalid channel name "${name}": use letters, numbers, underscores, or dashes`);
+  return `/channels/${name}`;
+}
+function channelMethods(channel) {
+  const methods = channel.methods?.length ? channel.methods : ["POST"];
+  return [...new Set(methods.map((method) => method.toUpperCase()))];
+}
+function singleAgentName(agents) {
+  const names = Object.keys(agents);
+  return names.length === 1 ? names[0] : void 0;
+}
+function createScheduledHandler(options) {
+  return async (event, env, ctx) => {
+    const persistence = options.persistenceFor?.(env ?? {}) ?? getDefaultPersistence();
+    const atlas = routeContext(
+      options.agents,
+      persistence,
+      { baseInstructions: options.baseInstructions, sharedPersonas: options.personas ?? options.subagents, engine: options.engine, durability: options.durability },
+      env
+    );
+    const when = new Date(event.scheduledTime ?? Date.now());
+    const dispatched = [];
+    for (const [name, trig] of Object.entries(options.triggers ?? {})) {
+      const cron = matchingTriggerCron(trig, event, when);
+      if (!cron || !options.agents[name]) continue;
+      const { runId, done } = await atlas.dispatch(name, {
+        payload: { trigger: "cron", cron, scheduledTime: when.getTime() }
+      });
+      ctx?.waitUntil?.(done);
+      dispatched.push({ agent: name, runId });
+    }
+    return { dispatched };
+  };
+}
+function matchingTriggerCron(trig, event, when) {
+  const crons = triggerCronList(trig);
+  if (!crons.length) return void 0;
+  if (event.cron && crons.includes(event.cron)) return event.cron;
+  for (const cron of crons) {
+    try {
+      if (cronMatches(cron, when)) return cron;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function triggerCronList(trig) {
+  const out = [];
+  if (typeof trig?.cron === "string" && trig.cron.trim()) out.push(trig.cron);
+  if (Array.isArray(trig?.crons)) {
+    for (const cron of trig.crons) {
+      if (typeof cron === "string" && cron.trim()) out.push(cron);
+    }
+  }
+  return [...new Set(out)];
+}
+export {
+  corsFromEnv,
+  createApp,
+  createScheduledHandler,
+  keepAlive,
+  mintScopedToken,
+  rateLimit,
+  rateLimitFromEnv,
+  recoverAppRuns,
+  requireApiKey,
+  scopedTokensFromEnv
+};