@odla-ai/chapter 0.34.0 → 0.35.0

package/dist/worker/index.cjs

@@ -22,7 +22,9 @@ var worker_exports = {};
 __export(worker_exports, {
   chapterWorker: () => chapterWorker,
   createWorkerContext: () => createWorkerContext,
-  deliverSignupControl: () => deliverSignupControl
+  deliverSignupControl: () => deliverSignupControl,
+  renderActiveSignupControlHtml: () => renderActiveSignupControlHtml,
+  withActiveSignupControlTheme: () => withActiveSignupControlTheme
 });
 module.exports = __toCommonJS(worker_exports);
 
@@ -1750,12 +1752,18 @@ function themeOf(value, errors) {
   }
   unknownKeys(input, /* @__PURE__ */ new Set(["tokens"]), "document.theme", errors);
   if (Object.keys(tokens).length > 256) errors.push("document.theme.tokens supports at most 256 entries");
+  let serializedLength = 0;
   for (const [key, token] of Object.entries(tokens)) {
-    if (!/^--[a-z0-9-]{1,100}$/.test(key)) errors.push(`document.theme.tokens.${key} must be a CSS custom-property name`);
-    if (typeof token !== "string" && typeof token !== "number" || String(token).length > 1e3) {
-      errors.push(`document.theme.tokens.${key} must be a bounded string or number`);
+    if (!/^--ui-[a-z0-9][a-z0-9-]{0,94}$/.test(key)) {
+      errors.push(`document.theme.tokens.${key} must be an allowlisted --ui-* custom property`);
+    }
+    const rendered = String(token).trim();
+    serializedLength += key.length + rendered.length + 4;
+    if (typeof token !== "string" && typeof token !== "number" || typeof token === "number" && !Number.isFinite(token) || !rendered || rendered.length > 1e3 || /[\u0000-\u001f\u007f\\<>{};]|\/\*|\*\/|(?:^|[^a-z])(?:url|expression)\s*\(|@import/i.test(rendered)) {
+      errors.push(`document.theme.tokens.${key} must be a bounded breakout-safe CSS value`);
     }
   }
+  if (serializedLength > 65536) errors.push("document.theme.tokens exceeds the serialized size bound");
   return { tokens };
 }
 function validateSignupControlDocument(input) {
@@ -4077,6 +4085,137 @@ async function deliverSignupControl(options) {
   return result;
 }
 
+// src/signup-control-theme.ts
+var SIGNUP_CONTROL_THEME_MARKER = "<!--odla:signup-control-theme-->";
+var SIGNUP_CONTROL_THEME_STYLE_ID = "odla-signup-control-theme";
+var TOKEN_NAME = /^--ui-[a-z0-9][a-z0-9-]{0,94}$/;
+var DIGEST = /^sha256:[0-9a-f]{64}$/;
+var UNSAFE_VALUE = /[\u0000-\u001f\u007f\\<>{};]|\/\*|\*\/|(?:^|[^a-z])(?:url|expression)\s*\(|@import/i;
+var MAX_TOKENS = 256;
+var MAX_VALUE_LENGTH = 1e3;
+var MAX_SERIALIZED_LENGTH = 65536;
+function validatedTokens(input) {
+  const entries = Object.entries(input ?? {});
+  if (entries.length > MAX_TOKENS) {
+    throw new TypeError(`signup-control theme supports at most ${MAX_TOKENS} tokens`);
+  }
+  const tokens = {};
+  let serializedLength = 0;
+  for (const [name, raw] of entries.sort(([left], [right]) => left.localeCompare(right))) {
+    if (!TOKEN_NAME.test(name)) {
+      throw new TypeError(`signup-control theme token "${name}" must be an allowlisted --ui-* property`);
+    }
+    if (typeof raw !== "string" && typeof raw !== "number" || typeof raw === "number" && !Number.isFinite(raw)) {
+      throw new TypeError(`signup-control theme token "${name}" must be a finite string or number`);
+    }
+    const value = String(raw).trim();
+    if (!value || value.length > MAX_VALUE_LENGTH || UNSAFE_VALUE.test(value)) {
+      throw new TypeError(`signup-control theme token "${name}" has an unsafe or oversized value`);
+    }
+    serializedLength += name.length + value.length + 4;
+    if (serializedLength > MAX_SERIALIZED_LENGTH) {
+      throw new TypeError("signup-control theme exceeds the serialized size bound");
+    }
+    tokens[name] = value;
+  }
+  return tokens;
+}
+function cssFor(tokens) {
+  const declarations = Object.entries(tokens).map(([name, value]) => `  ${name}: ${value};`);
+  return declarations.length ? `:root {
+${declarations.join("\n")}
+}` : "";
+}
+function stateFor(revision, options) {
+  if (!revision) {
+    return {
+      css: cssFor(validatedTokens(options.bootstrapTokens)),
+      metadata: { source: "bootstrap", revision: null, digest: null, cacheKey: "signup-control:bootstrap" }
+    };
+  }
+  if (!Number.isSafeInteger(revision.revision) || revision.revision < 1 || !DIGEST.test(revision.digest)) {
+    throw new TypeError("signup-control theme revision metadata is invalid");
+  }
+  return {
+    css: cssFor(validatedTokens(revision.theme?.tokens)),
+    metadata: {
+      source: "active",
+      revision: revision.revision,
+      digest: revision.digest,
+      cacheKey: `signup-control:${revision.digest}`
+    }
+  };
+}
+function attributes(metadata) {
+  return [
+    `id="${SIGNUP_CONTROL_THEME_STYLE_ID}"`,
+    `data-signup-control-source="${metadata.source}"`,
+    `data-signup-control-cache-key="${metadata.cacheKey}"`,
+    ...metadata.revision === null ? [] : [`data-signup-control-revision="${metadata.revision}"`],
+    ...metadata.digest === null ? [] : [`data-signup-control-digest="${metadata.digest}"`]
+  ].join(" ");
+}
+function renderSignupControlThemeHead(revision, options = {}) {
+  const { css, metadata } = stateFor(revision, options);
+  return { css, metadata, head: `<style ${attributes(metadata)}>${css}</style>` };
+}
+function injectSignupControlThemeHead(html, rendered, marker = SIGNUP_CONTROL_THEME_MARKER) {
+  const existing = /<style\b(?=[^>]*\bid\s*=\s*["']odla-signup-control-theme["'])[^>]*>[\s\S]*?<\/style>/gi;
+  const existingBlocks = html.match(existing) ?? [];
+  if (existingBlocks.length > 1) {
+    throw new TypeError("signup-control theme style block must appear at most once");
+  }
+  if (existingBlocks.length === 1) return html.replace(existing, rendered.head);
+  const markerIndex = html.indexOf(marker);
+  if (markerIndex >= 0) {
+    if (html.indexOf(marker, markerIndex + marker.length) >= 0) {
+      throw new TypeError("signup-control theme marker must appear exactly once");
+    }
+    return `${html.slice(0, markerIndex)}${rendered.head}${html.slice(markerIndex + marker.length)}`;
+  }
+  const closingHead = html.search(/<\/head\s*>/i);
+  if (closingHead < 0) throw new TypeError("signup-control theme requires an HTML head");
+  return `${html.slice(0, closingHead)}${rendered.head}${html.slice(closingHead)}`;
+}
+
+// src/signup-control-theme-worker.ts
+async function activeTheme(options) {
+  const active = await loadActiveSignupControl(options.db, options.chapterId, options.environment);
+  if (!active) return null;
+  const checked = validateSignupControlDocument(active.document);
+  if (!checked.ok) throw new TypeError(`active signup-control document is invalid: ${checked.errors.join("; ")}`);
+  const document = checked.value;
+  if (document.revision !== active.revision || document.target.chapterId !== options.chapterId || document.target.environment !== options.environment || active.digest !== await signupControlDigest(document)) {
+    throw new TypeError("active signup-control revision metadata or digest is invalid");
+  }
+  return { revision: active.revision, digest: active.digest, theme: document.theme };
+}
+async function renderActiveSignupControlHtml(html, options) {
+  const theme = renderSignupControlThemeHead(await activeTheme(options), {
+    bootstrapTokens: options.bootstrapTokens
+  });
+  return { html: injectSignupControlThemeHead(html, theme, options.marker), theme };
+}
+async function contentEtag(html) {
+  const bytes = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(html));
+  const hex = Array.from(new Uint8Array(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
+  return `W/"sha256-${hex}"`;
+}
+async function withActiveSignupControlTheme(response, options) {
+  if (!response.ok || !(response.headers.get("content-type") ?? "").toLowerCase().includes("text/html")) {
+    throw new TypeError("signup-control theme can only transform a successful HTML response");
+  }
+  const rendered = await renderActiveSignupControlHtml(await response.text(), options);
+  const headers = new Headers(response.headers);
+  headers.delete("content-length");
+  headers.set("cache-control", "no-store");
+  headers.set("etag", await contentEtag(rendered.html));
+  headers.set("x-odla-signup-control-digest", rendered.theme.metadata.digest ?? "bootstrap");
+  if (rendered.theme.metadata.revision === null) headers.delete("x-odla-signup-control-revision");
+  else headers.set("x-odla-signup-control-revision", String(rendered.theme.metadata.revision));
+  return new Response(rendered.html, { status: response.status, statusText: response.statusText, headers });
+}
+
 // src/worker.ts
 var BUILTIN_ROUTES = [
   handleHealth,