@agilesyndrome/cf-genai-base 4.1.2 → 5.0.0

package/src/index.js

@@ -1,291 +1,12 @@
 /**
- * Lean, opinionated Worker composition for Cloudflare sites.
- * Site code owns domain routes and data; this owns lifecycle and edge concerns.
+ * Public package surface. Runtime composition and platform services live in
+ * focused modules under ./runtime, ./core, ./auth, ./api, ./admin, and ./ui.
  */
-import { createImpersonationToken, ensureScopes, ensureSubscriptionManifest, ensureUser, getAuthorizationUser, hasScope, listAuthorizationScopes, listAuthorizationUsers, listGroups, listTenantSubscriptions, listUserGroups, listUserGrants, replaceUserGroups, replaceUserGrants, SubscriptionError } from "./authorization.js";
-import { getCircuitBreaker, evaluateCircuitBreaker, listCircuitBreakers, listHealthchecks, listFeatureCatalog, listFeatureHealth, registerFeatureManifests, requestActor, setCircuitBreaker, updateHealthcheck } from "./core.js";
-import { createDataReader, DataScopeError, normalizeDataResources, requestDataContext } from "./data.js";
-export * from "./core.js";
-export * from "./data.js";
-export * from "./authorization.js";
-const featureRegistrationPromises = new WeakMap();
-
-export function ensureFeatureManifests(env, features = [], { who = "system:update" } = {}) {
-  if (!env || typeof env !== "object" || !env.DB) return Promise.resolve();
-  const key = features.map((feature) => String(feature?.name || feature?.id || "feature")).join("|");
-  let registrations = featureRegistrationPromises.get(env.DB);
-  if (!registrations) {
-    registrations = new Map();
-    featureRegistrationPromises.set(env.DB, registrations);
-  }
-  let promise = registrations.get(key);
-  if (!promise) {
-    promise = (async () => {
-      await registerFeatureManifests(env, features, { who });
-      const breakers = await listCircuitBreakers(env, { who });
-      await Promise.all(breakers.filter(Boolean).map((breaker) => evaluateCircuitBreaker(env, breaker.id, { who })));
-    })();
-    registrations.set(key, promise);
-    promise.catch(() => registrations.delete(key));
-  }
-  return promise;
-}
-
-export function createWorker({ fetch, scheduled, auth, authorize, scopes = [], subscriptionManifest = [], scopeRoutes = [], middleware = [], features = [], dataResources = [], publicTenantId = null, health, boot, metrics, security = true, adminPage, siteAdminPage }) {
-  if (typeof fetch !== "function") throw new TypeError("createWorker requires a fetch handler");
-  const provider = auth || features.find((feature) => typeof feature?.getUser === "function");
-  const registeredDataResources = normalizeDataResources([...dataResources, ...features.flatMap((feature) => Array.isArray(feature?.dataResources) ? feature.dataResources : [])]);
-  const featureRoutes = features.flatMap((feature) => Array.isArray(feature?.routes) ? [async (request, env, ctx, next, state) => {
-    for (const route of feature.routes) {
-      const matches = typeof route?.match === "function" ? await route.match(request, env, state) : route?.path === new URL(request.url).pathname;
-      if (matches && typeof route.handle === "function") return route.handle({ request, env, ctx, state, next });
-    }
-    return next();
-  }] : []);
-  const chain = [
-            (request, env, ctx, next, state) => adminBoundary(request, env, ctx, next, state, { provider, authorize, scopes, scopeRoutes, features, adminPage, siteAdminPage }),
-    ...features.flatMap((feature) => feature?.middleware ? [feature.middleware.bind(feature)] : []),
-    ...featureRoutes,
-    ...middleware,
-    ...(auth ? [(request, env, ctx, next) => auth(request, env, ctx, next)] : []),
-  ].filter(Boolean);
-  return {
-    async fetch(request, env, ctx) {
-      try {
-        if (boot) await boot(env, { request, ctx });
-        if (subscriptionManifest.length) await ensureSubscriptionManifest(env, subscriptionManifest, { who: "system:update" });
-        const url = new URL(request.url);
-        const state = Object.create(null);
-        if (provider?.getUser) state.user = await provider.getUser(request, env).catch(() => null);
-        state.data = createDataReader(env, { resources: registeredDataResources, context: () => requestDataContext(env, { state, request, publicTenantId }) });
-        if (env?.DB && features.some((feature) => typeof feature?.healthcheck === "function" || feature?.healthchecks?.length || feature?.healthChecks?.length || feature?.circuitBreakers?.length || feature?.circuit_breakers?.length)) ctx?.waitUntil?.(ensureFeatureManifests(env, features).catch((error) => console.error("[EventLog] feature manifest registration failed", error)));
-        const dispatch = async (index, currentRequest = request) => {
-          const layer = chain[index];
-          if (!layer) {
-            if (url.pathname === "/health" || url.pathname === "/api/health") {
-              const details = health ? await health(env, { request: currentRequest, ctx, state }) : {};
-              const featureHealth = env?.DB ? await listFeatureHealth(env, { who: "system:read" }).catch(() => []) : [];
-              return healthResponse(env, featureHealth.length ? { ...details, features: featureHealth } : details);
-            }
-            if (url.pathname === "/api/tenant" && currentRequest.method === "GET") {
-              const context = await state.data.context();
-              if (!context.userId) return Response.json({ error: "Authentication is required." }, { status: 401 });
-              if (context.invalidTenant) return Response.json({ error: "The requested tenant is not available." }, { status: 400 });
-              return Response.json({ tenant: context.tenantId ? { id: context.tenantId, name: context.tenants?.find((tenant) => tenant.id === context.tenantId)?.name || null } : null, tenants: context.tenants || [] });
-            }
-            return fetch(currentRequest, env, ctx, state);
-          }
-          if (typeof layer !== "function") throw new TypeError("Worker middleware must be a function");
-          return layer(currentRequest, env, ctx, (nextRequest = currentRequest) => dispatch(index + 1, nextRequest), state);
-        };
-        const response = await dispatch(0);
-        if (metrics) metrics.request(request, response, env, ctx);
-        return security ? secureResponse(response) : response;
-      } catch (error) {
-        console.error("[worker] request failed", error);
-        if (error instanceof DataScopeError || error instanceof SubscriptionError) return secureResponse(Response.json({ error: error.message }, { status: 403, headers: { "Cache-Control": "no-store" } }));
-        return secureResponse(Response.json({ error: "Internal server error" }, { status: 500, headers: { "Cache-Control": "no-store" } }));
-      }
-    },
-    ...(scheduled ? { scheduled } : {}),
-  };
-}
-
-
-async function adminBoundary(request, env, ctx, next, state, { provider, authorize, scopes, scopeRoutes, features, adminPage, siteAdminPage }) {
-  const url = new URL(request.url);
-  if (!isAdminPath(url.pathname)) return next(request);
-  const strategy = String(env?.AUTH_STRATEGY || "http_basic").trim().toLowerCase();
-  if (strategy === "http_basic") {
-    const user = basicUser(request, env);
-    if (!user) return adminUnauthorized(request);
-    state.user = user;
-  } else if (strategy === "oauth") {
-    const user = provider?.getUser ? await provider.getUser(request, env) : null;
-    if (!user) return oauthUnauthorized(request, url);
-    state.user = user;
-  } else {
-    return new Response("Unsupported AUTH_STRATEGY", { status: 500, headers: { "Cache-Control": "no-store" } });
-  }
-  if (["POST", "PUT", "PATCH", "DELETE"].includes(request.method) && url.pathname.startsWith("/api/")) {
-    const origin = request.headers.get("Origin");
-    if (!origin || (() => { try { return new URL(origin).origin !== url.origin; } catch { return true; } })()) return Response.json({ error: "A same-origin request is required." }, { status: 403, headers: { "Cache-Control": "no-store" } });
-  }
-  await ensureScopes(env, scopes, { who: state.user?.auth_strategy === "http_basic" ? "user:admin" : `user:${state.user?.sub || "unknown"}` });
-  state.authUser = await ensureUser(env, state.user, { who: state.user?.auth_strategy === "http_basic" ? "user:admin" : `user:${state.user?.sub || "unknown"}` });
-  state.requestedBy = requestActor(state);
-  const requiredScope = requiredScopeFor(url.pathname, scopeRoutes);
-  const scopeAllowed = !requiredScope || await hasScope(env, state.user, requiredScope, { who: requestActor(state) });
-  if (!scopeAllowed || (authorize && state.user.auth_strategy !== "http_basic" && !(await authorize({ request, url, user: state.user, env, ctx, state })))) {
-    return url.pathname.startsWith("/api/") ? Response.json({ error: "Administrator access is required." }, { status: 403, headers: { "Cache-Control": "no-store" } }) : new Response("Administrator access is required.", { status: 403, headers: { "Cache-Control": "no-store" } });
-  }
-  const platformResponse = await authorizationApi(request, env, url, state, features);
-  if (platformResponse) return platformResponse;
-  if (request.method === "GET" && isSiteAdminPage(url.pathname) && typeof siteAdminPage === "function") {
-    const response = await siteAdminPage({ request, env, url, state, features });
-    if (response) return response;
-  }
-  if (request.method === "GET" && isPlatformAdminPage(url.pathname) && typeof adminPage === "function") {
-    if (!(state.user.auth_strategy === "http_basic" || (state.authUser && state.authUser.is_admin))) return new Response("Administrator access is required.", { status: 403, headers: { "Cache-Control": "no-store" } });
-    const response = await adminPage({ request, env, url, state, features });
-    if (response) return response;
-  }
-  if (url.pathname === "/admin/features" && request.method === "GET") {
-    if (!(state.user.auth_strategy === "http_basic" || (state.authUser && state.authUser.is_admin))) return new Response("Administrator access is required.", { status: 403, headers: { "Cache-Control": "no-store" } });
-    return featureCatalogPage(env, features, state);
-  }
-  return next(request);
-}
-
-function isPlatformAdminPage(pathname) {
-  return ["/admin/users", "/admin/scopes", "/admin/groups", "/admin/features", "/admin/healthchecks", "/admin/circuit-breakers"].includes(pathname);
-}
-
-function isSiteAdminPage(pathname) {
-  return pathname === "/admin/site" || pathname.startsWith("/admin/site/");
-}
-
-function requiredScopeFor(pathname, routes) {
-  const route = routes.find((entry) => typeof entry.match === "function" ? entry.match(pathname) : pathname === entry.path || pathname.startsWith(String(entry.path || "") + "/"));
-  return route && route.scope ? route.scope : null;
-}
-
-async function authorizationApi(request, env, url, state, features = []) {
-  const grantsMatch = url.pathname.match(/\/api\/admin\/users\/([^/]+)\/scopes$/);
-  const platformPath = url.pathname === "/api/admin/users" || url.pathname === "/api/admin/scopes" || url.pathname === "/api/admin/groups" || url.pathname.startsWith("/api/admin/users/") || url.pathname.startsWith("/api/admin/impersonate") || url.pathname === "/api/admin/status" || url.pathname === "/api/admin/features" || url.pathname === "/api/admin/healthchecks" || url.pathname === "/api/admin/circuit-breakers" || url.pathname.startsWith("/api/admin/healthchecks/") || url.pathname.startsWith("/api/admin/circuit-breakers/") || Boolean(grantsMatch);
-  if (!platformPath) return null;
-  if (!(state.user.auth_strategy === "http_basic" || (state.authUser && state.authUser.is_admin))) return Response.json({ error: "Administrator access is required." }, { status: 403, headers: { "Cache-Control": "no-store" } });
-  if (url.pathname === "/api/admin/impersonate/clear" && request.method === "POST") return new Response(JSON.stringify({ ok: true }), { headers: { "content-type": "application/json; charset=utf-8", "Set-Cookie": "__Host-cfgenai_impersonation=; Max-Age=0; Path=/; Secure; HttpOnly; SameSite=Lax" } });
-  if (url.pathname === "/api/admin/users" && request.method === "GET") return Response.json({ users: await listAuthorizationUsers(env, { who: requestActor(state) }) });
-  const impersonateMatch = url.pathname.match(/^\/api\/admin\/users\/([^/]+)\/impersonate$/);
-  if (impersonateMatch && request.method === "POST") {
-    const target = decodeURIComponent(impersonateMatch[1]);
-    const targetUser = await getAuthorizationUser(env, target, { who: requestActor(state) });
-    if (!targetUser) return Response.json({ error: "User not found." }, { status: 404 });
-    const token = await createImpersonationToken(env, state.authUser?.id || state.user?.sub || "admin", targetUser.id);
-    return new Response(JSON.stringify({ ok: true, user: { id: targetUser.id, email: targetUser.email, display_name: targetUser.display_name }, expires_in: 900 }), { headers: { "content-type": "application/json; charset=utf-8", "Set-Cookie": `__Host-cfgenai_impersonation=${token}; Max-Age=900; Path=/; Secure; HttpOnly; SameSite=Lax` } });
-  }
-  if (url.pathname === "/api/admin/scopes" && request.method === "GET") return Response.json({ scopes: await listAuthorizationScopes(env, { who: requestActor(state) }) });
-  if (url.pathname === "/api/admin/status" && request.method === "GET") return Response.json({ features: await listFeatureHealth(env, { who: requestActor(state) }) });
-  if (url.pathname === "/api/admin/features" && request.method === "GET") return Response.json({ features: await listFeatureCatalog(env, features, { who: requestActor(state) }) });
-  if (url.pathname === "/api/admin/groups" && request.method === "GET") return Response.json({ groups: await listGroups(env, { who: requestActor(state) }) });
-  if (url.pathname === "/api/admin/healthchecks" && request.method === "GET") return Response.json({ healthchecks: await listHealthchecks(env, { who: requestActor(state) }) });
-  if (url.pathname === "/api/admin/circuit-breakers" && request.method === "GET") return Response.json({ circuit_breakers: await listCircuitBreakers(env, { who: requestActor(state) }) });
-  const healthcheckMatch = url.pathname.match(/\/api\/admin\/healthchecks\/([^/]+)$/);
-  if (healthcheckMatch && request.method === "PUT") { const body = await request.json().catch(() => null); if (!body?.state) return Response.json({ error: "state is required" }, { status: 400 }); const healthcheck = await updateHealthcheck(env, decodeURIComponent(healthcheckMatch[1]), body.state, { who: requestActor(state) }); return healthcheck ? Response.json({ healthcheck }) : Response.json({ error: "Healthcheck not found" }, { status: 404 }); }
-  const breakerMatch = url.pathname.match(/\/api\/admin\/circuit-breakers\/([^/]+)$/);
-  if (breakerMatch && request.method === "GET") return Response.json({ circuit_breaker: await getCircuitBreaker(env, decodeURIComponent(breakerMatch[1]), { who: requestActor(state) }) });
-  if (breakerMatch && request.method === "PUT") { const body = await request.json().catch(() => null); if (!body?.state) return Response.json({ error: "state is required" }, { status: 400 }); const breaker = await setCircuitBreaker(env, decodeURIComponent(breakerMatch[1]), body.state, { who: requestActor(state) }); return breaker ? Response.json({ circuit_breaker: breaker }) : Response.json({ error: "Circuit breaker not found" }, { status: 404 }); }
-  const groupsMatch = url.pathname.match(/\/api\/admin\/users\/([^/]+)\/groups$/);
-  if (groupsMatch && request.method === "GET") return Response.json({ groups: await listUserGroups(env, decodeURIComponent(groupsMatch[1]), { who: requestActor(state) }) });
-  if (groupsMatch && request.method === "PUT") { const body = await request.json().catch(() => null); if (!body || !Array.isArray(body.groups)) return Response.json({ error: "groups must be an array" }, { status: 400 }); return Response.json({ groups: await replaceUserGroups(env, decodeURIComponent(groupsMatch[1]), body.groups, state.authUser && state.authUser.id, { who: requestActor(state) }) }); }
-  if (grantsMatch && request.method === "GET") return Response.json({ grants: await listUserGrants(env, decodeURIComponent(grantsMatch[1]), { who: requestActor(state) }) });
-  if (grantsMatch && request.method === "PUT") {
-    const body = await request.json().catch(() => null);
-    if (!body || !Array.isArray(body.scopes)) return Response.json({ error: "scopes must be an array" }, { status: 400 });
-    const grants = await replaceUserGrants(env, decodeURIComponent(grantsMatch[1]), body.scopes, state.authUser && state.authUser.id, { who: requestActor(state) });
-    return Response.json({ grants });
-  }
-  return null;
-}
-
-function isAdminPath(pathname) {
-  return pathname === "/admin" || pathname.startsWith("/admin/") || pathname === "/api/admin" || pathname.startsWith("/api/admin/");
-}
-
-function basicUser(request, env) {
-  const token = String(env?.ADMIN_TOKEN || env?.admin_token || "");
-  if (!token) return null;
-  const header = request.headers.get("Authorization") || "";
-  if (!header.toLowerCase().startsWith("basic ")) return null;
-  let decoded;
-  try { decoded = atob(header.slice(6).trim()); } catch { return null; }
-  const separator = decoded.indexOf(":");
-  if (separator < 0) return null;
-  if (!constantTimeEqual(decoded.slice(0, separator), "admin") || !constantTimeEqual(decoded.slice(separator + 1), token)) return null;
-  return { sub: "basic:admin", email: "", name: "admin", roles: ["admin"], auth_strategy: "http_basic" };
-}
-
-function adminUnauthorized(request) {
-  const headers = { "Cache-Control": "no-store", "WWW-Authenticate": "Basic realm=\"admin\", charset=\"UTF-8\"" };
-  return new URL(request.url).pathname.startsWith("/api/") ? Response.json({ error: "Authentication is required." }, { status: 401, headers }) : new Response("Authentication is required.", { status: 401, headers });
-}
-
-function oauthUnauthorized(request, url) {
-  if (url.pathname.startsWith("/api/")) return Response.json({ error: "Authentication is required." }, { status: 401, headers: { "Cache-Control": "no-store" } });
-  return Response.redirect(url.origin + "/auth/login?return_to=" + encodeURIComponent(safeReturnTo(url.pathname + url.search)), 302);
-}
-
-function safeReturnTo(value) { return value?.startsWith("/") && !value.startsWith("//") && !value.startsWith("/auth/") ? value : "/"; }
-function constantTimeEqual(a, b) { const aa = new TextEncoder().encode(a), bb = new TextEncoder().encode(b); let n = aa.length ^ bb.length; for (let i = 0; i < Math.max(aa.length, bb.length); i++) n |= (aa[i] || 0) ^ (bb[i] || 0); return n === 0; }
-
-export function validateBoot(env, { bindings = [], required = [] } = {}) {
-  const missingBindings = bindings.filter((name) => !env?.[name]);
-  const missingValues = required.filter((name) => !env?.[name] || String(env[name]).startsWith("replace-with-"));
-  return { ok: missingBindings.length === 0 && missingValues.length === 0, missingBindings, missingValues };
-}
-
-export function assertBoot(env, spec = {}) {
-  const result = validateBoot(env, spec);
-  if (!result.ok) throw new Error(`Worker boot validation failed: ${[...result.missingBindings, ...result.missingValues].join(", ")}`);
-  return result;
-}
-
-export function secureResponse(response) {
-  const headers = new Headers(response.headers);
-  headers.set("X-Content-Type-Options", "nosniff");
-  headers.set("X-Frame-Options", "DENY");
-  headers.set("Referrer-Policy", "strict-origin-when-cross-origin");
-  headers.set("Permissions-Policy", "camera=(), microphone=(), geolocation=(), payment=(), usb=()");
-  headers.set("Cross-Origin-Opener-Policy", "same-origin");
-  headers.set("Strict-Transport-Security", "max-age=31536000");
-  return new Response(response.body, { status: response.status, statusText: response.statusText, headers });
-}
-
-export function methodNotAllowed(allow = "GET") {
-  return new Response("Method Not Allowed", { status: 405, headers: { Allow: allow } });
-}
-
-export function healthResponse(env, details = {}) {
-  return Response.json({ ok: true, version: String(env.BUILD_SHA || "unknown").slice(0, 7), build_number: env.BUILD_NUMBER ? String(env.BUILD_NUMBER) : null, ...details }, { headers: { "Cache-Control": "no-store" } });
-}
-
-export function createMetrics({ tokenEnv = "POSTHOG_TOKEN", host = "https://us.i.posthog.com" } = {}) {
-  return {
-    request(request, response, env, ctx) {
-      if (!env?.[tokenEnv] || !ctx?.waitUntil || new URL(request.url).pathname === "/health") return;
-      const event = response.status >= 500 ? "server_error" : "request";
-      ctx.waitUntil(track(env, event, { path: new URL(request.url).pathname, method: request.method, status: response.status }, { tokenEnv, host }));
-    },
-    track: (env, event, properties, ctx) => ctx?.waitUntil?.(track(env, event, properties, { tokenEnv, host })),
-  };
-}
-
-async function track(env, event, properties, { tokenEnv, host }) {
-  try {
-    const token = String(env?.[tokenEnv] || "");
-    if (!token) return;
-    await fetch(`${host.replace(/\/+$/, "")}/capture/`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ api_key: token, event, properties: { ...properties, distinct_id: properties?.distinct_id || "anonymous" } }) });
-  } catch (error) {
-    console.error("[metrics] delivery failed", error);
-  }
-}
-
-
-async function featureCatalogPage(env, features, state) {
-  const catalog = await listFeatureCatalog(env, features, { who: requestActor(state) });
-  return new Response(featureCatalogMarkup(catalog), { headers: { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store" } });
-}
-
-function featureCatalogMarkup(catalog) {
-  const rows = catalog.map((item) => {
-    const checks = item.healthchecks.length ? "<ul>" + item.healthchecks.map((check) => "<li><strong>" + escapeHtml(check.display_name) + "</strong>: " + escapeHtml(check.state) + "</li>").join("") + "</ul>" : "<span>None registered</span>";
-    const breakers = item.circuit_breakers.length ? "<ul>" + item.circuit_breakers.map((breaker) => "<li><strong>" + escapeHtml(breaker.display_name) + "</strong>: " + escapeHtml(breaker.state) + "</li>").join("") + "</ul>" : "<span>None registered</span>";
-    const packageLabel = item.package_name ? escapeHtml(item.package_name) : "Unknown package";
-    const versionLabel = item.version ? escapeHtml(item.version) : "Unknown version";
-    return "<tr><td><strong>" + escapeHtml(item.display_name) + "</strong><br><code>" + escapeHtml(item.feature) + "</code></td><td>" + packageLabel + "<br>" + versionLabel + "</td><td><span class=\"state state-" + escapeHtml(item.health) + "\">" + escapeHtml(item.health) + "</span></td><td>" + (item.circuit_breaker ? escapeHtml(item.circuit_breaker.state) : "None") + "</td><td>" + checks + "</td><td>" + breakers + "</td></tr>";
-  }).join("");
-  return "<!doctype html><html lang=\"en\"><head><meta charset=\"utf-8\"><meta name=\"viewport\" content=\"width=device-width,initial-scale=1\"><title>Features</title><style>body{font:15px/1.45 system-ui,sans-serif;color:#20231f;background:#f7f7f5;margin:0;padding:2rem}main{max-width:1200px;margin:auto;background:#fff;padding:1.5rem;border:1px solid #d8ddd5;border-radius:.6rem}nav{display:flex;gap:1rem;margin-bottom:1.5rem}a{color:#2f6f52}table{width:100%;border-collapse:collapse}th,td{padding:.7rem;border-bottom:1px solid #d8ddd5;text-align:left;vertical-align:top}th{font-size:.8rem;color:#687067;text-transform:uppercase}ul{margin:.25rem 0;padding-left:1.2rem}code{color:#687067}.state{font-weight:700}.state-green{color:#26734d}.state-yellow{color:#9a6b00}.state-red{color:#b3261e}</style></head><body><main><nav><a href=\"/admin\">Admin</a><a href=\"/admin/features\" aria-current=\"page\">Features</a><a href=\"/admin/users\">Users</a><a href=\"/admin/groups\">Groups</a></nav><h1>Installed features</h1><p>Runtime modules, package versions, healthchecks, and circuit breakers.</p><table><thead><tr><th>Feature</th><th>Package/version</th><th>Health</th><th>Roll-up breaker</th><th>Healthchecks</th><th>Circuit breakers</th></tr></thead><tbody>" + rows + "</tbody></table></main></body></html>";
-}
-
-function escapeHtml(value) { return String(value ?? "").replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll(String.fromCharCode(39), "&#39;"); }
+export { createWorker } from "./runtime/worker.js";
+export { ensureFeatureManifests } from "./runtime/features.js";
+export { assertBoot, validateBoot, methodNotAllowed, healthResponse } from "./runtime/health.js";
+export { defineApp } from "./app.js";
+export * from "./core/index.js";
+export * from "./data/index.js";
+export * from "./auth/index.js";
+export { secureResponse } from "./core/security.js";

package/src/repository.js

@@ -0,0 +1,63 @@
+import { auditLog } from "./core/events.js";
+
+export class RepositoryError extends Error {
+  constructor(message, status = 500) { super(message); this.name = "RepositoryError"; this.status = status; }
+}
+
+export function defineRepository({ name, resource, scope = "tenant", relations = {}, hooks = {}, resourceDefinition = null } = {}) {
+  if (!/^[a-z][a-z0-9_-]*$/.test(String(name || ""))) throw new TypeError("Repositories require a safe name");
+  if (!resource) throw new TypeError(`Repository ${name} requires a data resource`);
+  return { name: String(name), resource: String(resource), scope, relations: { ...relations }, hooks: { ...hooks }, resourceDefinition };
+}
+
+export function createRepositories(env, definitions = [], { context } = {}) {
+  const specs = new Map(definitions.map((definition) => {
+    const spec = defineRepository(definition);
+    return [spec.name, spec];
+  }));
+  const repositories = new Map();
+  const get = (name) => {
+    const repository = repositories.get(String(name));
+    if (!repository) throw new RepositoryError(`Unknown repository: ${name}`, 500);
+    return repository;
+  };
+  for (const spec of specs.values()) repositories.set(spec.name, repository(spec));
+  return Object.fromEntries([...repositories].map(([name, value]) => [name, value]));
+
+  function repository(spec) {
+    const reader = () => {
+      const data = env?.data;
+      if (!data?.[spec.scope]) throw new RepositoryError(`Data scope ${spec.scope} is unavailable`, 500);
+      return data[spec.scope];
+    };
+    const invoke = async (operation, value) => {
+      const hook = spec.hooks[operation];
+      return typeof hook === "function" ? hook(value, { env, context, repository: api }) : value;
+    };
+    const api = {
+      name: spec.name,
+      resource: spec.resource,
+      async list(options) { return invoke("list", await reader().list(spec.resource, options)); },
+      async page(options) { return invoke("page", await reader().page(spec.resource, options)); },
+      async count(options) { return reader().count(spec.resource, options); },
+      async find(id) { return invoke("find", await reader().get(spec.resource, id)); },
+      async findOne(where, options = {}) { return invoke("findOne", (await reader().list(spec.resource, { ...options, where, limit: 1 }))[0] || null); },
+      async insert(values) { const result = await reader().insert(spec.resource, await invoke("beforeInsert", values)); auditLog({ who: "repository", operation: "create", resource: spec.name }); return invoke("afterInsert", result); },
+      async update(id, changes) { const result = await reader().update(spec.resource, id, await invoke("beforeUpdate", changes)); auditLog({ who: "repository", operation: "update", resource: spec.name }); return invoke("afterUpdate", result); },
+      async updateWhere(where, changes) { return reader().updateWhere(spec.resource, where, await invoke("beforeUpdate", changes)); },
+      async delete(id) { const result = await reader().delete(spec.resource, id); auditLog({ who: "repository", operation: "delete", resource: spec.name }); return result; },
+      async deleteWhere(where) { return reader().deleteWhere(spec.resource, where); },
+      async link(relation, record) {
+        const relationSpec = spec.relations[relation];
+        if (!relationSpec) throw new RepositoryError(`Unknown relation ${spec.name}.${relation}`, 500);
+        const target = get(relationSpec.repository);
+        const localKey = relationSpec.localKey || "id";
+        const foreignKey = relationSpec.foreignKey || `${spec.name}_id`;
+        const value = record?.[localKey];
+        if (value === undefined || value === null) return relationSpec.many === false ? null : [];
+        return relationSpec.many === false ? target.findOne({ [foreignKey]: value }) : target.list({ where: { [foreignKey]: value, ...(relationSpec.where || {}) }, ...(relationSpec.options || {}) });
+      },
+    };
+    return api;
+  }
+}

package/src/runtime/features.js

@@ -0,0 +1,17 @@
+import { evaluateCircuitBreaker, listCircuitBreakers, registerFeatureManifests } from "../core/circuits.js";
+
+const featureRegistrationPromises = new WeakMap();
+
+export function ensureFeatureManifests(env, features = [], { who = "system:update" } = {}) {
+  if (!env || typeof env !== "object" || !env.DB) return Promise.resolve();
+  const key = features.map((feature) => String(feature?.name || feature?.id || "feature")).join("|");
+  let registrations = featureRegistrationPromises.get(env.DB);
+  if (!registrations) { registrations = new Map(); featureRegistrationPromises.set(env.DB, registrations); }
+  let promise = registrations.get(key);
+  if (!promise) {
+    promise = (async () => { await registerFeatureManifests(env, features, { who }); const breakers = await listCircuitBreakers(env, { who }); await Promise.all(breakers.filter(Boolean).map((breaker) => evaluateCircuitBreaker(env, breaker.id, { who }))); })();
+    registrations.set(key, promise);
+    promise.catch(() => registrations.delete(key));
+  }
+  return promise;
+}

package/src/runtime/health.js

@@ -0,0 +1,17 @@
+export function validateBoot(env, { bindings = [], required = [] } = {}) {
+  const missingBindings = bindings.filter((name) => !env?.[name]);
+  const missingValues = required.filter((name) => !env?.[name] || String(env[name]).startsWith("replace-with-"));
+  return { ok: missingBindings.length === 0 && missingValues.length === 0, missingBindings, missingValues };
+}
+
+export function assertBoot(env, spec = {}) {
+  const result = validateBoot(env, spec);
+  if (!result.ok) throw new Error(`Worker boot validation failed: ${[...result.missingBindings, ...result.missingValues].join(", ")}`);
+  return result;
+}
+
+export function methodNotAllowed(allow = "GET") { return new Response("Method Not Allowed", { status: 405, headers: { Allow: allow } }); }
+
+export function healthResponse(env, details = {}) {
+  return Response.json({ ok: true, version: String(env.BUILD_SHA || "unknown").slice(0, 7), build_number: env.BUILD_NUMBER ? String(env.BUILD_NUMBER) : null, ...details }, { headers: { "Cache-Control": "no-store" } });
+}

package/src/runtime/worker.js

@@ -0,0 +1,45 @@
+import { ensureSubscriptionManifest, SubscriptionError } from "../auth/index.js";
+import { auditedD1, createEventHandler, listFeatureHealth, requestActor, requestContext, secureResponse } from "../core/index.js";
+import { jobResponse, liveEventsResponse } from "../api/jobs.js";
+import { createRepositories } from "../repository.js";
+import { dispatchRoutes } from "../api/contracts.js";
+import { defineApp } from "../app.js";
+import { createDataReader } from "../data/reader.js";
+import { DataScopeError, normalizeDataResources } from "../data/resources.js";
+import { requestDataContext } from "../data/context.js";
+import { adminBoundary } from "../admin/routes.js";
+import { ensureFeatureManifests } from "./features.js";
+import { healthResponse } from "./health.js";
+
+export function createWorker({ fetch, scheduled, app = { name: "worker" }, auth, authorize, scopes = [], subscriptionManifest = [], scopeRoutes = [], apiRoutes = [], middleware = [], features = [], dataResources = [], repositories = [], publicTenantId = null, health, boot, security = true, eventHubBinding = "EVENT_HUB" }) {
+  if (typeof fetch !== "function") throw new TypeError("createWorker requires a fetch handler");
+  const application = defineApp(app); const provider = auth || features.find((feature) => typeof feature?.getUser === "function"); const eventHandler = createEventHandler(features, { eventHubBinding });
+  const repositoryDefinitions = [...repositories, ...features.flatMap((feature) => Array.isArray(feature?.repositories) ? feature.repositories : [])];
+  const registeredDataResources = normalizeDataResources([...dataResources, ...features.flatMap((feature) => Array.isArray(feature?.dataResources) ? feature.dataResources : []), ...repositoryDefinitions.filter((definition) => definition.resourceDefinition).map((definition) => definition.resourceDefinition)]);
+  const featureRoutes = features.flatMap((feature) => Array.isArray(feature?.routes) ? [async (request, env, ctx, next, state) => { for (const route of feature.routes) { const matches = typeof route?.match === "function" ? await route.match(request, env, state) : route?.path === new URL(request.url).pathname; if (matches && typeof route.handle === "function") return route.handle({ request, env, ctx, state, next }); } return next(); }] : []);
+  const chain = [(request, env, ctx, next, state) => adminBoundary(request, env, ctx, next, state, { provider, authorize, scopes, scopeRoutes, features }), ...(apiRoutes.length ? [(request, env, ctx, next, state) => dispatchRoutes(request, env, ctx, state, apiRoutes).then((response) => response || next(request))] : []), ...features.flatMap((feature) => feature?.middleware ? [feature.middleware.bind(feature)] : []), ...featureRoutes, ...middleware, ...(auth ? [(request, env, ctx, next) => auth(request, env, ctx, next)] : [])].filter(Boolean);
+  return {
+    async fetch(request, env, ctx) {
+      try {
+        if (boot) await boot(env, { request, ctx });
+        if (subscriptionManifest.length) await ensureSubscriptionManifest(env, subscriptionManifest, { who: "system:update" });
+        const url = new URL(request.url); const state = Object.create(null); state.requestId = crypto.randomUUID();
+        if (provider?.getUser) state.user = await provider.getUser(request, env).catch(() => null); if (state.user?.authUser) state.authUser = state.user.authUser;
+        state.data = createDataReader(env, { resources: registeredDataResources, context: () => requestDataContext(env, { state, request, publicTenantId }) });
+        const requestEnv = Object.create(env || null);
+        Object.assign(requestEnv, { app: application, DB: env?.DB ? auditedD1(env.DB, requestActor(state)) : env?.DB, data: state.data, repositories: createRepositories(requestEnv, repositoryDefinitions), user: state.user || null, authUser: state.authUser || null, userId: state.authUser?.id || null, eventHandler: (event, eventEnv, eventCtx) => eventHandler(event, eventEnv || requestEnv, eventCtx || ctx) });
+        requestEnv.requestId = state.requestId; state.context = requestContext({ request, env: requestEnv, ctx, state, data: state.data }); requestEnv.context = state.context; requestEnv.event = state.context.event;
+        if (env?.DB && features.some((feature) => typeof feature?.healthcheck === "function" || feature?.healthchecks?.length || feature?.healthChecks?.length || feature?.circuitBreakers?.length || feature?.circuit_breakers?.length)) ctx?.waitUntil?.(ensureFeatureManifests(env, features).catch((error) => console.error("[EventLog] feature manifest registration failed", error)));
+        const dispatch = async (index, currentRequest = request) => { const layer = chain[index]; if (!layer) { if (url.pathname === "/health" || url.pathname === "/api/health") { const details = health ? await health(requestEnv, { request: currentRequest, ctx, state }) : {}; const featureHealth = requestEnv?.DB ? await listFeatureHealth(requestEnv, { who: "system:read" }).catch(() => []) : []; return healthResponse(requestEnv, featureHealth.length ? { ...details, features: featureHealth } : details); } if (url.pathname === "/api/tenant" && currentRequest.method === "GET") { const context = await state.data.context(); if (!context.userId) return Response.json({ error: "Authentication is required." }, { status: 401 }); if (context.invalidTenant) return Response.json({ error: "The requested tenant is not available." }, { status: 400 }); return Response.json({ tenant: context.tenantId ? { id: context.tenantId, name: context.tenants?.find((tenant) => tenant.id === context.tenantId)?.name || null } : null, tenants: context.tenants || [] }); } return fetch(currentRequest, requestEnv, ctx, state); } if (typeof layer !== "function") throw new TypeError("Worker middleware must be a function"); return layer(currentRequest, requestEnv, ctx, (nextRequest = currentRequest) => dispatch(index + 1, nextRequest), state); };
+        const liveResponse = await liveEventsResponse(request, requestEnv, state, eventHubBinding);
+        if (liveResponse) return liveResponse;
+        const response = await jobResponse(request, requestEnv, state) || await dispatch(0); return withRequestId(security ? secureResponse(response) : response, state.requestId);
+      } catch (error) {
+        console.error("[worker] request failed", error); const errorResponse = error instanceof DataScopeError || error instanceof SubscriptionError ? Response.json({ error: error.message }, { status: 403, headers: { "Cache-Control": "no-store" } }) : Response.json({ error: "Internal server error" }, { status: 500, headers: { "Cache-Control": "no-store" } }); return withRequestId(security ? secureResponse(errorResponse) : errorResponse, error?.requestId || crypto.randomUUID());
+      }
+    },
+    ...(scheduled ? { scheduled } : {}),
+  };
+}
+
+function withRequestId(response, requestId) { const headers = new Headers(response.headers); headers.set("X-Request-ID", String(requestId)); return new Response(response.body, { status: response.status, statusText: response.statusText, headers }); }

package/src/ui/index.js

@@ -1,87 +1 @@
-export * from "./groups.js";
-const styles = `:host { --cf-ui-bg:#fff; --cf-ui-surface:#f7f7f5; --cf-ui-text:#20231f; --cf-ui-muted:#687067; --cf-ui-border:#d8ddd5; --cf-ui-primary:#2f6f52; color:var(--cf-ui-text); font:15px/1.45 system-ui,sans-serif } *,*::before,*::after{box-sizing:border-box}.shell{display:grid;grid-template-columns:180px minmax(0,1fr);gap:1.5rem}.nav{display:grid;align-content:start;gap:.2rem;border-right:1px solid var(--cf-ui-border);padding-right:1rem}.nav-group{display:grid;gap:.15rem;margin-bottom:.85rem}.nav-label{padding:.35rem .7rem;color:var(--cf-ui-muted);font-size:.68rem;font-weight:700;letter-spacing:.1em;text-transform:uppercase}.nav a{color:var(--cf-ui-text);padding:.48rem .7rem;border-radius:.4rem;text-decoration:none}.nav a:hover,.nav a[aria-current=page]{background:var(--cf-ui-surface);color:var(--cf-ui-primary)}.card{background:var(--cf-ui-bg);border:1px solid var(--cf-ui-border);border-radius:.6rem;padding:1rem;overflow:auto}table{width:100%;border-collapse:collapse}th,td{padding:.65rem;border-bottom:1px solid var(--cf-ui-border);text-align:left;vertical-align:top}th{color:var(--cf-ui-muted);font-size:.8rem;text-transform:uppercase;letter-spacing:.04em}button{border:1px solid var(--cf-ui-border);border-radius:.4rem;background:var(--cf-ui-bg);color:inherit;padding:.45rem .65rem;cursor:pointer}.scope-list,.catalog-list{display:grid;gap:.3rem;min-width:14rem}.scope-list label{display:flex;gap:.4rem;align-items:center}.catalog-list div{padding:.55rem 0;border-bottom:1px solid var(--cf-ui-border)}.status{color:var(--cf-ui-muted);min-height:1.4em}.state{font-weight:700}.state-green{color:#26734d}.state-yellow{color:#9a6b00}.state-red{color:#b3261e}@media(max-width:640px){.shell{grid-template-columns:1fr}.nav{grid-template-columns:repeat(2,minmax(0,1fr));border-right:0;border-bottom:1px solid var(--cf-ui-border);padding:0 0 1rem}.nav-group{margin:0}.nav-label{grid-column:1/-1}}`;
-
-const enhancedStyles = styles + `.status-grid,.breaker-groups,.feature-grid{display:grid;gap:.85rem}.status-grid{grid-template-columns:repeat(auto-fit,minmax(230px,1fr))}.status-card,.feature-card{padding:1rem;background:var(--cf-ui-bg);border:1px solid var(--cf-ui-border);border-radius:.65rem}.status-card h3,.feature-card h3{margin:0 0 .35rem;font-size:1rem}.status-card p,.feature-card p{margin:.3rem 0;color:var(--cf-ui-muted)}.status-line{display:flex;align-items:center;gap:.55rem;margin:.35rem 0}.state{font-weight:700}.state-green{color:#26734d}.state-yellow{color:#9a6b00}.state-red{color:#b3261e}.state-off{color:#687067}.state-tripped{color:#a33b32}.state-on{color:#26734d}.breaker-group{padding:1rem;background:var(--cf-ui-bg);border:1px solid var(--cf-ui-border);border-radius:.75rem}.breaker-group-heading{display:flex;align-items:start;justify-content:space-between;gap:1rem;margin-bottom:.75rem}.breaker-group h3{margin:0}.breaker-list{display:grid;gap:.55rem}.breaker-row{display:grid;grid-template-columns:minmax(0,1fr) auto auto;gap:.7rem;align-items:center;padding:.7rem 0;border-top:1px solid var(--cf-ui-border)}.breaker-row.rollup{margin-top:.2rem;padding:.8rem;background:var(--cf-ui-surface);border:1px solid var(--cf-ui-border);border-radius:.55rem}.breaker-name{font-weight:700}.breaker-key{display:block;color:var(--cf-ui-muted);font:12px ui-monospace,monospace}.breaker-actions{display:flex;gap:.35rem;flex-wrap:wrap;justify-content:end}.breaker-actions button.is-active{border-color:var(--cf-ui-primary);background:var(--cf-ui-surface);color:var(--cf-ui-primary);font-weight:700}.feature-links{display:flex;gap:.65rem;flex-wrap:wrap;margin-top:.7rem}.feature-links a{color:var(--cf-ui-primary);font-weight:700}.error{color:var(--cf-ui-danger);min-height:1.4em}@media(max-width:640px){.breaker-row{grid-template-columns:1fr}.breaker-actions{justify-content:start}}`;
-const stateInfo = { green: ["🟢", "Green"], yellow: ["🟡", "Yellow"], red: ["🔴", "Red"], off: ["⚪", "Off"], tripped: ["🔴", "Tripped"], on: ["🟢", "On"] };
-const stateMarkup = (state) => { const [emoji, label] = stateInfo[String(state || "yellow").toLowerCase()] || ["⚪", String(state || "Unknown")]; return `<span class="state state-${String(state || "").toLowerCase()}">${emoji} ${label}</span>`; };
-
-export class CfAdminShell extends HTMLElement {
-  connectedCallback() {
-    const active = this.getAttribute("active") || "";
-    const configured = this.getAttribute("cookbook-links");
-    const links = (configured ? configured.split(";") : ["New recipe|/new", "Reviewers|/admin#reviewers"]).map((entry) => { const [label, href, key] = entry.split("|"); return { label: label || "", href: href || "#", key: key || "" }; }).filter((entry) => entry.label && entry.href);
-    const cookbookLinks = links.map(({ label, href, key }) => `<a href="${href}" ${active === key ? 'aria-current="page"' : ""}>${label}</a>`).join("");
-    this.attachShadow({ mode: "open" }).innerHTML = `<style>${enhancedStyles}</style><div class="shell"><nav class="nav" part="navigation"><div class="nav-group"><div class="nav-label">Cookbook</div><a href="/admin" ${active === "home" ? 'aria-current="page"' : ""}>Overview</a>${cookbookLinks}</div><div class="nav-group"><div class="nav-label">System</div><a href="/admin/users" ${active === "users" ? 'aria-current="page"' : ""}>Users</a><a href="/admin/scopes" ${active === "scopes" ? 'aria-current="page"' : ""}>Scopes</a><a href="/admin/features" ${active === "features" ? 'aria-current="page"' : ""}>Features</a><a href="/admin/healthchecks" ${active === "healthchecks" ? 'aria-current="page"' : ""}>Healthchecks</a><a href="/admin/circuit-breakers" ${active === "circuit-breakers" ? 'aria-current="page"' : ""}>Circuit breakers</a><a href="/admin/groups" ${active === "groups" ? 'aria-current="page"' : ""}>Groups</a></div></nav><main><slot></slot></main></div>`;
-  }
-}
-
-export class CfScopeBadge extends HTMLElement {
-  connectedCallback() { this.attachShadow({ mode: "open" }).innerHTML = `<style>${enhancedStyles}.badge{display:inline-block;border:1px solid var(--cf-ui-border);border-radius:999px;padding:.15rem .5rem;color:var(--cf-ui-primary);background:var(--cf-ui-surface);font-size:.85rem;cursor:help}</style><span class="badge" part="badge"></span>`; const name = this.getAttribute("scope") || this.textContent || ""; this.shadowRoot.querySelector(".badge").textContent = name; this.shadowRoot.querySelector(".badge").title = this.getAttribute("label") || name; }
-}
-
-export class CfUserManagement extends HTMLElement {
-  async connectedCallback() { this.attachShadow({ mode: "open" }).innerHTML = `<style>${enhancedStyles}</style><section class="card" part="panel"><h2>User access</h2><p class="status" part="status">Loading users and scopes…</p><table hidden part="table"><thead><tr><th>User</th><th>Scopes</th><th>Save</th></tr></thead><tbody></tbody></table></section>`; try { await this.load(); } catch (error) { this.status.textContent = error.message || "Unable to load access data."; } }
-  get status() { return this.shadowRoot.querySelector(".status"); }
-  async load() { const [usersResponse, scopesResponse] = await Promise.all([fetch("/api/admin/users", { credentials: "same-origin" }), fetch("/api/admin/scopes", { credentials: "same-origin" })]); if (!usersResponse.ok || !scopesResponse.ok) throw new Error("Unable to load user access."); const users = (await usersResponse.json()).users || []; const scopes = (await scopesResponse.json()).scopes || []; const body = this.shadowRoot.querySelector("tbody"); body.replaceChildren(...users.map((user) => this.row(user, scopes))); this.shadowRoot.querySelector("table").hidden = false; this.status.textContent = `${users.length} user${users.length === 1 ? "" : "s"}`; }
-  row(user, scopes) { const row = document.createElement("tr"); const identity = document.createElement("td"); identity.textContent = `${user.display_name || user.email || "Unnamed user"} (${user.email || "no email"})`; const grants = document.createElement("td"); const list = document.createElement("div"); list.className = "scope-list"; for (const scope of scopes) { const label = document.createElement("label"); const input = document.createElement("input"); input.type = "checkbox"; input.value = scope.name; input.checked = Boolean((user.scopes || []).includes(scope.name)); const text = document.createElement("span"); text.textContent = scope.label || scope.name; text.title = scope.name; label.append(input, text); list.append(label); } grants.append(list); const action = document.createElement("td"); const button = document.createElement("button"); button.textContent = "Save"; button.addEventListener("click", async () => { button.disabled = true; const selected = [...list.querySelectorAll("input:checked")].map((input) => input.value); const response = await fetch(`/api/admin/users/${encodeURIComponent(user.id)}/scopes`, { method: "PUT", credentials: "same-origin", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ scopes: selected }) }); button.disabled = false; this.status.textContent = response.ok ? "Access saved." : "Unable to save access."; }); action.append(button); row.append(identity, grants, action); return row; }
-}
-
-if (!customElements.get("cf-admin-shell")) customElements.define("cf-admin-shell", CfAdminShell);
-if (!customElements.get("cf-scope-badge")) customElements.define("cf-scope-badge", CfScopeBadge);
-if (!customElements.get("cf-user-management")) customElements.define("cf-user-management", CfUserManagement);
-
-export class CfScopeCatalog extends HTMLElement {
-  async connectedCallback() {
-    this.attachShadow({ mode: "open" }).innerHTML = `<style>${enhancedStyles}</style><section class="card" part="panel"><h2>Available scopes</h2><p class="status" part="status">Loading scopes…</p><div class="scope-list" hidden part="list"></div></section>`;
-    try {
-      const response = await fetch("/api/admin/scopes", { credentials: "same-origin" });
-      if (!response.ok) throw new Error("Unable to load scopes.");
-      const scopes = (await response.json()).scopes || [];
-      const list = this.shadowRoot.querySelector(".scope-list");
-      list.replaceChildren(...scopes.map((scope) => {
-        const item = document.createElement("div");
-        const badge = document.createElement("cf-scope-badge");
-        badge.setAttribute("scope", scope.name);
-        const description = document.createElement("span");
-        description.textContent = ` ${scope.label || scope.description || scope.name}`;
-        description.title = scope.label || scope.name;
-        item.append(badge, description);
-        return item;
-      }));
-      list.hidden = false;
-      this.shadowRoot.querySelector(".status").textContent = `${scopes.length} scope${scopes.length === 1 ? "" : "s"}`;
-    } catch (error) {
-      this.shadowRoot.querySelector(".status").textContent = error.message || "Unable to load scopes.";
-    }
-  }
-}
-
-if (!customElements.get("cf-scope-catalog")) customElements.define("cf-scope-catalog", CfScopeCatalog);
-
-export class CfHealthcheckCatalog extends HTMLElement {
-  async connectedCallback() {
-    this.attachShadow({ mode: "open" }).innerHTML = `<style>${enhancedStyles}</style><section class="card"><h2>Healthchecks</h2><p class="status">Loading…</p><div class="status-grid" hidden></div></section>`;
-    try { const response = await fetch("/api/admin/healthchecks", { credentials: "same-origin" }); if (!response.ok) throw new Error("Unable to load healthchecks."); let items = (await response.json()).healthchecks || []; const feature = new URLSearchParams(location.search).get("feature"); if (feature) items = items.filter((item) => item.feature === feature); const grid = this.shadowRoot.querySelector(".status-grid"); grid.replaceChildren(...items.map((item) => { const card = document.createElement("article"); card.className = "status-card"; card.innerHTML = `<h3></h3><div class="status-line"></div><p></p>`; card.querySelector("h3").textContent = item.display_name; card.querySelector(".status-line").innerHTML = stateMarkup(item.state); card.querySelector("p").textContent = `${item.feature} / ${item.component}`; return card; })); grid.hidden = false; this.shadowRoot.querySelector(".status").textContent = `${items.length} healthcheck${items.length === 1 ? "" : "s"}${feature ? ` for ${feature}` : ""}`; } catch (error) { this.shadowRoot.querySelector(".status").textContent = error.message; }
-  }
-}
-
-export class CfCircuitBreakerCatalog extends HTMLElement {
-  async connectedCallback() {
-    this.attachShadow({ mode: "open" }).innerHTML = `<style>${enhancedStyles}</style><section class="card"><h2>Circuit breakers</h2><p class="status">Loading…</p><div class="breaker-groups" hidden></div><p class="error" role="status"></p></section>`;
-    try { const response = await fetch("/api/admin/circuit-breakers", { credentials: "same-origin" }); if (!response.ok) throw new Error("Unable to load circuit breakers."); let items = (await response.json()).circuit_breakers || []; const feature = new URLSearchParams(location.search).get("feature"); if (feature) items = items.filter((item) => item.feature === feature); const groups = new Map(); for (const item of items) { if (!groups.has(item.feature)) groups.set(item.feature, []); groups.get(item.feature).push(item); } const root = this.shadowRoot.querySelector(".breaker-groups"); root.replaceChildren(...[...groups].map(([featureName, breakers]) => this.group(featureName, breakers))); root.hidden = false; this.shadowRoot.querySelector(".status").textContent = `${items.length} circuit breaker${items.length === 1 ? "" : "s"}${feature ? ` for ${feature}` : ""}`; } catch (error) { this.shadowRoot.querySelector(".status").textContent = error.message; }
-  }
-  group(feature, breakers) { const section = document.createElement("section"); section.className = "breaker-group"; const heading = document.createElement("div"); heading.className = "breaker-group-heading"; heading.innerHTML = `<div><h3></h3><span class="breaker-key"></span></div><a href="/admin/features?feature=${encodeURIComponent(feature)}">View feature</a>`; heading.querySelector("h3").textContent = feature; heading.querySelector(".breaker-key").textContent = `${breakers.length} breaker${breakers.length === 1 ? "" : "s"}`; section.append(heading); const list = document.createElement("div"); list.className = "breaker-list"; const ordered = [...breakers].sort((a, b) => Number(b.name === "rollup") - Number(a.name === "rollup") || a.name.localeCompare(b.name)); list.replaceChildren(...ordered.map((breaker) => this.row(breaker))); section.append(list); return section; }
-  row(breaker) { const row = document.createElement("div"); row.className = `breaker-row${breaker.name === "rollup" ? " rollup" : ""}`; row.innerHTML = `<div><span class="breaker-name"></span><span class="breaker-key"></span></div><span class="breaker-state"></span><div class="breaker-actions"><button data-state="off">Off</button><button data-state="tripped">Tripped</button><button data-state="on">On</button></div>`; row.querySelector(".breaker-name").textContent = breaker.name === "rollup" ? `↳ ${breaker.display_name} · feature rollup` : breaker.display_name; row.querySelector(".breaker-key").textContent = `${breaker.feature}/${breaker.name}`; row.querySelector(".breaker-state").innerHTML = stateMarkup(breaker.state); for (const button of row.querySelectorAll("button")) { button.classList.toggle("is-active", button.dataset.state === breaker.state); button.addEventListener("click", () => this.update(breaker, row, button.dataset.state)); } return row; }
-  async update(breaker, row, state) { const buttons = [...row.querySelectorAll("button")]; buttons.forEach((button) => { button.disabled = true; }); try { const response = await fetch(`/api/admin/circuit-breakers/${encodeURIComponent(breaker.id)}`, { method: "PUT", credentials: "same-origin", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ state }) }); const result = await response.json(); if (!response.ok) throw new Error(result.error || "Unable to update circuit breaker."); breaker.state = result.circuit_breaker?.state || state; row.querySelector(".breaker-state").innerHTML = stateMarkup(breaker.state); buttons.forEach((button) => button.classList.toggle("is-active", button.dataset.state === breaker.state)); } catch (error) { this.shadowRoot.querySelector(".error").textContent = error.message; } finally { buttons.forEach((button) => { button.disabled = false; }); } }
-}
-
-export class CfFeatureCatalog extends HTMLElement {
-  async connectedCallback() {
-    this.attachShadow({ mode: "open" }).innerHTML = `<style>${enhancedStyles}</style><section class="card"><h2>Installed features</h2><p class="status">Loading…</p><div class="feature-grid" hidden></div></section>`;
-    try { const response = await fetch("/api/admin/features", { credentials: "same-origin" }); if (!response.ok) throw new Error("Unable to load features."); let items = (await response.json()).features || []; const selected = new URLSearchParams(location.search).get("feature"); if (selected) items = items.filter((item) => item.feature === selected); const grid = this.shadowRoot.querySelector(".feature-grid"); grid.replaceChildren(...items.map((item) => { const card = document.createElement("article"); card.className = "feature-card"; const rollup = item.circuit_breaker; card.innerHTML = `<h3></h3><p class="feature-health"></p><p class="feature-rollup"></p><div class="feature-links"><a class="health-link">Healthchecks</a><a class="breaker-link">Circuit breakers</a></div>`; card.querySelector("h3").textContent = item.display_name || item.feature; card.querySelector(".feature-health").innerHTML = `Health: ${stateMarkup(item.health)}`; card.querySelector(".feature-rollup").innerHTML = `Rollup: ${rollup ? stateMarkup(rollup.state) : "—"}`; card.querySelector(".health-link").href = `/admin/healthchecks?feature=${encodeURIComponent(item.feature)}`; card.querySelector(".breaker-link").href = `/admin/circuit-breakers?feature=${encodeURIComponent(item.feature)}`; return card; })); grid.hidden = false; this.shadowRoot.querySelector(".status").textContent = `${items.length} feature${items.length === 1 ? "" : "s"}`; } catch (error) { this.shadowRoot.querySelector(".status").textContent = error.message; }
-  }
-}
-
-if (!customElements.get("cf-healthcheck-catalog")) customElements.define("cf-healthcheck-catalog", CfHealthcheckCatalog);
-if (!customElements.get("cf-circuit-breaker-catalog")) customElements.define("cf-circuit-breaker-catalog", CfCircuitBreakerCatalog);
-if (!customElements.get("cf-feature-catalog")) customElements.define("cf-feature-catalog", CfFeatureCatalog);
+export * from "./react/index.jsx";