forgesmith 0.3.0 → 0.6.1

package/dist/index.cjs

@@ -1,12 +1,6 @@
 'use strict';
 
-var fs = require('fs/promises');
-var path = require('path');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var fs__default = /*#__PURE__*/_interopDefault(fs);
-var path__default = /*#__PURE__*/_interopDefault(path);
+var crypto = require('crypto');
 
 // src/generators/releaseNotes.ts
 function buildSystemPrompt() {
@@ -277,12 +271,12 @@ function detectImportCycles(edges) {
   const cycles = [];
   const visited = /* @__PURE__ */ new Set();
   const stack = /* @__PURE__ */ new Set();
-  function dfs(node, path2) {
+  function dfs(node, path) {
     if (cycles.length >= 5) return;
     if (stack.has(node)) {
-      const cycleStart = path2.indexOf(node);
+      const cycleStart = path.indexOf(node);
       if (cycleStart !== -1) {
-        cycles.push(path2.slice(cycleStart).join(" \u2192 ") + " \u2192 " + node);
+        cycles.push(path.slice(cycleStart).join(" \u2192 ") + " \u2192 " + node);
       }
       return;
     }
@@ -290,7 +284,7 @@ function detectImportCycles(edges) {
     visited.add(node);
     stack.add(node);
     for (const neighbor of graph.get(node) ?? []) {
-      dfs(neighbor, [...path2, node]);
+      dfs(neighbor, [...path, node]);
     }
     stack.delete(node);
   }
@@ -345,43 +339,6 @@ async function generateRefactoringReport(blueprint, opts, provider) {
     metadata: { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), usedTokens: response.usedTokens, generator: "forgesmith" }
   };
 }
-async function readJsonFiles(dir) {
-  try {
-    const entries = await fs__default.default.readdir(dir);
-    const results = [];
-    for (const entry of entries) {
-      if (!entry.endsWith(".json")) continue;
-      try {
-        const raw = await fs__default.default.readFile(path__default.default.join(dir, entry), "utf-8");
-        results.push(JSON.parse(raw));
-      } catch {
-      }
-    }
-    return results;
-  } catch {
-    return [];
-  }
-}
-async function readPrismDirectory(prismPath) {
-  const sessionsDir = path__default.default.join(prismPath, "sessions");
-  const recsDir = path__default.default.join(prismPath, "recommendations");
-  const insightsDir = path__default.default.join(prismPath, "green", "insights", "accepted");
-  const [sessions, recommendations, insights] = await Promise.all([
-    readJsonFiles(sessionsDir),
-    readJsonFiles(recsDir),
-    readJsonFiles(insightsDir)
-  ]);
-  return { sessions, recommendations, insights };
-}
-async function readBlueprintData(targetPath) {
-  const snapshotPath = path__default.default.join(targetPath, ".prism", "blueprint", "snapshot.json");
-  try {
-    const raw = await fs__default.default.readFile(snapshotPath, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
 
 // src/generators/askDrivenAsset.ts
 var NO_DATA_MSG5 = "No Blueprint data available. Run prism scan first.";
@@ -465,11 +422,2641 @@ async function generateAskDrivenAsset(blueprint, question, opts, provider) {
   };
 }
 
+// src/forge/types.ts
+var asAudienceId = (id) => id;
+
+// src/forge/distill.ts
+var MIN_CLAIMS = 3;
+var MAX_CLAIMS = 6;
+function clampClaims(claims) {
+  if (claims.length <= MAX_CLAIMS) return claims;
+  return claims.slice(0, MAX_CLAIMS);
+}
+function splitSentences(text) {
+  return text.split(/(?<=[.!?])\s+/).map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function fromBrief(payload) {
+  const body = typeof payload.body === "string" ? payload.body : "";
+  return splitSentences(body).slice(0, MAX_CLAIMS);
+}
+function fromKnowledgeRef(payload) {
+  const ids = Array.isArray(payload.blockIds) ? payload.blockIds : [];
+  const note = typeof payload.note === "string" ? payload.note : "";
+  const out = [];
+  if (note.trim().length > 0) out.push(note.trim());
+  for (const id of ids) {
+    out.push(`Knowledge reference: ${id}`);
+    if (out.length >= MAX_CLAIMS) break;
+  }
+  return out;
+}
+function fromGitRange(payload) {
+  const summary = payload.summary ?? {};
+  const commits = Array.isArray(summary.commits) ? summary.commits : [];
+  const subjects = commits.map((c) => typeof c?.subject === "string" ? c.subject : "").filter((s) => s.length > 0);
+  const files = typeof summary.files_changed_summary === "string" ? summary.files_changed_summary.split("\n").filter((l) => l.trim().length > 0) : [];
+  const out = [];
+  if (subjects.length > 0) {
+    out.push(`${commits.length} commit(s): ${subjects.slice(0, 3).join("; ")}`);
+  }
+  if (files.length > 0) {
+    const tail = files[files.length - 1] ?? "";
+    out.push(`Changes: ${tail.trim()}`);
+  }
+  for (const subj of subjects.slice(1, MAX_CLAIMS)) {
+    out.push(subj);
+    if (out.length >= MAX_CLAIMS) break;
+  }
+  return out;
+}
+function fromAppFeatureRef(payload) {
+  const ids = Array.isArray(payload.featureIds) ? payload.featureIds : [];
+  const note = typeof payload.note === "string" ? payload.note : "";
+  const out = [];
+  if (note.trim().length > 0) out.push(note.trim());
+  out.push(`References ${ids.length} app feature(s): ${ids.slice(0, 5).join(", ")}`);
+  return out;
+}
+function fromBusinessCapabilityRef(payload) {
+  const capabilityName = typeof payload.capability_name === "string" ? payload.capability_name : "";
+  const resolvedClaims = Array.isArray(payload.resolvedClaims) ? payload.resolvedClaims : [];
+  const out = [];
+  if (capabilityName.trim().length > 0) {
+    out.push(`Business capability: ${capabilityName}`);
+  }
+  for (const claim of resolvedClaims) {
+    if (typeof claim === "string" && claim.trim().length > 0) {
+      out.push(claim.trim());
+      if (out.length >= MAX_CLAIMS) break;
+    }
+  }
+  return out;
+}
+function buildSourceRefs(signal) {
+  const refs = signal.source_refs ?? {};
+  const collected = [];
+  for (const [key, val] of Object.entries(refs)) {
+    if (Array.isArray(val)) {
+      for (const item of val) {
+        if (typeof item === "string") collected.push(`${key}:${item}`);
+        else collected.push(`${key}:${JSON.stringify(item)}`);
+      }
+    }
+  }
+  if (collected.length === 0) collected.push(`signal:${signal.id}`);
+  return collected;
+}
+function distill(input) {
+  const { signal, audience } = input;
+  const payload = signal.payload ?? {};
+  let statements = [];
+  switch (signal.kind) {
+    case "brief":
+      statements = fromBrief(payload);
+      break;
+    case "knowledge_ref":
+      statements = fromKnowledgeRef(payload);
+      break;
+    case "git_range":
+      statements = fromGitRange(payload);
+      break;
+    case "app_feature_ref":
+      statements = fromAppFeatureRef(payload);
+      break;
+    case "business_capability_ref":
+      statements = fromBusinessCapabilityRef(payload);
+      break;
+    // amber_capability_ref uses the same pre-resolved payload shape as business_capability_ref.
+    case "amber_capability_ref":
+      statements = fromBusinessCapabilityRef(payload);
+      break;
+    // platform_walkthrough is reserved for the platform-adapter; graceful no-op here.
+    case "platform_walkthrough":
+      statements = [];
+      break;
+    // green_insight_ref: platform-adapter resolves insight_title + resolvedClaims before distill.
+    case "green_insight_ref": {
+      const insightTitle = typeof payload.insight_title === "string" ? payload.insight_title : "";
+      const resolvedClaims = Array.isArray(payload.resolvedClaims) ? payload.resolvedClaims : [];
+      const out = [];
+      if (insightTitle.trim().length > 0) {
+        out.push(`GREEN insight: ${insightTitle}`);
+      }
+      for (const c of resolvedClaims) {
+        if (typeof c === "string" && c.trim().length > 0) {
+          out.push(c.trim());
+        }
+      }
+      statements = out;
+      break;
+    }
+  }
+  if (statements.length < MIN_CLAIMS) {
+    const fallback = `Signal of kind ${signal.kind} for audience ${audience.id}.`;
+    while (statements.length < MIN_CLAIMS) statements.push(fallback);
+  }
+  const refs = buildSourceRefs(signal);
+  const claims = clampClaims(
+    statements.map((statement, i) => ({
+      id: `c${i + 1}`,
+      statement,
+      source_ref: refs[i % refs.length] ?? `signal:${signal.id}`
+    }))
+  );
+  return {
+    signal_id: signal.id,
+    audience_id: String(audience.id),
+    audience_label: audience.label,
+    tonality: audience.tonality,
+    reading_level: audience.reading_level,
+    claims,
+    raw_source_refs: signal.source_refs ?? {}
+  };
+}
+
+// src/forge/promptAssembly.ts
+var EXECUTOR_SPICKZETTEL = `You are a precise execution agent. Your role is to carry out a specific step given a fully-specified context.
+- You act on the provided state and knowledge blocks.
+- You return a concrete next_action and state_delta.
+- You never invent facts. If domain rules are missing, you set knowledge_missing.
+- Confidence reflects how certain you are that your action is correct.`;
+var FORGE_WRITER_SPICKZETTEL = `${EXECUTOR_SPICKZETTEL}
+
+You write product communication. Your job is to take a structured ProductTruth
+(claims + source refs) and produce a JSON object that fills the template's
+schema_json. Stay inside the audience's tonality and reading level. Never
+invent facts that are not present in the ProductTruth.`;
+function appendJsonSchemaInstruction(systemPrompt, schemaName, schema) {
+  const schemaText = JSON.stringify(schema, null, 2);
+  const block = [
+    "",
+    "\u2500\u2500\u2500 OUTPUT CONTRACT \u2500\u2500\u2500",
+    `You MUST respond with a single valid JSON object that satisfies the schema named "${schemaName}".`,
+    "Return ONLY the JSON object. No prose before or after. No markdown fences.",
+    "If a field cannot be filled given the inputs, set it to an empty string or empty array \u2014 do NOT omit required keys.",
+    "",
+    `Schema (${schemaName}):`,
+    schemaText
+  ].join("\n");
+  return `${systemPrompt}
+${block}`;
+}
+function tonalityInstruction(audience) {
+  return [
+    `Audience: ${audience.label} (${audience.id}).`,
+    `Tonality: ${audience.tonality}.`,
+    `Reading level: ${audience.reading_level}.`,
+    `Channel hints: ${audience.channel_hints.join(", ")}.`,
+    audience.description
+  ].join(" ");
+}
+function formatSpec(resolved) {
+  return [
+    `Channel: ${resolved.channel}.`,
+    `Intent: ${resolved.intent}.`,
+    `Format: ${resolved.format}.`,
+    `Modality: ${resolved.modality}.`
+  ].join(" ");
+}
+function interactiveVisualSlotsBlock(template) {
+  const slots = Array.isArray(template.asset_slots) ? template.asset_slots : [];
+  const visual = slots.map(
+    (raw) => typeof raw === "object" && raw !== null ? raw : null
+  ).filter(
+    (s) => s !== null && s.modality === "interactive_visual"
+  );
+  if (visual.length === 0) return null;
+  const lines = ["\u2500\u2500\u2500 INTERACTIVE VISUAL SLOTS \u2500\u2500\u2500"];
+  const perDocument = [];
+  const perSlide = [];
+  visual.forEach((slot, i) => {
+    const kind = typeof slot.kind === "string" ? slot.kind : `slot_${i}`;
+    const per = typeof slot.per === "string" ? slot.per : "document";
+    const rs = slot.render_spec ?? {};
+    const w = typeof rs.width === "number" ? rs.width : 800;
+    const h = typeof rs.height === "number" ? rs.height : 450;
+    const ar = typeof rs.aspect_ratio === "string" ? rs.aspect_ratio : `${w}:${h}`;
+    lines.push(
+      `\u2022 ${kind} (per ${per}) \u2014 target viewport ${w}\xD7${h} px, aspect ratio ${ar}. The brief you write for this slot will be rendered inside a fixed-dimension widget; describe a layout that reads cleanly at exactly those proportions.`
+    );
+    if (per === "slide") perSlide.push(slot);
+    else perDocument.push(slot);
+  });
+  lines.push("");
+  lines.push("REQUIRED OUTPUT FIELDS for the interactive_visual slots above:");
+  if (perDocument.length > 0) {
+    lines.push(
+      "\u2022 Add a TOP-LEVEL `visual_brief` field (string) to your JSON output. Describe the widget's visual structure, content, and any data values needed to render it. 2\u20136 sentences, concrete, no marketing."
+    );
+  }
+  if (perSlide.length > 0) {
+    lines.push(
+      "\u2022 Each entry of `slides` MUST include a `visual_brief` field (string) describing what the slide-specific widget should draw. Keep each visual_brief 1\u20133 sentences, concrete."
+    );
+  }
+  lines.push(
+    "These fields are in addition to the schema's other required keys; do NOT omit them. Without them the visual cannot be rendered."
+  );
+  return lines.join("\n");
+}
+function productTruthBlock(truth) {
+  const claims = truth.claims.map((c) => `- (${c.id}) [${c.source_ref}] ${c.statement}`).join("\n");
+  return ["ProductTruth (deterministic, do not extend):", claims].join("\n");
+}
+function assembleForgePrompt(input) {
+  const { template, audience, productTruth, resolved, contextBlocks } = input;
+  const visualBlock = interactiveVisualSlotsBlock(template);
+  const systemBase = [
+    FORGE_WRITER_SPICKZETTEL,
+    "",
+    "\u2500\u2500\u2500 AUDIENCE \u2500\u2500\u2500",
+    tonalityInstruction(audience),
+    "",
+    "\u2500\u2500\u2500 FORMAT \u2500\u2500\u2500",
+    formatSpec(resolved),
+    ...visualBlock ? ["", visualBlock] : []
+  ].join("\n");
+  const schemaName = `forge.${template.id}`;
+  const system = appendJsonSchemaInstruction(systemBase, schemaName, template.schema_json);
+  const blocks = (contextBlocks ?? []).filter(
+    (b) => typeof b === "string" && b.trim().length > 0
+  );
+  const userParts = [];
+  for (const b of blocks) {
+    userParts.push(b);
+    userParts.push("");
+  }
+  userParts.push(productTruthBlock(productTruth));
+  userParts.push("");
+  userParts.push("Produce the JSON object now.");
+  const user = userParts.join("\n");
+  return { system, user, schema_name: schemaName, schema: template.schema_json };
+}
+
+// src/forge/validateResult.ts
+function isStringValue(v) {
+  return typeof v === "string" && v.trim().length > 0;
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isSchemaSections(s) {
+  return isPlainObject(s) && Array.isArray(s.sections) && s.sections.every((x) => typeof x === "string");
+}
+function isSchemaSlides(s) {
+  if (!isPlainObject(s)) return false;
+  const sl = s.slides;
+  return isPlainObject(sl) && typeof sl.min === "number" && typeof sl.max === "number";
+}
+function validateAgainstTemplateSchema(schema, candidate) {
+  if (!isPlainObject(candidate)) {
+    return { ok: false, errors: ["result is not a JSON object"] };
+  }
+  if (isSchemaSections(schema)) {
+    const missing = [];
+    for (const key of schema.sections) {
+      if (!isStringValue(candidate[key])) missing.push(key);
+    }
+    if (missing.length > 0) {
+      return {
+        ok: false,
+        errors: [`missing or empty section field(s): ${missing.join(", ")}`]
+      };
+    }
+    return { ok: true, value: candidate };
+  }
+  if (isSchemaSlides(schema)) {
+    const slides = candidate.slides;
+    if (!Array.isArray(slides)) {
+      return { ok: false, errors: ["slides must be an array"] };
+    }
+    const { min, max } = schema.slides;
+    if (slides.length < min || slides.length > max) {
+      return {
+        ok: false,
+        errors: [`slides length ${slides.length} not in [${min}, ${max}]`]
+      };
+    }
+    const slideErrors = [];
+    slides.forEach((s, i) => {
+      if (!isPlainObject(s)) {
+        slideErrors.push(`slide[${i}] not an object`);
+        return;
+      }
+      const hasBody = isStringValue(s.body);
+      const hasHeadline = isStringValue(s.headline);
+      if (!hasBody && !hasHeadline) {
+        slideErrors.push(`slide[${i}] requires non-empty body or headline`);
+      }
+    });
+    if (slideErrors.length > 0) {
+      return { ok: false, errors: slideErrors };
+    }
+    return { ok: true, value: candidate };
+  }
+  return {
+    ok: false,
+    errors: ["template schema_json is not in a supported shape"],
+    unsupported: ["unrecognized schema shape"]
+  };
+}
+function tryParseJsonObject(raw) {
+  let s = raw.trim();
+  const fenceMatch = s.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fenceMatch) s = fenceMatch[1].trim();
+  const first = s.indexOf("{");
+  const last = s.lastIndexOf("}");
+  if (first === -1 || last === -1 || last <= first) {
+    throw new Error("no JSON object found in model output");
+  }
+  const slice = s.slice(first, last + 1);
+  return JSON.parse(slice);
+}
+
+// src/forge/validateSchemaDefinition.ts
+function isPlainObject2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function validateSchemaDefinition(input) {
+  if (!isPlainObject2(input)) {
+    return { valid: false, errors: ["schema_json must be an object"] };
+  }
+  if (typeof input.type !== "string" || input.type.length === 0) {
+    return {
+      valid: false,
+      errors: ["schema_json must declare a top-level `type` (e.g. 'object')"]
+    };
+  }
+  if (input.type === "object" && input.properties !== void 0) {
+    if (!isPlainObject2(input.properties)) {
+      return {
+        valid: false,
+        errors: ["schema_json.properties must be a flat object record"]
+      };
+    }
+    const propErrors = [];
+    for (const [name, def] of Object.entries(input.properties)) {
+      if (!isPlainObject2(def)) {
+        propErrors.push(`properties.${name} must be an object`);
+        continue;
+      }
+      if (typeof def.type !== "string" || def.type.length === 0) {
+        propErrors.push(`properties.${name}.type required`);
+      }
+    }
+    if (propErrors.length > 0) {
+      return { valid: false, errors: propErrors };
+    }
+  }
+  return { valid: true };
+}
+function parseAndValidateSchemaDefinition(jsonText) {
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonText);
+  } catch (e) {
+    return {
+      valid: false,
+      errors: [
+        `schema_json is not valid JSON: ${e instanceof Error ? e.message : String(e)}`
+      ]
+    };
+  }
+  const result = validateSchemaDefinition(parsed);
+  if (!result.valid) return result;
+  return { valid: true, parsed };
+}
+
+// src/forge/validateAssetSlots.ts
+var VALID_MODALITIES = [
+  "text",
+  "text_with_visual_brief",
+  "interactive_visual",
+  "image",
+  "video",
+  "mixed"
+];
+var VALID_PER = /* @__PURE__ */ new Set(["document", "slide"]);
+var ASPECT_RATIO_RE = /^\d+:\d+$/;
+var MIN_W = 320;
+var MAX_W = 4096;
+var MIN_H = 240;
+var MAX_H = 4096;
+function isPlainObject3(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isInt(v) {
+  return typeof v === "number" && Number.isFinite(v) && Number.isInteger(v);
+}
+function validateAssetSlots(input) {
+  if (!Array.isArray(input)) {
+    return { valid: false, errors: ["asset_slots must be an array"] };
+  }
+  const errors = [];
+  input.forEach((raw, i) => {
+    if (!isPlainObject3(raw)) {
+      errors.push(`asset_slots[${i}] must be an object`);
+      return;
+    }
+    const kind = raw.kind;
+    if (typeof kind !== "string" || kind.length === 0) {
+      errors.push(`asset_slots[${i}].kind must be a non-empty string`);
+    }
+    const per = raw.per;
+    if (typeof per !== "string" || !VALID_PER.has(per)) {
+      errors.push(
+        `asset_slots[${i}].per must be 'document' or 'slide' (got ${JSON.stringify(per)})`
+      );
+    }
+    const modality = raw.modality;
+    if (typeof modality !== "string" || !VALID_MODALITIES.includes(modality)) {
+      errors.push(
+        `asset_slots[${i}].modality invalid (got ${JSON.stringify(modality)})`
+      );
+    }
+    if (modality === "interactive_visual") {
+      const rs = raw.render_spec;
+      if (!isPlainObject3(rs)) {
+        errors.push(
+          `asset_slots[${i}].render_spec required when modality='interactive_visual'`
+        );
+      } else {
+        const ar = rs.aspect_ratio;
+        if (typeof ar !== "string" || !ASPECT_RATIO_RE.test(ar)) {
+          errors.push(
+            `asset_slots[${i}].render_spec.aspect_ratio must match \\d+:\\d+`
+          );
+        }
+        const w = rs.width;
+        if (!isInt(w) || w < MIN_W || w > MAX_W) {
+          errors.push(
+            `asset_slots[${i}].render_spec.width must be an integer in [${MIN_W}, ${MAX_W}]`
+          );
+        }
+        const h = rs.height;
+        if (!isInt(h) || h < MIN_H || h > MAX_H) {
+          errors.push(
+            `asset_slots[${i}].render_spec.height must be an integer in [${MIN_H}, ${MAX_H}]`
+          );
+        }
+        if (rs.animated !== void 0 && typeof rs.animated !== "boolean") {
+          errors.push(
+            `asset_slots[${i}].render_spec.animated must be a boolean when present`
+          );
+        }
+      }
+    }
+  });
+  return errors.length === 0 ? { valid: true } : { valid: false, errors };
+}
+
+// src/forge/animationChoice.ts
+function isPlainObject4(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function templateAnimatedDefault(assetSlots) {
+  if (!Array.isArray(assetSlots)) return false;
+  for (const raw of assetSlots) {
+    if (!isPlainObject4(raw)) continue;
+    if (raw.modality !== "interactive_visual") continue;
+    const rs = raw.render_spec;
+    if (isPlainObject4(rs) && rs.animated === true) return true;
+  }
+  return false;
+}
+function resolveAnimatedChoice(templateDefault, override) {
+  return typeof override === "boolean" ? override : templateDefault;
+}
+
+// src/forge/animationDuration.ts
+var DEFAULT_ANIMATION_DURATION_SECONDS = 10;
+var ANIMATION_DURATION_PRESETS = [5, 10, 20, 30];
+var MIN_ANIMATION_DURATION_SECONDS = 1;
+var MAX_ANIMATION_DURATION_SECONDS = 120;
+function isUsableDuration(v) {
+  return typeof v === "number" && Number.isFinite(v) && v > 0;
+}
+function clampAnimationDuration(seconds) {
+  if (!Number.isFinite(seconds)) return DEFAULT_ANIMATION_DURATION_SECONDS;
+  return Math.min(
+    MAX_ANIMATION_DURATION_SECONDS,
+    Math.max(MIN_ANIMATION_DURATION_SECONDS, Math.round(seconds))
+  );
+}
+function resolveAnimationDuration(override, persisted, fallback = DEFAULT_ANIMATION_DURATION_SECONDS) {
+  if (isUsableDuration(override)) return clampAnimationDuration(override);
+  if (isUsableDuration(persisted)) return clampAnimationDuration(persisted);
+  return clampAnimationDuration(fallback);
+}
+
+// src/forge/refineLimit.ts
+var REFINE_SESSION_SOFT_CAP = 100;
+var REFINE_COUNTDOWN_THRESHOLD = 90;
+function refineLimitState(usedRefines, softCap = REFINE_SESSION_SOFT_CAP) {
+  const used = Number.isFinite(usedRefines) && usedRefines > 0 ? Math.floor(usedRefines) : 0;
+  const remaining = Math.max(0, softCap - used);
+  return {
+    used,
+    capped: used >= softCap,
+    remaining,
+    showCountdown: used >= REFINE_COUNTDOWN_THRESHOLD
+  };
+}
+
+// src/forge/brandKit.ts
+var DEFAULT_BRAND_KIT_PALETTE = {
+  primary: "#f97316",
+  secondary: "#1e293b",
+  accent: "#fb923c",
+  surface: "#0f172a",
+  text: "#f1f5f9",
+  muted: "#64748b"
+};
+var DEFAULT_BRAND_KIT_FONTS = {
+  heading: "Inter",
+  body: "Inter",
+  mono: "JetBrains Mono"
+};
+var DEFAULT_BRAND_KIT_VOICE = {
+  tone: "professional",
+  audience: "developers",
+  vocabulary: [],
+  avoid: [],
+  formality: 60,
+  technicality: 70
+};
+function defaultBrandKit(partial) {
+  return {
+    name: "My Brand",
+    source: "manual",
+    palette: { ...DEFAULT_BRAND_KIT_PALETTE },
+    fonts: { ...DEFAULT_BRAND_KIT_FONTS },
+    voice: { ...DEFAULT_BRAND_KIT_VOICE },
+    logo: {},
+    version: 1,
+    versions: [],
+    ...partial
+  };
+}
+function assembleBrandUrlExtractionPrompt(hints) {
+  const lines = [
+    `Extract a brand kit from the following website metadata.`,
+    `URL: ${hints.url}`
+  ];
+  if (hints.pageTitle) lines.push(`Page title: ${hints.pageTitle}`);
+  if (hints.metaDescription) lines.push(`Meta description: ${hints.metaDescription}`);
+  if (hints.themeColor) lines.push(`Theme color: ${hints.themeColor}`);
+  if (hints.cssColorHints?.length) lines.push(`Color hints from CSS/HTML: ${hints.cssColorHints.join(", ")}`);
+  if (hints.fontHints?.length) lines.push(`Font hints: ${hints.fontHints.join(", ")}`);
+  lines.push(
+    "",
+    "Return a JSON object with exactly this structure (use hex colors, fill all fields with your best inference):",
+    JSON.stringify({
+      name: "<brand name>",
+      palette: {
+        primary: "#rrggbb",
+        secondary: "#rrggbb",
+        accent: "#rrggbb",
+        surface: "#rrggbb",
+        text: "#rrggbb",
+        muted: "#rrggbb"
+      },
+      fonts: {
+        heading: "<font name>",
+        body: "<font name>",
+        mono: "<font name or 'monospace'>"
+      },
+      voice: {
+        tone: "<professional|technical|casual|inspirational|authoritative>",
+        audience: "<developers|executives|general|designers|business>",
+        vocabulary: ["<preferred term>"],
+        avoid: ["<term to avoid>"],
+        formality: 70,
+        technicality: 50
+      },
+      logo: { url: "<logo url if known or empty string>" }
+    }, null, 2),
+    "",
+    "Respond with ONLY the JSON object, no markdown fences, no explanation."
+  );
+  return lines.join("\n");
+}
+function isValidHex(v) {
+  return typeof v === "string" && /^#[0-9a-fA-F]{3,8}$/.test(v.trim());
+}
+function safeHex(v, fallback) {
+  return isValidHex(v) ? v.trim() : fallback;
+}
+function safeStr(v, fallback) {
+  return typeof v === "string" && v.trim() ? v.trim() : fallback;
+}
+function safeNum(v, fallback) {
+  const n = Number(v);
+  return Number.isFinite(n) ? Math.max(0, Math.min(100, n)) : fallback;
+}
+function parseBrandKitFromLlmResponse(text, hints) {
+  let raw;
+  const cleaned = text.replace(/^```json\s*/i, "").replace(/^```\s*/i, "").replace(/\s*```\s*$/i, "").trim();
+  try {
+    raw = JSON.parse(cleaned);
+  } catch {
+    const match = /\{[\s\S]*\}/.exec(text);
+    if (match) {
+      try {
+        raw = JSON.parse(match[0]);
+      } catch {
+        raw = {};
+      }
+    } else {
+      raw = {};
+    }
+  }
+  const r = raw && typeof raw === "object" ? raw : {};
+  const palette = r.palette && typeof r.palette === "object" ? r.palette : {};
+  const fonts = r.fonts && typeof r.fonts === "object" ? r.fonts : {};
+  const voice = r.voice && typeof r.voice === "object" ? r.voice : {};
+  const logo = r.logo && typeof r.logo === "object" ? r.logo : {};
+  const vocab = Array.isArray(voice.vocabulary) ? voice.vocabulary.filter((v) => typeof v === "string") : [];
+  const avoid = Array.isArray(voice.avoid) ? voice.avoid.filter((v) => typeof v === "string") : [];
+  return {
+    name: safeStr(r.name, new URL(hints.url).hostname.replace(/^www\./, "")),
+    source: "url",
+    source_url: hints.url,
+    palette: {
+      primary: safeHex(palette.primary, hints.themeColor ?? DEFAULT_BRAND_KIT_PALETTE.primary),
+      secondary: safeHex(palette.secondary, DEFAULT_BRAND_KIT_PALETTE.secondary),
+      accent: safeHex(palette.accent, DEFAULT_BRAND_KIT_PALETTE.accent),
+      surface: safeHex(palette.surface, DEFAULT_BRAND_KIT_PALETTE.surface),
+      text: safeHex(palette.text, DEFAULT_BRAND_KIT_PALETTE.text),
+      muted: safeHex(palette.muted, DEFAULT_BRAND_KIT_PALETTE.muted)
+    },
+    fonts: {
+      heading: safeStr(fonts.heading, DEFAULT_BRAND_KIT_FONTS.heading),
+      body: safeStr(fonts.body, DEFAULT_BRAND_KIT_FONTS.body),
+      mono: safeStr(fonts.mono, DEFAULT_BRAND_KIT_FONTS.mono)
+    },
+    voice: {
+      tone: safeStr(voice.tone, DEFAULT_BRAND_KIT_VOICE.tone),
+      audience: safeStr(voice.audience, DEFAULT_BRAND_KIT_VOICE.audience),
+      vocabulary: vocab,
+      avoid,
+      formality: safeNum(voice.formality, DEFAULT_BRAND_KIT_VOICE.formality),
+      technicality: safeNum(voice.technicality, DEFAULT_BRAND_KIT_VOICE.technicality)
+    },
+    logo: { url: safeStr(logo.url, "") || void 0 },
+    prism_detected: false
+  };
+}
+
+// src/forge/brandPalette.ts
+function isNonEmptyString(v) {
+  return typeof v === "string" && v.trim().length > 0;
+}
+function themeEntryToPalette(entry) {
+  if (!entry || typeof entry !== "object") return null;
+  const { primary, accent, bg, text } = entry;
+  if (!isNonEmptyString(primary) || !isNonEmptyString(accent) || !isNonEmptyString(bg) || !isNonEmptyString(text)) {
+    return null;
+  }
+  return {
+    primary: primary.trim(),
+    accent: accent.trim(),
+    background: bg.trim(),
+    card: isNonEmptyString(entry.card) ? entry.card.trim() : "#ffffff",
+    text: text.trim()
+  };
+}
+function parseThemeConfigContent(content) {
+  let value = content;
+  if (typeof value === "string") {
+    try {
+      value = JSON.parse(value);
+    } catch {
+      return [];
+    }
+  }
+  if (!Array.isArray(value)) return [];
+  return value.filter(
+    (e) => typeof e === "object" && e !== null && !Array.isArray(e)
+  );
+}
+var FORGE_BRAND_THEME_ID = "__forge_brand__";
+var BRAND_CONTENT_SLOT_KEYS = {
+  primary: "content-primary",
+  accent: "content-accent",
+  bg: "content-bg",
+  card: "content-card",
+  text: "content-text"
+};
+function parseBrandThemeContent(content) {
+  let value = content;
+  if (typeof value === "string") {
+    try {
+      value = JSON.parse(value);
+    } catch {
+      return [];
+    }
+  }
+  if (!Array.isArray(value)) return [];
+  return value.filter(
+    (e) => typeof e === "object" && e !== null && !Array.isArray(e)
+  );
+}
+function brandThemeConfigToEntry(config) {
+  if (!config || typeof config !== "object") return null;
+  const values = config.values;
+  if (!values || typeof values !== "object") return null;
+  const entry = {
+    id: FORGE_BRAND_THEME_ID,
+    label: config.name ?? "Brand",
+    primary: values[BRAND_CONTENT_SLOT_KEYS.primary],
+    accent: values[BRAND_CONTENT_SLOT_KEYS.accent],
+    bg: values[BRAND_CONTENT_SLOT_KEYS.bg],
+    card: values[BRAND_CONTENT_SLOT_KEYS.card],
+    text: values[BRAND_CONTENT_SLOT_KEYS.text]
+  };
+  return themeEntryToPalette(entry) ? entry : null;
+}
+function resolveBrandPalette(input) {
+  if (isNonEmptyString(input.selectedThemeId)) {
+    const picked = input.themes.find((t) => t.id === input.selectedThemeId);
+    const palette = themeEntryToPalette(picked);
+    if (palette) return palette;
+  }
+  return input.scope === "app" ? input.appDefault : input.frameworkDefault;
+}
+
+// src/forge/schemaToForm.ts
+var MULTILINE_KEYWORDS = /body|brief|description|content|text|copy|hashtags|caption|outline|notes|story|paragraph/i;
+var MULTILINE_MAX_LENGTH = 200;
+function isPlainObject5(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function humanise(name) {
+  return name.replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim().replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function isMultilineString(name, def) {
+  const max = typeof def.maxLength === "number" ? def.maxLength : void 0;
+  if (max !== void 0) return max > MULTILINE_MAX_LENGTH;
+  return MULTILINE_KEYWORDS.test(name);
+}
+function resolveProperty(name, def, required) {
+  const description = typeof def.description === "string" ? def.description : void 0;
+  const label = humanise(name);
+  const t = def.type;
+  if (t === "string") {
+    const enumVals = Array.isArray(def.enum) ? def.enum.filter((x) => typeof x === "string") : void 0;
+    return {
+      kind: "string",
+      name,
+      label,
+      required,
+      description,
+      multiline: enumVals ? false : isMultilineString(name, def),
+      ...enumVals ? { enum: enumVals } : {},
+      ...typeof def.maxLength === "number" ? { maxLength: def.maxLength } : {},
+      ...typeof def.minLength === "number" ? { minLength: def.minLength } : {}
+    };
+  }
+  if (t === "number" || t === "integer") {
+    return {
+      kind: "number",
+      name,
+      label,
+      required,
+      description,
+      integer: t === "integer",
+      ...typeof def.minimum === "number" ? { minimum: def.minimum } : {},
+      ...typeof def.maximum === "number" ? { maximum: def.maximum } : {}
+    };
+  }
+  if (t === "boolean") {
+    return { kind: "boolean", name, label, required, description };
+  }
+  if (t === "array") {
+    const items = isPlainObject5(def.items) ? def.items : null;
+    const itemField = items ? resolveProperty("item", items, true) : null;
+    return {
+      kind: "array",
+      name,
+      label,
+      required,
+      description,
+      itemField,
+      ...typeof def.minItems === "number" ? { minItems: def.minItems } : {},
+      ...typeof def.maxItems === "number" ? { maxItems: def.maxItems } : {}
+    };
+  }
+  if (t === "object" && isPlainObject5(def.properties)) {
+    const reqList = Array.isArray(def.required) ? def.required.filter((x) => typeof x === "string") : [];
+    const fields = [];
+    for (const [k, d] of Object.entries(def.properties)) {
+      if (!isPlainObject5(d)) return null;
+      const f = resolveProperty(k, d, reqList.includes(k));
+      if (!f) return null;
+      fields.push(f);
+    }
+    return { kind: "object", name, label, required, description, fields };
+  }
+  return null;
+}
+function schemaToForm(schema) {
+  if (!isPlainObject5(schema)) {
+    return { kind: "raw", reason: "schema_json is not an object" };
+  }
+  if (schema.type === "object" && isPlainObject5(schema.properties)) {
+    const reqList = Array.isArray(schema.required) ? schema.required.filter((x) => typeof x === "string") : [];
+    const fields = [];
+    for (const [name, def] of Object.entries(schema.properties)) {
+      if (!isPlainObject5(def)) {
+        return {
+          kind: "raw",
+          reason: `property '${name}' is not an object \u2014 cannot render`
+        };
+      }
+      const f = resolveProperty(name, def, reqList.includes(name));
+      if (!f) {
+        return {
+          kind: "raw",
+          reason: `property '${name}' uses an unsupported type \u2014 cannot render`
+        };
+      }
+      fields.push(f);
+    }
+    if (fields.length === 0) {
+      return { kind: "raw", reason: "schema has no properties to render" };
+    }
+    return { kind: "form", fields };
+  }
+  if (Array.isArray(schema.sections)) {
+    const sections = schema.sections.filter(
+      (x) => typeof x === "string"
+    );
+    if (sections.length === 0) {
+      return { kind: "raw", reason: "sections array is empty" };
+    }
+    const fields = sections.map((name) => ({
+      kind: "string",
+      name,
+      label: humanise(name),
+      required: true,
+      multiline: MULTILINE_KEYWORDS.test(name)
+    }));
+    return { kind: "form", fields };
+  }
+  return { kind: "raw", reason: "schema shape not form-compatible" };
+}
+function defaultValueForField(field) {
+  switch (field.kind) {
+    case "string":
+      return "";
+    case "number":
+      return "";
+    case "boolean":
+      return false;
+    case "array":
+      return [];
+    case "object":
+      return initialFormValues(field.fields, {});
+  }
+}
+function pickInitialValue(field, current) {
+  switch (field.kind) {
+    case "string":
+      return typeof current === "string" ? current : "";
+    case "number":
+      return typeof current === "number" ? current : "";
+    case "boolean":
+      return typeof current === "boolean" ? current : false;
+    case "array":
+      return Array.isArray(current) ? current.slice() : [];
+    case "object": {
+      const c = isPlainObject5(current) ? current : {};
+      return initialFormValues(field.fields, c);
+    }
+  }
+}
+function initialFormValues(fields, source) {
+  const out = {};
+  for (const f of fields) {
+    out[f.name] = source[f.name] !== void 0 ? pickInitialValue(f, source[f.name]) : defaultValueForField(f);
+  }
+  return out;
+}
+function isEmptyString(v) {
+  return typeof v === "string" && v.trim().length === 0;
+}
+function validateField(field, value, path) {
+  const errors = {};
+  switch (field.kind) {
+    case "string": {
+      if (field.required && (value === void 0 || value === null || isEmptyString(value))) {
+        errors[path] = `${field.label} ist erforderlich`;
+        break;
+      }
+      if (typeof value === "string") {
+        if (field.minLength !== void 0 && value.length < field.minLength) {
+          errors[path] = `${field.label} mindestens ${field.minLength} Zeichen`;
+        } else if (field.maxLength !== void 0 && value.length > field.maxLength) {
+          errors[path] = `${field.label} h\xF6chstens ${field.maxLength} Zeichen`;
+        } else if (field.enum && value.length > 0 && !field.enum.includes(value)) {
+          errors[path] = `${field.label}: Wert nicht in der Auswahl`;
+        }
+      }
+      break;
+    }
+    case "number": {
+      if (value === "" || value === void 0 || value === null) {
+        if (field.required) errors[path] = `${field.label} ist erforderlich`;
+        break;
+      }
+      const n = typeof value === "number" ? value : Number(value);
+      if (!Number.isFinite(n)) {
+        errors[path] = `${field.label} muss eine Zahl sein`;
+      } else if (field.integer && !Number.isInteger(n)) {
+        errors[path] = `${field.label} muss eine ganze Zahl sein`;
+      } else if (field.minimum !== void 0 && n < field.minimum) {
+        errors[path] = `${field.label} >= ${field.minimum}`;
+      } else if (field.maximum !== void 0 && n > field.maximum) {
+        errors[path] = `${field.label} <= ${field.maximum}`;
+      }
+      break;
+    }
+    case "boolean":
+      if (field.required && value !== true) {
+        errors[path] = `${field.label} muss aktiviert sein`;
+      }
+      break;
+    case "array": {
+      const arr = Array.isArray(value) ? value : [];
+      if (field.required && arr.length === 0) {
+        errors[path] = `${field.label}: mindestens ein Eintrag erforderlich`;
+      }
+      if (field.minItems !== void 0 && arr.length < field.minItems) {
+        errors[path] = `${field.label}: mindestens ${field.minItems} Eintr\xE4ge`;
+      } else if (field.maxItems !== void 0 && arr.length > field.maxItems) {
+        errors[path] = `${field.label}: h\xF6chstens ${field.maxItems} Eintr\xE4ge`;
+      }
+      if (field.itemField) {
+        arr.forEach((item, i) => {
+          const sub = validateField(
+            field.itemField,
+            item,
+            `${path}[${i}]`
+          );
+          Object.assign(errors, sub);
+        });
+      }
+      break;
+    }
+    case "object": {
+      const obj = isPlainObject5(value) ? value : {};
+      for (const sub of field.fields) {
+        const subErrors = validateField(sub, obj[sub.name], `${path}.${sub.name}`);
+        Object.assign(errors, subErrors);
+      }
+      break;
+    }
+  }
+  return errors;
+}
+function validateFormValues(fields, values) {
+  const errors = {};
+  for (const f of fields) {
+    Object.assign(errors, validateField(f, values[f.name], f.name));
+  }
+  return errors;
+}
+var TEMPLATE_SCHEMA_EXAMPLES = {
+  long_article: {
+    type: "object",
+    required: ["headline", "lede", "sections"],
+    properties: {
+      headline: { type: "string" },
+      lede: { type: "string" },
+      sections: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: { h2: { type: "string" }, body: { type: "string" } },
+          required: ["h2", "body"]
+        }
+      }
+    }
+  },
+  short_post: {
+    type: "object",
+    required: ["hook", "body"],
+    properties: {
+      hook: { type: "string", maxLength: 200 },
+      body: { type: "string", maxLength: 1200 },
+      cta: { type: "string" }
+    }
+  },
+  carousel_sequence: {
+    type: "object",
+    required: ["slides"],
+    properties: {
+      slides: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            headline: { type: "string" },
+            body: { type: "string" },
+            visual_brief: { type: "string" }
+          },
+          required: ["headline", "body"]
+        }
+      }
+    }
+  }
+};
+var TEMPLATE_SCHEMA_GENERIC = {
+  type: "object",
+  required: ["body"],
+  properties: { body: { type: "string" } }
+};
+function schemaExampleFor(format) {
+  return TEMPLATE_SCHEMA_EXAMPLES[format] ?? TEMPLATE_SCHEMA_GENERIC;
+}
+
+// src/forge/engine.ts
+async function runForgeGeneration(input) {
+  const { storage, provider } = input;
+  const [signal, template] = await Promise.all([
+    storage.getSignal(input.signalId),
+    storage.getTemplate(input.templateId)
+  ]);
+  if (!signal) {
+    return { kind: "error", status: 404, error: "signal not found", field: "signalId" };
+  }
+  if (!template) {
+    return { kind: "error", status: 404, error: "template not found", field: "templateId" };
+  }
+  const resolved = {
+    channel: template.channel,
+    audience_id: input.audienceOverride ?? String(template.audience_id),
+    intent: input.intentOverride ?? template.intent,
+    format: input.formatOverride ?? template.format,
+    modality: input.modalityOverride ?? template.modality
+  };
+  const audience = await storage.getAudience(resolved.audience_id);
+  if (!audience) {
+    return {
+      kind: "error",
+      status: 404,
+      error: "audience not found",
+      field: "audienceOverride"
+    };
+  }
+  const productTruth = distill({
+    signal,
+    audience
+  });
+  const prompt = assembleForgePrompt({
+    template,
+    audience,
+    productTruth,
+    resolved
+  });
+  if (input.dryRun) {
+    return {
+      kind: "dry_run",
+      payload: {
+        dryRun: true,
+        resolved,
+        product_truth: productTruth,
+        prompt: {
+          system: prompt.system,
+          user: prompt.user,
+          schema_name: prompt.schema_name
+        }
+      }
+    };
+  }
+  let rawResponse = "";
+  let parseError = null;
+  let parsed = null;
+  let validation = null;
+  try {
+    const result = await provider.complete({
+      systemPrompt: prompt.system,
+      messages: [{ role: "user", content: prompt.user }],
+      maxTokens: input.maxTokens ?? 4096
+    });
+    rawResponse = result.content;
+  } catch (err) {
+    parseError = err instanceof Error ? err.message : String(err);
+  }
+  if (!parseError) {
+    try {
+      parsed = tryParseJsonObject(rawResponse);
+      validation = validateAgainstTemplateSchema(
+        template.schema_json,
+        parsed
+      );
+    } catch (e) {
+      parseError = e instanceof Error ? e.message : String(e);
+    }
+  }
+  const status = parseError === null && validation && validation.ok ? "ready" : "failed";
+  const result_json = status === "ready" ? { content: parsed, product_truth: productTruth } : {
+    failure_reason: parseError ?? (validation && !validation.ok ? validation.errors.join("; ") : "unknown"),
+    raw: rawResponse.slice(0, 4e3)
+  };
+  const output = await storage.saveOutput({
+    signal_id: signal.id,
+    template_id: template.id,
+    status,
+    scope_kind: signal.scope_kind,
+    app_id: signal.scope_kind === "app" ? signal.app_id ?? null : null,
+    env: signal.scope_kind === "app" ? signal.env ?? null : null,
+    channel: resolved.channel,
+    audience_id: resolved.audience_id,
+    intent: resolved.intent,
+    format: resolved.format,
+    modality: resolved.modality,
+    result_json
+  });
+  return {
+    kind: "generated",
+    status: status === "ready" ? 201 : 200,
+    payload: {
+      output,
+      validation: validation ?? null,
+      failure_reason: status === "failed" ? result_json.failure_reason ?? null : null
+    }
+  };
+}
+
+// src/forge/widget.ts
+function getSlotValue(slots, template, slotId) {
+  const val = slots[slotId];
+  if (val !== void 0 && val !== null && val !== "") return String(val);
+  const def = template.slots.find((s) => s.id === slotId);
+  return def?.default !== void 0 ? String(def.default) : "";
+}
+
+// src/forge/widgetStyle.ts
+var BASE_SPACING = {
+  xs: "4px",
+  sm: "8px",
+  md: "16px",
+  lg: "24px",
+  xl: "40px"
+};
+var STYLE_PRESET_DEFAULT = {
+  id: "default",
+  name: "Default",
+  preset: true,
+  tokens: {
+    radius: { sm: "6px", md: "12px", lg: "20px", full: "9999px" },
+    shadow: {
+      sm: "0 1px 3px rgba(0,0,0,.12)",
+      md: "0 4px 16px rgba(0,0,0,.15)",
+      lg: "0 8px 32px rgba(0,0,0,.20)"
+    },
+    spacing: BASE_SPACING,
+    borderWidth: "1px",
+    borderStyle: "solid",
+    animation: { entry: "fade", durationMs: 300 }
+  },
+  version: 1,
+  versions: [],
+  created_at: "",
+  updated_at: ""
+};
+var STYLE_PRESET_MINIMAL = {
+  id: "minimal",
+  name: "Minimal",
+  preset: true,
+  tokens: {
+    radius: { sm: "0px", md: "0px", lg: "0px", full: "0px" },
+    shadow: { sm: "none", md: "none", lg: "none" },
+    spacing: BASE_SPACING,
+    borderWidth: "1px",
+    borderStyle: "solid",
+    animation: { entry: "none", durationMs: 0 }
+  },
+  version: 1,
+  versions: [],
+  created_at: "",
+  updated_at: ""
+};
+var STYLE_PRESET_GLASSY = {
+  id: "glassy",
+  name: "Glassy",
+  preset: true,
+  tokens: {
+    radius: { sm: "12px", md: "20px", lg: "28px", full: "9999px" },
+    shadow: {
+      sm: "0 2px 8px rgba(0,0,0,.08), inset 0 1px 0 rgba(255,255,255,.06)",
+      md: "0 8px 24px rgba(0,0,0,.12), inset 0 1px 0 rgba(255,255,255,.08)",
+      lg: "0 16px 48px rgba(0,0,0,.16), inset 0 1px 0 rgba(255,255,255,.10)"
+    },
+    spacing: BASE_SPACING,
+    borderWidth: "1px",
+    borderStyle: "solid",
+    animation: { entry: "scale", durationMs: 250 }
+  },
+  customCss: ".pw-widget{backdrop-filter:blur(16px);-webkit-backdrop-filter:blur(16px);}",
+  version: 1,
+  versions: [],
+  created_at: "",
+  updated_at: ""
+};
+var STYLE_PRESET_BRUTALIST = {
+  id: "brutalist",
+  name: "Brutalist",
+  preset: true,
+  tokens: {
+    radius: { sm: "0px", md: "0px", lg: "0px", full: "0px" },
+    shadow: {
+      sm: "2px 2px 0 currentColor",
+      md: "4px 4px 0 currentColor",
+      lg: "6px 6px 0 currentColor"
+    },
+    spacing: BASE_SPACING,
+    borderWidth: "2px",
+    borderStyle: "solid",
+    animation: { entry: "slide", durationMs: 200 }
+  },
+  version: 1,
+  versions: [],
+  created_at: "",
+  updated_at: ""
+};
+var BUNDLED_STYLE_PRESETS = [
+  STYLE_PRESET_DEFAULT,
+  STYLE_PRESET_MINIMAL,
+  STYLE_PRESET_GLASSY,
+  STYLE_PRESET_BRUTALIST
+];
+function getStyleById(id) {
+  return BUNDLED_STYLE_PRESETS.find((s) => s.id === id) ?? STYLE_PRESET_DEFAULT;
+}
+function safeStr2(v, fallback) {
+  return typeof v === "string" && v.trim() ? v.trim() : fallback;
+}
+function safeNum2(v, fallback) {
+  const n = Number(v);
+  return Number.isFinite(n) ? n : fallback;
+}
+function parseStyleFromTokensJson(json) {
+  if (!json || typeof json !== "object") return {};
+  const obj = json;
+  const get = (keys) => {
+    let cur = obj;
+    for (const k of keys) {
+      if (!cur || typeof cur !== "object") return void 0;
+      cur = cur[k];
+    }
+    return cur?.value ?? cur;
+  };
+  const radius = {};
+  const shadow = {};
+  const spacing = {};
+  const radiusSm = get(["borderRadius", "sm"]) ?? get(["radius", "sm"]) ?? get(["border-radius", "sm"]);
+  const radiusMd = get(["borderRadius", "md"]) ?? get(["radius", "md"]) ?? get(["border-radius", "md"]);
+  const radiusLg = get(["borderRadius", "lg"]) ?? get(["radius", "lg"]) ?? get(["border-radius", "lg"]);
+  if (radiusSm) radius.sm = safeStr2(radiusSm, "6px");
+  if (radiusMd) radius.md = safeStr2(radiusMd, "12px");
+  if (radiusLg) radius.lg = safeStr2(radiusLg, "20px");
+  const shadowSm = get(["boxShadow", "sm"]) ?? get(["shadow", "sm"]);
+  const shadowMd = get(["boxShadow", "md"]) ?? get(["shadow", "md"]) ?? get(["boxShadow", "DEFAULT"]);
+  const shadowLg = get(["boxShadow", "lg"]) ?? get(["shadow", "lg"]);
+  if (shadowSm) shadow.sm = safeStr2(shadowSm, STYLE_PRESET_DEFAULT.tokens.shadow.sm);
+  if (shadowMd) shadow.md = safeStr2(shadowMd, STYLE_PRESET_DEFAULT.tokens.shadow.md);
+  if (shadowLg) shadow.lg = safeStr2(shadowLg, STYLE_PRESET_DEFAULT.tokens.shadow.lg);
+  const spacingSm = get(["spacing", "sm"]) ?? get(["space", "sm"]);
+  const spacingMd = get(["spacing", "md"]) ?? get(["space", "md"]);
+  const spacingLg = get(["spacing", "lg"]) ?? get(["space", "lg"]);
+  if (spacingSm) spacing.sm = safeStr2(spacingSm, "8px");
+  if (spacingMd) spacing.md = safeStr2(spacingMd, "16px");
+  if (spacingLg) spacing.lg = safeStr2(spacingLg, "24px");
+  const animDuration = get(["animation", "duration"]) ?? get(["motion", "duration"]);
+  return {
+    ...Object.keys(radius).length ? { radius: { ...STYLE_PRESET_DEFAULT.tokens.radius, ...radius } } : {},
+    ...Object.keys(shadow).length ? { shadow: { ...STYLE_PRESET_DEFAULT.tokens.shadow, ...shadow } } : {},
+    ...Object.keys(spacing).length ? { spacing: { ...STYLE_PRESET_DEFAULT.tokens.spacing, ...spacing } } : {},
+    ...animDuration ? { animation: { ...STYLE_PRESET_DEFAULT.tokens.animation, durationMs: safeNum2(animDuration, 300) } } : {}
+  };
+}
+function parseStyleFromTailwindConfig(jsSource) {
+  const result = {};
+  const radiusMatch = {};
+  const radiusRx = /['"]?(?:sm|md|lg|DEFAULT)['"]?\s*:\s*['"]([^'"]+)['"]/g;
+  const radiusSection = /borderRadius\s*:\s*\{([^}]+)\}/.exec(jsSource)?.[1] ?? "";
+  let m;
+  while ((m = radiusRx.exec(radiusSection)) !== null) {
+    radiusMatch[m[0].split(":")[0].replace(/['"\s]/g, "")] = m[1];
+  }
+  if (radiusMatch.sm || radiusMatch.md || radiusMatch.lg) {
+    result.radius = {
+      sm: radiusMatch.sm ?? STYLE_PRESET_DEFAULT.tokens.radius.sm,
+      md: radiusMatch.md ?? radiusMatch.DEFAULT ?? STYLE_PRESET_DEFAULT.tokens.radius.md,
+      lg: radiusMatch.lg ?? STYLE_PRESET_DEFAULT.tokens.radius.lg,
+      full: STYLE_PRESET_DEFAULT.tokens.radius.full
+    };
+  }
+  const spacingSection = /spacing\s*:\s*\{([^}]+)\}/.exec(jsSource)?.[1] ?? "";
+  const spMap = {};
+  const spRx = /['"]?(\d+|sm|md|lg|xs|xl)['"]?\s*:\s*['"]([^'"]+)['"]/g;
+  while ((m = spRx.exec(spacingSection)) !== null) {
+    spMap[m[1]] = m[2];
+  }
+  if (Object.keys(spMap).length) {
+    result.spacing = {
+      xs: spMap.xs ?? spMap["1"] ?? STYLE_PRESET_DEFAULT.tokens.spacing.xs,
+      sm: spMap.sm ?? spMap["2"] ?? STYLE_PRESET_DEFAULT.tokens.spacing.sm,
+      md: spMap.md ?? spMap["4"] ?? STYLE_PRESET_DEFAULT.tokens.spacing.md,
+      lg: spMap.lg ?? spMap["6"] ?? STYLE_PRESET_DEFAULT.tokens.spacing.lg,
+      xl: spMap.xl ?? spMap["10"] ?? STYLE_PRESET_DEFAULT.tokens.spacing.xl
+    };
+  }
+  return result;
+}
+function parseStyleFromCss(css) {
+  const tokens = {};
+  const radiusSm = /--radius-sm\s*:\s*([^;]+)/.exec(css)?.[1]?.trim();
+  const radiusMd = /--radius(?:-md)?\s*:\s*([^;]+)/.exec(css)?.[1]?.trim();
+  const radiusLg = /--radius-lg\s*:\s*([^;]+)/.exec(css)?.[1]?.trim();
+  if (radiusSm || radiusMd || radiusLg) {
+    tokens.radius = {
+      sm: radiusSm ?? STYLE_PRESET_DEFAULT.tokens.radius.sm,
+      md: radiusMd ?? STYLE_PRESET_DEFAULT.tokens.radius.md,
+      lg: radiusLg ?? STYLE_PRESET_DEFAULT.tokens.radius.lg,
+      full: STYLE_PRESET_DEFAULT.tokens.radius.full
+    };
+  }
+  const shadowMd = /--shadow(?:-md)?\s*:\s*([^;]+)/.exec(css)?.[1]?.trim();
+  if (shadowMd) {
+    tokens.shadow = { ...STYLE_PRESET_DEFAULT.tokens.shadow, md: shadowMd };
+  }
+  return { tokens, customCss: css };
+}
+
+// src/forge/widgetTemplates.ts
+var WIDGET_TEMPLATE_STAT_CARD = {
+  id: "stat-card",
+  name: "Stat Card",
+  description: "Big number with label and optional delta arrow.",
+  free_tier: true,
+  exportFormats: ["html", "markdown", "react"],
+  slots: [
+    { id: "value", label: "Value", type: "text", required: true, placeholder: "138", default: "138" },
+    { id: "label", label: "Label", type: "text", required: true, placeholder: "Total Files", default: "Total Files" },
+    { id: "delta", label: "Delta", type: "text", placeholder: "+12%", default: "" },
+    { id: "delta_direction", label: "Delta direction", type: "select", options: ["up", "down", "neutral"], default: "up" },
+    { id: "unit", label: "Unit (optional)", type: "text", placeholder: "files", default: "" }
+  ]
+};
+var WIDGET_TEMPLATE_FEATURE_GRID = {
+  id: "feature-grid",
+  name: "Feature Grid",
+  description: "Grid of features with icons or checkmarks.",
+  free_tier: false,
+  exportFormats: ["html", "markdown", "react"],
+  slots: [
+    { id: "title", label: "Title", type: "text", placeholder: "What you get", default: "What you get" },
+    { id: "features", label: "Features (one per line)", type: "multiline", required: true, placeholder: "Zero config\nInstant deploy\nGlobal CDN", default: "Feature one\nFeature two\nFeature three" },
+    { id: "columns", label: "Columns", type: "select", options: ["2", "3"], default: "3" },
+    { id: "icon", label: "Icon prefix", type: "text", placeholder: "\u2713", default: "\u2713" }
+  ]
+};
+var WIDGET_TEMPLATE_TESTIMONIAL = {
+  id: "testimonial",
+  name: "Testimonial",
+  description: "Pull-quote with author, role, and optional photo.",
+  free_tier: false,
+  exportFormats: ["html", "markdown", "react"],
+  slots: [
+    { id: "quote", label: "Quote", type: "multiline", required: true, placeholder: "This tool changed how we ship.", default: "This tool changed how we ship." },
+    { id: "author", label: "Author name", type: "text", required: true, placeholder: "Jane Smith", default: "Jane Smith" },
+    { id: "role", label: "Role", type: "text", placeholder: "CTO", default: "CTO" },
+    { id: "company", label: "Company", type: "text", placeholder: "Acme Corp", default: "Acme Corp" },
+    { id: "image_url", label: "Author photo URL", type: "image-url", placeholder: "https://\u2026", default: "" }
+  ]
+};
+var WIDGET_TEMPLATE_CTA_BANNER = {
+  id: "cta-banner",
+  name: "CTA Banner",
+  description: "Full-width call-to-action with heading, subtitle, and button.",
+  free_tier: true,
+  exportFormats: ["html", "markdown", "react"],
+  slots: [
+    { id: "heading", label: "Heading", type: "text", required: true, placeholder: "Ship faster.", default: "Ship faster." },
+    { id: "subtitle", label: "Subtitle", type: "text", placeholder: "From blueprint to production in minutes.", default: "From blueprint to production in minutes." },
+    { id: "button_text", label: "Button text", type: "text", required: true, placeholder: "Get started", default: "Get started" },
+    { id: "button_url", label: "Button URL", type: "url", placeholder: "https://\u2026", default: "#" },
+    { id: "align", label: "Alignment", type: "select", options: ["left", "center"], default: "center" }
+  ]
+};
+var WIDGET_TEMPLATE_METRIC_BADGE = {
+  id: "metric-badge",
+  name: "Metric Badge",
+  description: "Small inline metric chip \u2014 uptime, users, coverage.",
+  free_tier: true,
+  exportFormats: ["html", "markdown", "react"],
+  slots: [
+    { id: "metric_name", label: "Metric name", type: "text", required: true, placeholder: "Uptime", default: "Uptime" },
+    { id: "value", label: "Value", type: "text", required: true, placeholder: "99.9", default: "99.9" },
+    { id: "unit", label: "Unit", type: "text", placeholder: "%", default: "%" },
+    { id: "color", label: "Color override", type: "color", default: "" }
+  ]
+};
+var WIDGET_TEMPLATE_PRICING_TIER = {
+  id: "pricing-tier",
+  name: "Pricing Tier",
+  description: "Plan name, price, feature bullets, and CTA button.",
+  free_tier: false,
+  exportFormats: ["html", "markdown", "react"],
+  slots: [
+    { id: "plan_name", label: "Plan name", type: "text", required: true, placeholder: "Pro", default: "Pro" },
+    { id: "price", label: "Price", type: "text", required: true, placeholder: "\u20AC49", default: "\u20AC49" },
+    { id: "period", label: "Period", type: "text", placeholder: "/month", default: "/month" },
+    { id: "features", label: "Features (one per line)", type: "multiline", required: true, placeholder: "Unlimited projects\nPriority support\nAPI access", default: "Feature one\nFeature two\nFeature three" },
+    { id: "cta_text", label: "CTA text", type: "text", placeholder: "Get Pro", default: "Get Pro" },
+    { id: "cta_url", label: "CTA URL", type: "url", placeholder: "https://\u2026", default: "#" },
+    { id: "highlighted", label: "Highlighted tier", type: "select", options: ["yes", "no"], default: "no" }
+  ]
+};
+var WIDGET_TEMPLATE_CHANGELOG_ROW = {
+  id: "changelog-row",
+  name: "Changelog Row",
+  description: "Version, date, and bullet list of changes.",
+  free_tier: false,
+  exportFormats: ["html", "markdown", "react"],
+  slots: [
+    { id: "version", label: "Version", type: "text", required: true, placeholder: "v1.2.0", default: "v1.2.0" },
+    { id: "date", label: "Date", type: "text", required: true, placeholder: "2024-01-15", default: "2024-01-15" },
+    { id: "label", label: "Release label", type: "select", options: ["feat", "fix", "docs", "chore", ""], default: "feat" },
+    { id: "changes", label: "Changes (one per line)", type: "multiline", required: true, placeholder: "Added dark mode\nFixed auth bug\nImproved performance", default: "Added feature X\nFixed bug Y\nImproved performance" }
+  ]
+};
+var WIDGET_TEMPLATE_SOCIAL_PROOF = {
+  id: "social-proof",
+  name: "Social Proof",
+  description: "Logo row with optional caption.",
+  free_tier: false,
+  exportFormats: ["html", "markdown", "react"],
+  slots: [
+    { id: "caption", label: "Caption", type: "text", placeholder: "Trusted by engineering teams at", default: "Trusted by engineering teams at" },
+    { id: "logos", label: "Brand names (one per line)", type: "multiline", required: true, placeholder: "Vercel\nStripe\nLinear\nResend", default: "Acme Corp\nBeta Inc\nGamma Ltd" },
+    { id: "show_divider", label: "Show divider", type: "select", options: ["yes", "no"], default: "no" }
+  ]
+};
+var BUNDLED_WIDGET_TEMPLATES = [
+  WIDGET_TEMPLATE_STAT_CARD,
+  WIDGET_TEMPLATE_FEATURE_GRID,
+  WIDGET_TEMPLATE_TESTIMONIAL,
+  WIDGET_TEMPLATE_CTA_BANNER,
+  WIDGET_TEMPLATE_METRIC_BADGE,
+  WIDGET_TEMPLATE_PRICING_TIER,
+  WIDGET_TEMPLATE_CHANGELOG_ROW,
+  WIDGET_TEMPLATE_SOCIAL_PROOF
+];
+var FREE_TIER_WIDGET_IDS = BUNDLED_WIDGET_TEMPLATES.filter((t) => t.free_tier).map((t) => t.id);
+function getWidgetTemplate(id) {
+  return BUNDLED_WIDGET_TEMPLATES.find((t) => t.id === id);
+}
+
+// src/forge/widgetRenderer.ts
+function brandVars(brand) {
+  const p = brand?.palette;
+  const f = brand?.fonts;
+  return {
+    "--pw-brand-primary": p?.primary ?? "#f97316",
+    "--pw-brand-secondary": p?.secondary ?? "#1e293b",
+    "--pw-brand-accent": p?.accent ?? "#fb923c",
+    "--pw-brand-surface": p?.surface ?? "#0f172a",
+    "--pw-brand-text": p?.text ?? "#f1f5f9",
+    "--pw-brand-muted": p?.muted ?? "#64748b",
+    "--pw-font-heading": f?.heading ? `'${f.heading}',sans-serif` : "sans-serif",
+    "--pw-font-body": f?.body ? `'${f.body}',sans-serif` : "sans-serif",
+    "--pw-font-mono": f?.mono ? `'${f.mono}',monospace` : "monospace"
+  };
+}
+function styleVars(style) {
+  const t = style.tokens;
+  return {
+    "--pw-radius-sm": t.radius.sm,
+    "--pw-radius-md": t.radius.md,
+    "--pw-radius-lg": t.radius.lg,
+    "--pw-radius-full": t.radius.full,
+    "--pw-shadow-sm": t.shadow.sm,
+    "--pw-shadow-md": t.shadow.md,
+    "--pw-shadow-lg": t.shadow.lg,
+    "--pw-spacing-xs": t.spacing.xs,
+    "--pw-spacing-sm": t.spacing.sm,
+    "--pw-spacing-md": t.spacing.md,
+    "--pw-spacing-lg": t.spacing.lg,
+    "--pw-spacing-xl": t.spacing.xl,
+    "--pw-border-width": t.borderWidth
+  };
+}
+function buildCssVarString(vars) {
+  return Object.entries(vars).map(([k, v]) => `${k}:${v}`).join(";");
+}
+function buildInlineStyle(vars) {
+  return buildCssVarString(vars);
+}
+function escHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function baseWidgetStyle() {
+  return `.pw-widget{font-family:var(--pw-font-body);color:var(--pw-brand-text);background:var(--pw-brand-surface);border-radius:var(--pw-radius-md);padding:var(--pw-spacing-md);border:var(--pw-border-width) solid rgba(255,255,255,.08);box-sizing:border-box;}`;
+}
+function renderStatCardHtml(slots, t) {
+  const value = getSlotValue(slots, t, "value");
+  const label = getSlotValue(slots, t, "label");
+  const delta = getSlotValue(slots, t, "delta");
+  const dir = getSlotValue(slots, t, "delta_direction");
+  const unit = getSlotValue(slots, t, "unit");
+  const arrow = dir === "up" ? "\u2191" : dir === "down" ? "\u2193" : "\u2192";
+  const deltaColor = dir === "up" ? "#22c55e" : dir === "down" ? "#ef4444" : "inherit";
+  return `<div class="pw-stat-value" style="font-size:2.5rem;font-weight:700;line-height:1;font-family:var(--pw-font-heading);color:var(--pw-brand-primary)">${escHtml(value)}${unit ? `<span style="font-size:1rem;font-weight:400;margin-left:4px">${escHtml(unit)}</span>` : ""}</div>
+<div class="pw-stat-label" style="font-size:.875rem;color:var(--pw-brand-muted);margin-top:var(--pw-spacing-xs)">${escHtml(label)}</div>
+${delta ? `<div class="pw-stat-delta" style="font-size:.75rem;color:${deltaColor};margin-top:var(--pw-spacing-xs)">${arrow} ${escHtml(delta)}</div>` : ""}`;
+}
+function renderFeatureGridHtml(slots, t) {
+  const title = getSlotValue(slots, t, "title");
+  const features = getSlotValue(slots, t, "features").split("\n").filter(Boolean);
+  const cols = getSlotValue(slots, t, "columns") || "3";
+  const icon = getSlotValue(slots, t, "icon") || "\u2713";
+  return `${title ? `<h3 style="font-size:1.125rem;font-weight:600;margin:0 0 var(--pw-spacing-md);font-family:var(--pw-font-heading);color:var(--pw-brand-text)">${escHtml(title)}</h3>` : ""}
+<div class="pw-grid" style="display:grid;grid-template-columns:repeat(${escHtml(cols)},1fr);gap:var(--pw-spacing-sm)">
+${features.map((f) => `  <div style="display:flex;align-items:flex-start;gap:var(--pw-spacing-xs);font-size:.875rem"><span style="color:var(--pw-brand-accent);flex-shrink:0">${escHtml(icon)}</span><span>${escHtml(f)}</span></div>`).join("\n")}
+</div>`;
+}
+function renderTestimonialHtml(slots, t) {
+  const quote = getSlotValue(slots, t, "quote");
+  const author = getSlotValue(slots, t, "author");
+  const role = getSlotValue(slots, t, "role");
+  const company = getSlotValue(slots, t, "company");
+  const img = getSlotValue(slots, t, "image_url");
+  return `<blockquote style="margin:0;font-size:1.125rem;line-height:1.6;font-style:italic;color:var(--pw-brand-text)">"${escHtml(quote)}"</blockquote>
+<div class="pw-attribution" style="display:flex;align-items:center;gap:var(--pw-spacing-sm);margin-top:var(--pw-spacing-md)">
+${img ? `  <img src="${escHtml(img)}" alt="${escHtml(author)}" style="width:40px;height:40px;border-radius:var(--pw-radius-full);object-fit:cover" />` : ""}
+  <div>
+    <div style="font-weight:600;font-size:.875rem">${escHtml(author)}</div>
+    ${role || company ? `<div style="font-size:.75rem;color:var(--pw-brand-muted)">${[role, company].filter(Boolean).map(escHtml).join(", ")}</div>` : ""}
+  </div>
+</div>`;
+}
+function renderCtaBannerHtml(slots, t) {
+  const heading = getSlotValue(slots, t, "heading");
+  const subtitle = getSlotValue(slots, t, "subtitle");
+  const btnText = getSlotValue(slots, t, "button_text");
+  const btnUrl = getSlotValue(slots, t, "button_url") || "#";
+  const align = getSlotValue(slots, t, "align") || "center";
+  return `<div style="text-align:${escHtml(align)}">
+<h2 style="margin:0 0 var(--pw-spacing-sm);font-size:1.75rem;font-weight:700;font-family:var(--pw-font-heading);line-height:1.2">${escHtml(heading)}</h2>
+${subtitle ? `<p style="margin:0 0 var(--pw-spacing-md);font-size:1rem;color:var(--pw-brand-muted)">${escHtml(subtitle)}</p>` : ""}
+<a href="${escHtml(btnUrl)}" style="display:inline-block;padding:var(--pw-spacing-sm) var(--pw-spacing-lg);background:var(--pw-brand-primary);color:#fff;border-radius:var(--pw-radius-sm);font-weight:600;text-decoration:none;font-size:.875rem">${escHtml(btnText)}</a>
+</div>`;
+}
+function renderMetricBadgeHtml(slots, t) {
+  const name = getSlotValue(slots, t, "metric_name");
+  const value = getSlotValue(slots, t, "value");
+  const unit = getSlotValue(slots, t, "unit");
+  const color = getSlotValue(slots, t, "color") || "var(--pw-brand-accent)";
+  return `<span style="display:inline-flex;align-items:center;gap:var(--pw-spacing-xs);padding:2px var(--pw-spacing-sm);border-radius:var(--pw-radius-full);border:var(--pw-border-width) solid ${escHtml(color)}20;background:${escHtml(color)}10">
+  <span style="font-size:.75rem;color:var(--pw-brand-muted)">${escHtml(name)}</span>
+  <span style="font-size:.875rem;font-weight:700;color:${escHtml(color)};font-family:var(--pw-font-mono)">${escHtml(value)}${unit ? `<span style="font-size:.7rem;font-weight:400">${escHtml(unit)}</span>` : ""}</span>
+</span>`;
+}
+function renderPricingTierHtml(slots, t) {
+  const plan = getSlotValue(slots, t, "plan_name");
+  const price = getSlotValue(slots, t, "price");
+  const period = getSlotValue(slots, t, "period");
+  const features = getSlotValue(slots, t, "features").split("\n").filter(Boolean);
+  const cta = getSlotValue(slots, t, "cta_text");
+  const ctaUrl = getSlotValue(slots, t, "cta_url") || "#";
+  const highlighted = getSlotValue(slots, t, "highlighted") === "yes";
+  const borderColor = highlighted ? "var(--pw-brand-primary)" : "rgba(255,255,255,.08)";
+  return `<div style="border-color:${borderColor};border-width:${highlighted ? "2px" : "var(--pw-border-width)"}">
+<div style="font-size:.75rem;font-weight:600;text-transform:uppercase;letter-spacing:.08em;color:var(--pw-brand-muted);margin-bottom:var(--pw-spacing-xs)">${escHtml(plan)}</div>
+<div style="display:flex;align-items:baseline;gap:2px;margin-bottom:var(--pw-spacing-md)">
+  <span style="font-size:2rem;font-weight:700;font-family:var(--pw-font-heading)">${escHtml(price)}</span>
+  <span style="font-size:.875rem;color:var(--pw-brand-muted)">${escHtml(period)}</span>
+</div>
+<ul style="margin:0 0 var(--pw-spacing-md);padding:0;list-style:none;space-y:var(--pw-spacing-xs)">
+${features.map((f) => `  <li style="display:flex;align-items:flex-start;gap:var(--pw-spacing-xs);font-size:.875rem;padding:var(--pw-spacing-xs) 0"><span style="color:var(--pw-brand-accent);flex-shrink:0">\u2713</span><span>${escHtml(f)}</span></li>`).join("\n")}
+</ul>
+<a href="${escHtml(ctaUrl)}" style="display:block;text-align:center;padding:var(--pw-spacing-sm);background:${highlighted ? "var(--pw-brand-primary)" : "transparent"};color:${highlighted ? "#fff" : "var(--pw-brand-primary)"};border-radius:var(--pw-radius-sm);font-weight:600;text-decoration:none;font-size:.875rem;border:1px solid var(--pw-brand-primary)">${escHtml(cta)}</a>
+</div>`;
+}
+function renderChangelogRowHtml(slots, t) {
+  const version = getSlotValue(slots, t, "version");
+  const date = getSlotValue(slots, t, "date");
+  const label = getSlotValue(slots, t, "label");
+  const changes = getSlotValue(slots, t, "changes").split("\n").filter(Boolean);
+  const labelColor = { feat: "#22c55e", fix: "#f59e0b", docs: "#60a5fa", chore: "#94a3b8" };
+  const lc = labelColor[label] ?? "var(--pw-brand-muted)";
+  return `<div style="display:flex;align-items:baseline;gap:var(--pw-spacing-sm);margin-bottom:var(--pw-spacing-sm);flex-wrap:wrap">
+  <span style="font-family:var(--pw-font-mono);font-size:.875rem;font-weight:600;color:var(--pw-brand-primary)">${escHtml(version)}</span>
+  ${label ? `<span style="font-size:.7rem;padding:1px 6px;border-radius:var(--pw-radius-full);background:${lc}20;color:${lc};font-weight:600">${escHtml(label)}</span>` : ""}
+  <span style="font-size:.75rem;color:var(--pw-brand-muted);font-family:var(--pw-font-mono)">${escHtml(date)}</span>
+</div>
+<ul style="margin:0;padding:0 0 0 var(--pw-spacing-md);list-style:disc;color:var(--pw-brand-muted)">
+${changes.map((c) => `  <li style="font-size:.875rem;line-height:1.5">${escHtml(c)}</li>`).join("\n")}
+</ul>`;
+}
+function renderSocialProofHtml(slots, t) {
+  const caption = getSlotValue(slots, t, "caption");
+  const logos = getSlotValue(slots, t, "logos").split("\n").filter(Boolean);
+  const divider = getSlotValue(slots, t, "show_divider") === "yes";
+  return `${caption ? `<p style="text-align:center;font-size:.75rem;text-transform:uppercase;letter-spacing:.08em;color:var(--pw-brand-muted);margin:0 0 var(--pw-spacing-md)">${escHtml(caption)}</p>` : ""}
+${divider ? `<hr style="border:none;border-top:1px solid rgba(255,255,255,.08);margin:var(--pw-spacing-sm) 0" />` : ""}
+<div style="display:flex;flex-wrap:wrap;align-items:center;justify-content:center;gap:var(--pw-spacing-lg)">
+${logos.map((l) => `  <span style="font-weight:600;font-size:.875rem;color:var(--pw-brand-muted);letter-spacing:-.01em">${escHtml(l)}</span>`).join("\n")}
+</div>`;
+}
+var HTML_BODY_FN = {
+  "stat-card": renderStatCardHtml,
+  "feature-grid": renderFeatureGridHtml,
+  "testimonial": renderTestimonialHtml,
+  "cta-banner": renderCtaBannerHtml,
+  "metric-badge": renderMetricBadgeHtml,
+  "pricing-tier": renderPricingTierHtml,
+  "changelog-row": renderChangelogRowHtml,
+  "social-proof": renderSocialProofHtml
+};
+function renderStatCardMd(slots, t) {
+  const value = getSlotValue(slots, t, "value");
+  const label = getSlotValue(slots, t, "label");
+  const delta = getSlotValue(slots, t, "delta");
+  const dir = getSlotValue(slots, t, "delta_direction");
+  const unit = getSlotValue(slots, t, "unit");
+  const arrow = dir === "up" ? "\u2191" : dir === "down" ? "\u2193" : "";
+  return `**${value}${unit ? " " + unit : ""}** \u2014 ${label}${delta ? ` ${arrow} ${delta}` : ""}`;
+}
+function renderFeatureGridMd(slots, t) {
+  const title = getSlotValue(slots, t, "title");
+  const features = getSlotValue(slots, t, "features").split("\n").filter(Boolean);
+  const icon = getSlotValue(slots, t, "icon") || "\u2713";
+  return `${title ? `## ${title}
+
+` : ""}${features.map((f) => `- ${icon} ${f}`).join("\n")}`;
+}
+function renderTestimonialMd(slots, t) {
+  const quote = getSlotValue(slots, t, "quote");
+  const author = getSlotValue(slots, t, "author");
+  const role = getSlotValue(slots, t, "role");
+  const company = getSlotValue(slots, t, "company");
+  const attribution = [author, role, company].filter(Boolean).join(", ");
+  return `> "${quote}"
+>
+> \u2014 ${attribution}`;
+}
+function renderCtaBannerMd(slots, t) {
+  const heading = getSlotValue(slots, t, "heading");
+  const subtitle = getSlotValue(slots, t, "subtitle");
+  const btnText = getSlotValue(slots, t, "button_text");
+  const btnUrl = getSlotValue(slots, t, "button_url") || "#";
+  return `## ${heading}
+
+${subtitle ? subtitle + "\n\n" : ""}[${btnText}](${btnUrl})`;
+}
+function renderMetricBadgeMd(slots, t) {
+  const name = getSlotValue(slots, t, "metric_name");
+  const value = getSlotValue(slots, t, "value");
+  const unit = getSlotValue(slots, t, "unit");
+  return `**${name}**: \`${value}${unit}\``;
+}
+function renderPricingTierMd(slots, t) {
+  const plan = getSlotValue(slots, t, "plan_name");
+  const price = getSlotValue(slots, t, "price");
+  const period = getSlotValue(slots, t, "period");
+  const features = getSlotValue(slots, t, "features").split("\n").filter(Boolean);
+  const cta = getSlotValue(slots, t, "cta_text");
+  const ctaUrl = getSlotValue(slots, t, "cta_url") || "#";
+  return `### ${plan} \u2014 ${price}${period}
+
+${features.map((f) => `- \u2713 ${f}`).join("\n")}
+
+[${cta}](${ctaUrl})`;
+}
+function renderChangelogRowMd(slots, t) {
+  const version = getSlotValue(slots, t, "version");
+  const date = getSlotValue(slots, t, "date");
+  const label = getSlotValue(slots, t, "label");
+  const changes = getSlotValue(slots, t, "changes").split("\n").filter(Boolean);
+  return `### ${version}${label ? ` \`${label}\`` : ""} \u2014 ${date}
+
+${changes.map((c) => `- ${c}`).join("\n")}`;
+}
+function renderSocialProofMd(slots, t) {
+  const caption = getSlotValue(slots, t, "caption");
+  const logos = getSlotValue(slots, t, "logos").split("\n").filter(Boolean);
+  return `${caption ? caption + "\n\n" : ""}${logos.join(" \xB7 ")}`;
+}
+var MD_FN = {
+  "stat-card": renderStatCardMd,
+  "feature-grid": renderFeatureGridMd,
+  "testimonial": renderTestimonialMd,
+  "cta-banner": renderCtaBannerMd,
+  "metric-badge": renderMetricBadgeMd,
+  "pricing-tier": renderPricingTierMd,
+  "changelog-row": renderChangelogRowMd,
+  "social-proof": renderSocialProofMd
+};
+function toReactStyle(vars) {
+  return "{\n" + Object.entries(vars).map(([k, v]) => `    "${k}": "${v.replace(/"/g, '\\"')}"`).join(",\n") + "\n  }";
+}
+function renderReact(template, slots, brand, style) {
+  const allVars = { ...brandVars(brand), ...styleVars(style) };
+  const componentName = template.id.split("-").map((p) => p[0].toUpperCase() + p.slice(1)).join("");
+  const slotDecls = template.slots.map((s) => {
+    const val = getSlotValue(slots, template, s.id);
+    if (s.type === "number") return `  const ${s.id.replace(/-/g, "_")} = ${Number(val) || 0};`;
+    return `  const ${s.id.replace(/-/g, "_")} = ${JSON.stringify(val)};`;
+  }).join("\n");
+  const htmlBody = (HTML_BODY_FN[template.id]?.(slots, template) ?? "").replace(/`/g, "\\`");
+  return `// forge0x2B \u2014 ${template.name} widget
+// Generated by forgesmith widget renderer
+
+const styleVars = ${toReactStyle(allVars)};
+
+export default function ${componentName}() {
+${slotDecls}
+
+  return (
+    <div
+      className="pw-widget pw-${template.id}"
+      style={styleVars}
+      dangerouslySetInnerHTML={{ __html: \`${htmlBody}\` }}
+    />
+  );
+}
+`;
+}
+function renderWidget(input) {
+  const { template, slots, brandKit, format } = input;
+  const style = !input.style ? STYLE_PRESET_DEFAULT : typeof input.style === "string" ? getStyleById(input.style) : input.style;
+  if (format === "markdown") {
+    const fn = MD_FN[template.id];
+    return fn ? fn(slots, template) : `<!-- ${template.name} -->`;
+  }
+  if (format === "react") {
+    return renderReact(template, slots, brandKit ?? null, style);
+  }
+  const bodyFn = HTML_BODY_FN[template.id];
+  const body = bodyFn ? bodyFn(slots, template) : "";
+  const allVars = { ...brandVars(brandKit ?? null), ...styleVars(style) };
+  const inlineStyle = buildInlineStyle(allVars);
+  const customCss = style.customCss ?? "";
+  const override = style.templateOverrides?.[template.id]?.html;
+  const finalBody = override ?? body;
+  return `<div class="pw-widget pw-${template.id}" style="${inlineStyle}">
+  <style>.pw-widget{${baseWidgetStyle().replace(/^\.pw-widget\{/, "").replace(/\}$/, "")}${customCss ? " " + customCss : ""}</style>
+  ${finalBody}
+</div>`;
+}
+
+// src/forge/fixtures/audiences.ts
+var FORGE_AUDIENCES = [
+  {
+    id: asAudienceId("heise_technical_editorial"),
+    label: "Heise \u2014 Technische Redaktion",
+    tonality: "sachlich-tief",
+    reading_level: "expert",
+    channel_hints: ["heise"],
+    description: "Fachredaktion mit tiefem technischem Hintergrund; erwartet Belege, Architekturbezug und keine Marketingsprache."
+  },
+  {
+    id: asAudienceId("connect_consumer_tech"),
+    label: "Connect \u2014 Consumer Tech",
+    tonality: "sachlich-zug\xE4nglich",
+    reading_level: "professional",
+    channel_hints: ["connect"],
+    description: "Consumer-Tech-Redaktion mit Fokus auf Alltagstauglichkeit und Vergleichbarkeit gegen\xFCber Marktalternativen."
+  },
+  {
+    id: asAudienceId("investor_seed"),
+    label: "Investor \u2014 Seed",
+    tonality: "ambitioniert-glaubw\xFCrdig",
+    reading_level: "professional",
+    channel_hints: ["internal", "deck", "email"],
+    description: "Seed-Stage Investor; erwartet These, Marktverst\xE4ndnis und glaubw\xFCrdige Traktion in wenigen Abs\xE4tzen."
+  },
+  {
+    id: asAudienceId("investor_growth"),
+    label: "Investor \u2014 Growth",
+    tonality: "n\xFCchtern-direkt",
+    reading_level: "professional",
+    channel_hints: ["internal", "deck", "email"],
+    description: "Growth-Stage Investor; erwartet Kennzahlen, Defensibility und operative Hebel."
+  },
+  {
+    id: asAudienceId("founder_peer"),
+    label: "Founder Peer",
+    tonality: "sachlich-zug\xE4nglich",
+    reading_level: "professional",
+    channel_hints: ["linkedin", "internal"],
+    description: "Gr\xFCnderkollege auf vergleichbarem Reifegrad; Austausch ohne Pitch-Ton."
+  },
+  {
+    id: asAudienceId("b2b_buyer"),
+    label: "B2B Buyer",
+    tonality: "n\xFCchtern-direkt",
+    reading_level: "professional",
+    channel_hints: ["landing", "onepager", "email"],
+    description: "Entscheider in einem Zielunternehmen; bewertet Nutzen, Integration und Risiko."
+  },
+  {
+    id: asAudienceId("end_customer_friendly"),
+    label: "Endkunde \u2014 freundlich",
+    tonality: "warm-zug\xE4nglich",
+    reading_level: "general",
+    channel_hints: ["landing", "instagram", "email"],
+    description: "Endnutzerin oder Endnutzer ohne Vorwissen; sucht direkten Nutzen und Vertrauen."
+  },
+  {
+    id: asAudienceId("partner_business"),
+    label: "Gesch\xE4ftspartner",
+    tonality: "sachlich-zug\xE4nglich",
+    reading_level: "professional",
+    channel_hints: ["email", "onepager", "deck"],
+    description: "Vertriebs- oder Integrationspartner; bewertet Mehrwert f\xFCr die eigene Wertsch\xF6pfung."
+  },
+  {
+    id: asAudienceId("linkedin_founder_post"),
+    label: "LinkedIn \u2014 Founder Post",
+    tonality: "ambitioniert-glaubw\xFCrdig",
+    reading_level: "professional",
+    channel_hints: ["linkedin"],
+    description: "LinkedIn-Publikum eines Gr\xFCnderprofils; erwartet pers\xF6nlichen Ton mit Substanz."
+  },
+  {
+    id: asAudienceId("linkedin_product_post"),
+    label: "LinkedIn \u2014 Product Post",
+    tonality: "sachlich-zug\xE4nglich",
+    reading_level: "professional",
+    channel_hints: ["linkedin"],
+    description: "LinkedIn-Publikum eines Produktprofils; Fokus auf Funktionalit\xE4t und Anwendungsfall."
+  },
+  {
+    id: asAudienceId("instagram_carousel_general"),
+    label: "Instagram \u2014 Carousel allgemein",
+    tonality: "warm-zug\xE4nglich",
+    reading_level: "general",
+    channel_hints: ["instagram"],
+    description: "Allgemeines Instagram-Publikum; visuelle Logik, kurze Hooks, freundlicher Ton."
+  },
+  {
+    id: asAudienceId("friend_explainer"),
+    label: "Freund \u2014 Erkl\xE4rung",
+    tonality: "warm-zug\xE4nglich",
+    reading_level: "lay",
+    channel_hints: ["internal", "email"],
+    description: "Eine fachfremde, nahestehende Person; sucht Verst\xE4ndnis ohne Fachbegriffe."
+  }
+];
+
+// src/forge/fixtures/templates.ts
+var FORGE_TEMPLATES = [
+  {
+    id: "heise_long_article",
+    channel: "heise",
+    audience_id: asAudienceId("heise_technical_editorial"),
+    intent: "inform",
+    format: "long_article",
+    modality: "text",
+    tonality: "sachlich-tief",
+    schema_json: {
+      sections: ["lede", "context", "architecture", "evidence", "outlook"]
+    },
+    asset_slots: []
+  },
+  {
+    id: "founder_seed_pitch",
+    channel: "internal",
+    audience_id: asAudienceId("investor_seed"),
+    intent: "pitch",
+    format: "pitch_paragraphs",
+    modality: "text",
+    tonality: "ambitioniert-glaubw\xFCrdig",
+    schema_json: { sections: ["thesis", "market", "wedge", "traction", "ask"] },
+    asset_slots: []
+  },
+  {
+    id: "linkedin_founder_post",
+    channel: "linkedin",
+    audience_id: asAudienceId("linkedin_founder_post"),
+    intent: "announce",
+    format: "short_post",
+    modality: "text_with_visual_brief",
+    tonality: "ambitioniert-glaubw\xFCrdig",
+    schema_json: { sections: ["hook", "body", "cta"] },
+    asset_slots: [{ kind: "image_brief", required: true }]
+  },
+  {
+    id: "linkedin_product_carousel",
+    channel: "linkedin",
+    audience_id: asAudienceId("linkedin_product_post"),
+    intent: "educate",
+    format: "carousel_sequence",
+    modality: "text_with_visual_brief",
+    tonality: "sachlich-zug\xE4nglich",
+    schema_json: { slides: { min: 5, max: 8 } },
+    asset_slots: [{ kind: "image_brief", required: true, per: "slide" }]
+  },
+  {
+    id: "instagram_carousel_general",
+    channel: "instagram",
+    audience_id: asAudienceId("instagram_carousel_general"),
+    intent: "celebrate_release",
+    format: "carousel_sequence",
+    modality: "text_with_visual_brief",
+    tonality: "warm-zug\xE4nglich",
+    schema_json: { slides: { min: 4, max: 7 } },
+    asset_slots: [{ kind: "image_brief", required: true, per: "slide" }]
+  },
+  {
+    id: "landing_section",
+    channel: "landing",
+    audience_id: asAudienceId("b2b_buyer"),
+    intent: "convince",
+    format: "landing_block",
+    modality: "text",
+    tonality: "n\xFCchtern-direkt",
+    schema_json: { sections: ["headline", "subhead", "bullets", "cta"] },
+    asset_slots: []
+  },
+  {
+    id: "friend_explainer_short",
+    channel: "internal",
+    audience_id: asAudienceId("friend_explainer"),
+    intent: "explain_to_layperson",
+    format: "short_post",
+    modality: "text",
+    tonality: "warm-zug\xE4nglich",
+    schema_json: {
+      sections: ["analogy", "what_it_does", "why_it_matters"]
+    },
+    asset_slots: []
+  },
+  {
+    id: "connect_consumer_review",
+    channel: "connect",
+    audience_id: asAudienceId("connect_consumer_tech"),
+    intent: "inform",
+    format: "long_article",
+    modality: "text",
+    tonality: "sachlich-zug\xE4nglich",
+    schema_json: {
+      sections: ["intro", "everyday_use", "comparison", "verdict"]
+    },
+    asset_slots: []
+  }
+];
+
+// src/forge/secrets.ts
+var SECRET_PATTERNS = [
+  /sk-ant-api03-[A-Za-z0-9_-]{80,}/,
+  /sk-proj-[A-Za-z0-9_-]{40,}/,
+  /AKIA[0-9A-Z]{16}/,
+  /(?:password|secret|token|api_key)\s*[:=]\s*["']?[A-Za-z0-9_\-+/]{16,}/i
+];
+function scanForSecrets(text) {
+  return SECRET_PATTERNS.some((re) => re.test(text));
+}
+
+// src/forge/prismContext.data.ts
+var PRISM_TEMPLATE_RELEASE_ANNOUNCEMENT = {
+  id: "release-announcement",
+  name: "Release Announcement",
+  description: "Announce what changed based on recent blueprint activity.",
+  defaultFocus: "release",
+  suggestedAsk: "Write a release announcement for the recent changes in our codebase. Reference the specific zones and files that saw the most activity. Make it concrete \u2014 mention zone names and what they do.",
+  suggestedChannels: ["tweet", "linkedin", "newsletter"]
+};
+var PRISM_TEMPLATE_SHIPPING_DIGEST = {
+  id: "weekly-shipping-digest",
+  name: "Weekly Shipping Digest",
+  description: "What we shipped this week \u2014 grounded in real zone activity.",
+  defaultFocus: "changelog",
+  suggestedAsk: "Write a 'what we shipped this week' digest. Use the zone and file activity data to describe what changed. Highlight the most active areas and what that suggests about team focus.",
+  suggestedChannels: ["newsletter", "slack", "linkedin"]
+};
+var PRISM_TEMPLATE_ZONE_DEEPDIVE = {
+  id: "zone-deepdive",
+  name: "Zone Deep-Dive",
+  description: "Deep-dive explanation of a specific zone for developers.",
+  defaultFocus: "deepdive",
+  suggestedAsk: "Write a deep-dive technical explanation of this codebase zone. Describe what lives here, how it connects to the rest of the system, and why it matters. Be concrete \u2014 mention specific files and their roles.",
+  suggestedChannels: ["blog", "hn"],
+  requiresZone: true
+};
+var PRISM_TEMPLATE_ARCHITECTURE_OVERVIEW = {
+  id: "architecture-overview",
+  name: "Architecture Overview",
+  description: "Full codebase structure \u2014 onboarding or blog post.",
+  defaultFocus: "deepdive",
+  suggestedAsk: "Write an architecture overview of this codebase for a new engineer joining the team. Explain the major zones, how they connect, and which files are most central. Be specific \u2014 mention real zone names from the blueprint.",
+  suggestedChannels: ["blog", "newsletter"]
+};
+var PRISM_TEMPLATE_REFACTOR_RATIONALE = {
+  id: "refactor-rationale",
+  name: "Refactor Rationale",
+  description: "Explain why changes were made \u2014 dependency + coupling context.",
+  defaultFocus: "release",
+  suggestedAsk: "Write a technical rationale explaining recent structural changes to the codebase. Focus on the dependency hotspots and what reducing coupling in those areas achieves. Use real file names and zone names from the blueprint.",
+  suggestedChannels: ["blog", "email", "hn"]
+};
+var PRISM_TEMPLATES = [
+  PRISM_TEMPLATE_RELEASE_ANNOUNCEMENT,
+  PRISM_TEMPLATE_SHIPPING_DIGEST,
+  PRISM_TEMPLATE_ZONE_DEEPDIVE,
+  PRISM_TEMPLATE_ARCHITECTURE_OVERVIEW,
+  PRISM_TEMPLATE_REFACTOR_RATIONALE
+];
+function getPrismTemplate(id) {
+  return PRISM_TEMPLATES.find((t) => t.id === id);
+}
+
+// src/forge/channel.ts
+var DISPATCH_CHANNEL_TWEET = {
+  id: "tweet",
+  name: "X / Twitter",
+  kind: "tweet",
+  maxLength: 280,
+  promptHints: "Write a single punchy tweet. Use line breaks for rhythm. 1\u20133 relevant hashtags at the end. No thread notation. Conversational, hook-first. No em-dashes\u2014use plain punctuation."
+};
+var DISPATCH_CHANNEL_LINKEDIN = {
+  id: "linkedin",
+  name: "LinkedIn",
+  kind: "linkedin",
+  maxLength: 1300,
+  promptHints: "Write a LinkedIn post for a professional audience. Start with a hook sentence on its own line. Use short paragraphs (1\u20133 sentences). End with a clear takeaway or call to action. Avoid buzzword soup. Authentic, peer-to-peer tone."
+};
+var DISPATCH_CHANNEL_BLOG = {
+  id: "blog",
+  name: "Blog Post",
+  kind: "blog",
+  maxLength: 3e3,
+  promptHints: "Write the opening section of a blog post: headline, 1\u20132 sentence lede, and 2\u20134 paragraphs expanding the core idea. Use subheadings where helpful. Developer-friendly prose \u2014 concrete, no fluff."
+};
+var DISPATCH_CHANNEL_NEWSLETTER = {
+  id: "newsletter",
+  name: "Newsletter",
+  kind: "newsletter",
+  maxLength: 1800,
+  promptHints: "Write a newsletter section (not the full issue). Lead with a brief context sentence, then the announcement, then 2\u20133 bullet points of detail, then a CTA link placeholder '[CTA]'. Conversational but informative. Appropriate for a developer newsletter."
+};
+var DISPATCH_CHANNEL_HN = {
+  id: "hn",
+  name: "Hacker News",
+  kind: "hn",
+  maxLength: 800,
+  promptHints: "Write a Show HN or Ask HN submission: a one-line title (max 80 chars, factual, no hype) followed by a short 'I built...' or 'We built...' paragraph explaining the technical motivation and what makes it interesting. HN readers are skeptical \u2014 be honest and specific."
+};
+var DISPATCH_CHANNEL_INSTAGRAM = {
+  id: "instagram",
+  name: "Instagram",
+  kind: "instagram",
+  maxLength: 2200,
+  promptHints: "Write an Instagram caption. Start with a hook (first 125 chars are shown before 'more'). Use emojis sparingly and purposefully. Add 5\u201310 relevant hashtags at the end separated from the main text by a blank line. Aspirational but grounded tone."
+};
+var DISPATCH_CHANNEL_REDDIT = {
+  id: "reddit",
+  name: "Reddit",
+  kind: "reddit",
+  maxLength: 1e3,
+  promptHints: "Write a Reddit post for a relevant technical subreddit. Title on the first line (max 300 chars), then the body. Be genuine \u2014 Redditors hate marketing. Lead with what it does and why it matters to them, not to you. Invite discussion at the end."
+};
+var DISPATCH_CHANNEL_EMAIL = {
+  id: "email",
+  name: "Email",
+  kind: "email",
+  maxLength: 1500,
+  promptHints: "Write a plain-text outreach email. Subject line on the first line prefixed with 'Subject: '. Then greeting, short context (1 sentence), the announcement (2\u20133 sentences), a specific CTA, and sign-off. Professional but personal. No HTML."
+};
+var DISPATCH_CHANNEL_SLACK = {
+  id: "slack",
+  name: "Slack",
+  kind: "slack",
+  maxLength: 600,
+  promptHints: "Write a Slack announcement for an internal team channel. Use Slack markdown: *bold*, `code`. Keep it brief \u2014 3\u20135 sentences max. Lead with the key fact, not context. End with a link placeholder '[link]' if relevant."
+};
+var BUNDLED_DISPATCH_CHANNELS = [
+  DISPATCH_CHANNEL_TWEET,
+  DISPATCH_CHANNEL_LINKEDIN,
+  DISPATCH_CHANNEL_BLOG,
+  DISPATCH_CHANNEL_NEWSLETTER,
+  DISPATCH_CHANNEL_HN,
+  DISPATCH_CHANNEL_INSTAGRAM,
+  DISPATCH_CHANNEL_REDDIT,
+  DISPATCH_CHANNEL_EMAIL,
+  DISPATCH_CHANNEL_SLACK
+];
+function getDispatchChannel(id) {
+  return BUNDLED_DISPATCH_CHANNELS.find((c) => c.id === id);
+}
+
+// src/forge/dispatch.ts
+function buildSystemPrompt7(channel, audience, brand, blueprintContext, toneOffset) {
+  const lines = [
+    `You are a skilled content writer producing a ${channel.name} post.`,
+    "",
+    `Channel rules:`,
+    `- Max length: ${channel.maxLength} characters (HARD LIMIT \u2014 do not exceed)`,
+    `- ${channel.promptHints}`
+  ];
+  if (audience) {
+    lines.push("", `Audience: ${audience.label}`);
+    lines.push(`Tone: ${audience.tonality}`);
+    lines.push(`Reading level: ${audience.reading_level}`);
+  }
+  if (toneOffset !== void 0 && toneOffset !== 0) {
+    const adj = toneOffset > 0 ? "more formal and professional" : "more casual and conversational";
+    lines.push(`Tone adjustment: ${adj} (offset ${toneOffset > 0 ? "+" : ""}${toneOffset})`);
+  }
+  if (brand) {
+    lines.push("", `Brand voice: ${brand.voice.tone}, formality ${brand.voice.formality}/100`);
+    if (brand.voice.vocabulary && brand.voice.vocabulary.length > 0) {
+      lines.push(`Preferred vocabulary: ${brand.voice.vocabulary.slice(0, 8).join(", ")}`);
+    }
+    if (brand.voice.avoid && brand.voice.avoid.length > 0) {
+      lines.push(`Avoid these words: ${brand.voice.avoid.slice(0, 6).join(", ")}`);
+    }
+  }
+  if (blueprintContext) {
+    lines.push("", "\u2500\u2500\u2500 CODEBASE CONTEXT (from prism blueprint) \u2500\u2500\u2500");
+    lines.push(blueprintContext);
+    lines.push(
+      "You may reference specific metrics above (file counts, zones, churn) to make the post concrete and credible.",
+      "Do not invent metrics that are not in the context."
+    );
+  }
+  lines.push(
+    "",
+    "IMPORTANT: Return ONLY the post content \u2014 no preamble, no 'Here is your post:', no wrapper quotes.",
+    "Stay strictly within the character limit."
+  );
+  return lines.join("\n");
+}
+function truncate(content, maxLength) {
+  if (content.length <= maxLength) return { content, truncated: false };
+  const cut = content.slice(0, maxLength);
+  const lastSpace = cut.lastIndexOf(" ");
+  const trimmed = lastSpace > maxLength * 0.8 ? cut.slice(0, lastSpace) : cut;
+  return { content: trimmed.trimEnd(), truncated: true };
+}
+async function generateForChannel(ask, channel, provider, opts) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const system = buildSystemPrompt7(
+      channel,
+      opts.audience,
+      opts.brand,
+      opts.blueprintContext,
+      opts.toneOffset
+    );
+    const resp = await provider.complete({
+      systemPrompt: system,
+      messages: [{ role: "user", content: ask }],
+      maxTokens: Math.ceil(channel.maxLength / 3.5) + 100
+      // rough token estimate + buffer
+    });
+    const raw = resp.content.trim();
+    const { content, truncated } = truncate(raw, channel.maxLength);
+    return {
+      output: {
+        channel_id: channel.id,
+        channel_name: channel.name,
+        kind: channel.kind,
+        content,
+        char_count: content.length,
+        truncated,
+        generated_at: now
+      },
+      inputTokens: resp.usedTokens,
+      // approximation — most providers return total
+      outputTokens: 0
+    };
+  } catch (err) {
+    return {
+      output: {
+        channel_id: channel.id,
+        channel_name: channel.name,
+        kind: channel.kind,
+        content: "",
+        char_count: 0,
+        truncated: false,
+        generated_at: now,
+        error: err instanceof Error ? err.message : String(err)
+      },
+      inputTokens: 0,
+      outputTokens: 0
+    };
+  }
+}
+async function orchestrateDispatch(input, provider) {
+  const { ask, channels, audience, brand, blueprintContext, toneOverrides = {} } = input;
+  const results = await Promise.all(
+    channels.map(
+      (ch) => generateForChannel(ask, ch, provider, {
+        audience,
+        brand,
+        blueprintContext,
+        toneOffset: toneOverrides[ch.id]
+      })
+    )
+  );
+  const outputs = results.map((r) => r.output);
+  const totalInput = results.reduce((acc, r) => acc + r.inputTokens, 0);
+  const totalOutput = results.reduce((acc, r) => acc + r.outputTokens, 0);
+  return {
+    outputs,
+    usage: {
+      total_input: totalInput,
+      total_output: totalOutput,
+      channel_count: channels.length
+    }
+  };
+}
+
+// src/forge/assetVersioning.ts
+function uuid() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    return (c === "x" ? r : r & 3 | 8).toString(16);
+  });
+}
+function computeDiff(contentA, contentB) {
+  const linesA = contentA.split("\n");
+  const linesB = contentB.split("\n");
+  const m = linesA.length;
+  const n = linesB.length;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i2 = 1; i2 <= m; i2++) {
+    for (let j2 = 1; j2 <= n; j2++) {
+      if (linesA[i2 - 1] === linesB[j2 - 1]) {
+        dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
+      } else {
+        dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+      }
+    }
+  }
+  const entries = [];
+  let i = m, j = n;
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && linesA[i - 1] === linesB[j - 1]) {
+      entries.push({ type: "unchanged", line: linesA[i - 1], lineNo: i });
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+      entries.push({ type: "added", line: linesB[j - 1] });
+      j--;
+    } else {
+      entries.push({ type: "removed", line: linesA[i - 1], lineNo: i });
+      i--;
+    }
+  }
+  entries.reverse();
+  const addedCount = entries.filter((e) => e.type === "added").length;
+  const removedCount = entries.filter((e) => e.type === "removed").length;
+  return { entries, addedCount, removedCount };
+}
+function buildVersion(assetId, versionNumber, content, message, meta) {
+  return {
+    id: uuid(),
+    assetId,
+    versionNumber,
+    content,
+    message,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...meta
+  };
+}
+function buildRevertVersion(assetId, versionNumber, source) {
+  return {
+    id: uuid(),
+    assetId,
+    versionNumber,
+    content: source.content,
+    message: `Reverted to v${source.versionNumber}`,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    brandKitId: source.brandKitId,
+    styleId: source.styleId,
+    blueprintFocus: source.blueprintFocus,
+    fromPrism: source.fromPrism,
+    revertedFrom: source.versionNumber
+  };
+}
+function nextVersionNumber(versions) {
+  if (versions.length === 0) return 1;
+  return Math.max(...versions.map((v) => v.versionNumber)) + 1;
+}
+
+// src/forge/refineAsset.ts
+function buildSystemPrompt8(input) {
+  const parts = [
+    `You are a content refinement assistant for a developer-focused content tool (forge0x2B).`,
+    `You are refining an existing ${input.assetType.replace(/-/g, " ")} asset.`,
+    ``,
+    `TASK: Apply the user's requested change to the asset content below. Return two things:`,
+    `1. REFINED_CONTENT: The complete revised content (not just the changed parts)`,
+    `2. REPLY: A brief explanation of what you changed and why (1-3 sentences)`,
+    ``,
+    `FORMAT YOUR RESPONSE EXACTLY LIKE THIS (no extra text outside these markers):`,
+    `<REFINED_CONTENT>`,
+    `[the full revised content here]`,
+    `</REFINED_CONTENT>`,
+    `<REPLY>`,
+    `[your brief explanation here]`,
+    `</REPLY>`
+  ];
+  if (input.brandName || input.brandVoice) {
+    parts.push(``, `Brand context:`);
+    if (input.brandName) parts.push(`  Name: ${input.brandName}`);
+    if (input.brandVoice) parts.push(`  Voice: ${input.brandVoice}`);
+  }
+  if (input.styleHint) {
+    parts.push(`  Style: ${input.styleHint}`);
+  }
+  if (input.blueprintContext) {
+    parts.push(``, `Blueprint context (codebase facts to reference):`, input.blueprintContext);
+  }
+  parts.push(``, `CURRENT CONTENT:`, `---`, input.currentContent, `---`);
+  return parts.join("\n");
+}
+function parseRefinedResponse(raw) {
+  const contentMatch = raw.match(/<REFINED_CONTENT>([\s\S]*?)<\/REFINED_CONTENT>/);
+  const replyMatch = raw.match(/<REPLY>([\s\S]*?)<\/REPLY>/);
+  const newContent = contentMatch ? contentMatch[1].trim() : raw.trim();
+  const llmReply = replyMatch ? replyMatch[1].trim() : "Content refined as requested.";
+  return { newContent, llmReply };
+}
+async function refineAsset(input, provider) {
+  const systemPrompt = buildSystemPrompt8(input);
+  if (scanForSecrets(systemPrompt)) {
+    throw new Error("refineAsset: secret pattern detected in asset content. Refusing to send to LLM.");
+  }
+  if (scanForSecrets(input.userMessage)) {
+    throw new Error("refineAsset: secret pattern detected in user message. Refusing to send to LLM.");
+  }
+  const response = await provider.complete({
+    messages: [{ role: "user", content: input.userMessage }],
+    systemPrompt,
+    maxTokens: 2e3
+  });
+  const { newContent, llmReply } = parseRefinedResponse(response.content);
+  return {
+    newContent,
+    llmReply,
+    usedTokens: response.usedTokens
+  };
+}
+var REFINE_SUGGESTIONS = [
+  "Make it more concise",
+  "Add more technical detail",
+  "Make the tone more formal",
+  "Make the tone more casual and conversational",
+  "Add a strong opening hook",
+  "Strengthen the call to action",
+  "Break into shorter paragraphs",
+  "Focus more on developer impact"
+];
+function buildScheduledEntry(assetId, channelId, scheduledFor, contentPreview, metadata = {}) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: crypto.randomUUID(),
+    assetId,
+    channelId,
+    scheduledFor,
+    status: "draft",
+    contentPreview: contentPreview.slice(0, 60),
+    metadata,
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function applyEntryPatch(entry, patch) {
+  return {
+    ...entry,
+    ...patch,
+    metadata: { ...entry.metadata, ...patch.metadata ?? {} },
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function entryInRange(entry, range) {
+  const d = entry.scheduledFor.slice(0, 10);
+  return d >= range.from && d <= range.to;
+}
+function next7DaysRange() {
+  const from = /* @__PURE__ */ new Date();
+  const to = /* @__PURE__ */ new Date();
+  to.setDate(to.getDate() + 6);
+  return {
+    from: from.toISOString().slice(0, 10),
+    to: to.toISOString().slice(0, 10)
+  };
+}
+function cascadingScheduledFor(channelIds, startFrom = /* @__PURE__ */ new Date()) {
+  const result = {};
+  channelIds.forEach((id, i) => {
+    const d = new Date(startFrom);
+    d.setDate(d.getDate() + i);
+    d.setHours(9, 0, 0, 0);
+    result[id] = d.toISOString();
+  });
+  return result;
+}
+
+// src/forge/exporters.ts
+function csvEscape(value) {
+  if (value.includes('"') || value.includes(",") || value.includes("\n") || value.includes("\r")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+function csvRow(cells) {
+  return cells.map(csvEscape).join(",");
+}
+function exportToBufferCsv(entries) {
+  const header = csvRow(["Date", "Time", "Content", "Link", "Image"]);
+  const rows = entries.map((e) => {
+    const d = new Date(e.scheduledFor);
+    const pad = (n) => String(n).padStart(2, "0");
+    const date = `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+    const time = `${pad(d.getHours())}:${pad(d.getMinutes())}`;
+    return csvRow([date, time, e.contentPreview, "", ""]);
+  });
+  return [header, ...rows].join("\r\n");
+}
+function exportToHypefuryCsv(entries) {
+  const header = csvRow(["scheduled_at", "content", "tweet_type"]);
+  const rows = entries.map(
+    (e) => csvRow([e.scheduledFor, e.contentPreview, "tweet"])
+  );
+  return [header, ...rows].join("\r\n");
+}
+function icsDate(iso) {
+  return iso.replace(/[-:]/g, "").replace(/\.\d{3}/, "").replace("Z", "Z");
+}
+function icsEscape(value) {
+  return value.replace(/\\/g, "\\\\").replace(/;/g, "\\;").replace(/,/g, "\\,").replace(/\n/g, "\\n");
+}
+function foldLine(line) {
+  const parts = [];
+  while (line.length > 75) {
+    parts.push(line.slice(0, 75));
+    line = " " + line.slice(75);
+  }
+  parts.push(line);
+  return parts.join("\r\n");
+}
+function exportToICalendar(entries) {
+  const now = icsDate((/* @__PURE__ */ new Date()).toISOString());
+  const events = entries.map((e) => {
+    const dtStart = icsDate(e.scheduledFor);
+    const end = new Date(new Date(e.scheduledFor).getTime() + 30 * 60 * 1e3);
+    const dtEnd = icsDate(end.toISOString());
+    const summary = icsEscape(`[${e.channelId}] ${e.contentPreview}`);
+    const description = icsEscape(
+      `Asset: ${e.assetId} \xB7 Channel: ${e.channelId} \xB7 Status: ${e.status}`
+    );
+    return [
+      "BEGIN:VEVENT",
+      foldLine(`UID:${e.id}@forge0x2B`),
+      `DTSTAMP:${now}`,
+      `DTSTART:${dtStart}`,
+      `DTEND:${dtEnd}`,
+      foldLine(`SUMMARY:${summary}`),
+      foldLine(`DESCRIPTION:${description}`),
+      `STATUS:${e.status === "queued" ? "CONFIRMED" : "TENTATIVE"}`,
+      "END:VEVENT"
+    ].join("\r\n");
+  });
+  return [
+    "BEGIN:VCALENDAR",
+    "VERSION:2.0",
+    "PRODID:-//forge0x2B//Scheduler//EN",
+    "CALSCALE:GREGORIAN",
+    "METHOD:PUBLISH",
+    ...events,
+    "END:VCALENDAR"
+  ].join("\r\n");
+}
+function previewExport(entries, format) {
+  const subset = entries.slice(0, 5);
+  switch (format) {
+    case "buffer":
+      return exportToBufferCsv(subset);
+    case "hypefury":
+      return exportToHypefuryCsv(subset);
+    case "icalendar":
+      return exportToICalendar(subset);
+  }
+}
+
+exports.ANIMATION_DURATION_PRESETS = ANIMATION_DURATION_PRESETS;
+exports.BRAND_CONTENT_SLOT_KEYS = BRAND_CONTENT_SLOT_KEYS;
+exports.BUNDLED_DISPATCH_CHANNELS = BUNDLED_DISPATCH_CHANNELS;
+exports.BUNDLED_STYLE_PRESETS = BUNDLED_STYLE_PRESETS;
+exports.BUNDLED_WIDGET_TEMPLATES = BUNDLED_WIDGET_TEMPLATES;
+exports.DEFAULT_ANIMATION_DURATION_SECONDS = DEFAULT_ANIMATION_DURATION_SECONDS;
+exports.DEFAULT_BRAND_KIT_FONTS = DEFAULT_BRAND_KIT_FONTS;
+exports.DEFAULT_BRAND_KIT_PALETTE = DEFAULT_BRAND_KIT_PALETTE;
+exports.DEFAULT_BRAND_KIT_VOICE = DEFAULT_BRAND_KIT_VOICE;
+exports.DISPATCH_CHANNEL_BLOG = DISPATCH_CHANNEL_BLOG;
+exports.DISPATCH_CHANNEL_EMAIL = DISPATCH_CHANNEL_EMAIL;
+exports.DISPATCH_CHANNEL_HN = DISPATCH_CHANNEL_HN;
+exports.DISPATCH_CHANNEL_INSTAGRAM = DISPATCH_CHANNEL_INSTAGRAM;
+exports.DISPATCH_CHANNEL_LINKEDIN = DISPATCH_CHANNEL_LINKEDIN;
+exports.DISPATCH_CHANNEL_NEWSLETTER = DISPATCH_CHANNEL_NEWSLETTER;
+exports.DISPATCH_CHANNEL_REDDIT = DISPATCH_CHANNEL_REDDIT;
+exports.DISPATCH_CHANNEL_SLACK = DISPATCH_CHANNEL_SLACK;
+exports.DISPATCH_CHANNEL_TWEET = DISPATCH_CHANNEL_TWEET;
+exports.FORGE_AUDIENCES = FORGE_AUDIENCES;
+exports.FORGE_BRAND_THEME_ID = FORGE_BRAND_THEME_ID;
+exports.FORGE_TEMPLATES = FORGE_TEMPLATES;
+exports.FREE_TIER_WIDGET_IDS = FREE_TIER_WIDGET_IDS;
+exports.MAX_ANIMATION_DURATION_SECONDS = MAX_ANIMATION_DURATION_SECONDS;
+exports.MIN_ANIMATION_DURATION_SECONDS = MIN_ANIMATION_DURATION_SECONDS;
+exports.PRISM_TEMPLATES = PRISM_TEMPLATES;
+exports.PRISM_TEMPLATE_ARCHITECTURE_OVERVIEW = PRISM_TEMPLATE_ARCHITECTURE_OVERVIEW;
+exports.PRISM_TEMPLATE_REFACTOR_RATIONALE = PRISM_TEMPLATE_REFACTOR_RATIONALE;
+exports.PRISM_TEMPLATE_RELEASE_ANNOUNCEMENT = PRISM_TEMPLATE_RELEASE_ANNOUNCEMENT;
+exports.PRISM_TEMPLATE_SHIPPING_DIGEST = PRISM_TEMPLATE_SHIPPING_DIGEST;
+exports.PRISM_TEMPLATE_ZONE_DEEPDIVE = PRISM_TEMPLATE_ZONE_DEEPDIVE;
+exports.REFINE_COUNTDOWN_THRESHOLD = REFINE_COUNTDOWN_THRESHOLD;
+exports.REFINE_SESSION_SOFT_CAP = REFINE_SESSION_SOFT_CAP;
+exports.REFINE_SUGGESTIONS = REFINE_SUGGESTIONS;
+exports.STYLE_PRESET_BRUTALIST = STYLE_PRESET_BRUTALIST;
+exports.STYLE_PRESET_DEFAULT = STYLE_PRESET_DEFAULT;
+exports.STYLE_PRESET_GLASSY = STYLE_PRESET_GLASSY;
+exports.STYLE_PRESET_MINIMAL = STYLE_PRESET_MINIMAL;
+exports.TEMPLATE_SCHEMA_EXAMPLES = TEMPLATE_SCHEMA_EXAMPLES;
+exports.TEMPLATE_SCHEMA_GENERIC = TEMPLATE_SCHEMA_GENERIC;
+exports.WIDGET_TEMPLATE_CHANGELOG_ROW = WIDGET_TEMPLATE_CHANGELOG_ROW;
+exports.WIDGET_TEMPLATE_CTA_BANNER = WIDGET_TEMPLATE_CTA_BANNER;
+exports.WIDGET_TEMPLATE_FEATURE_GRID = WIDGET_TEMPLATE_FEATURE_GRID;
+exports.WIDGET_TEMPLATE_METRIC_BADGE = WIDGET_TEMPLATE_METRIC_BADGE;
+exports.WIDGET_TEMPLATE_PRICING_TIER = WIDGET_TEMPLATE_PRICING_TIER;
+exports.WIDGET_TEMPLATE_SOCIAL_PROOF = WIDGET_TEMPLATE_SOCIAL_PROOF;
+exports.WIDGET_TEMPLATE_STAT_CARD = WIDGET_TEMPLATE_STAT_CARD;
+exports.WIDGET_TEMPLATE_TESTIMONIAL = WIDGET_TEMPLATE_TESTIMONIAL;
+exports.applyEntryPatch = applyEntryPatch;
+exports.asAudienceId = asAudienceId;
+exports.assembleBrandUrlExtractionPrompt = assembleBrandUrlExtractionPrompt;
+exports.assembleForgePrompt = assembleForgePrompt;
+exports.brandThemeConfigToEntry = brandThemeConfigToEntry;
+exports.buildRevertVersion = buildRevertVersion;
+exports.buildScheduledEntry = buildScheduledEntry;
+exports.buildVersion = buildVersion;
+exports.cascadingScheduledFor = cascadingScheduledFor;
+exports.clampAnimationDuration = clampAnimationDuration;
+exports.computeDiff = computeDiff;
+exports.defaultBrandKit = defaultBrandKit;
+exports.defaultValueForField = defaultValueForField;
+exports.distill = distill;
+exports.entryInRange = entryInRange;
+exports.exportToBufferCsv = exportToBufferCsv;
+exports.exportToHypefuryCsv = exportToHypefuryCsv;
+exports.exportToICalendar = exportToICalendar;
 exports.generateArchitectureWalkthrough = generateArchitectureWalkthrough;
 exports.generateAskDrivenAsset = generateAskDrivenAsset;
 exports.generateChangesSince = generateChangesSince;
 exports.generateOnboardingDoc = generateOnboardingDoc;
 exports.generateRefactoringReport = generateRefactoringReport;
 exports.generateReleaseNotes = generateReleaseNotes;
-exports.readBlueprintData = readBlueprintData;
-exports.readPrismDirectory = readPrismDirectory;
+exports.getDispatchChannel = getDispatchChannel;
+exports.getPrismTemplate = getPrismTemplate;
+exports.getSlotValue = getSlotValue;
+exports.getStyleById = getStyleById;
+exports.getWidgetTemplate = getWidgetTemplate;
+exports.initialFormValues = initialFormValues;
+exports.next7DaysRange = next7DaysRange;
+exports.nextVersionNumber = nextVersionNumber;
+exports.orchestrateDispatch = orchestrateDispatch;
+exports.parseAndValidateSchemaDefinition = parseAndValidateSchemaDefinition;
+exports.parseBrandKitFromLlmResponse = parseBrandKitFromLlmResponse;
+exports.parseBrandThemeContent = parseBrandThemeContent;
+exports.parseStyleFromCss = parseStyleFromCss;
+exports.parseStyleFromTailwindConfig = parseStyleFromTailwindConfig;
+exports.parseStyleFromTokensJson = parseStyleFromTokensJson;
+exports.parseThemeConfigContent = parseThemeConfigContent;
+exports.previewExport = previewExport;
+exports.refineAsset = refineAsset;
+exports.refineLimitState = refineLimitState;
+exports.renderWidget = renderWidget;
+exports.resolveAnimatedChoice = resolveAnimatedChoice;
+exports.resolveAnimationDuration = resolveAnimationDuration;
+exports.resolveBrandPalette = resolveBrandPalette;
+exports.runForgeGeneration = runForgeGeneration;
+exports.scanForSecrets = scanForSecrets;
+exports.schemaExampleFor = schemaExampleFor;
+exports.schemaToForm = schemaToForm;
+exports.templateAnimatedDefault = templateAnimatedDefault;
+exports.themeEntryToPalette = themeEntryToPalette;
+exports.tryParseJsonObject = tryParseJsonObject;
+exports.validateAgainstTemplateSchema = validateAgainstTemplateSchema;
+exports.validateAssetSlots = validateAssetSlots;
+exports.validateFormValues = validateFormValues;
+exports.validateSchemaDefinition = validateSchemaDefinition;