@odla-ai/brand 0.1.0

package/dist/index.js

@@ -0,0 +1,2625 @@
+// src/constants.ts
+var BRAND_NS = {
+  book: "brand_book",
+  section: "brand_section",
+  palette: "brand_palette",
+  proposal: "brand_proposal",
+  asset: "brand_asset"
+};
+var BOOK_STATUSES = ["draft", "active", "archived"];
+var SECTION_KINDS = ["palette", "typography", "voice", "logo", "imagery"];
+var SECTION_STATUSES = ["draft", "approved"];
+var PALETTE_STATUSES = ["active", "archived"];
+var PALETTE_SOURCES = ["extracted", "derived", "manual"];
+var PROPOSAL_KINDS = ["palette", "typography", "voice", "logo"];
+var PROPOSAL_STATUSES = ["open", "accepted", "rejected", "superseded"];
+var ASSET_KINDS = ["logo", "wordmark", "inspiration", "document", "font", "other"];
+var SWATCH_ROLES = [
+  "primary",
+  "secondary",
+  "highlight",
+  "bg",
+  "surface",
+  "text",
+  "neutral",
+  "good",
+  "warn",
+  "danger",
+  "chart",
+  "custom"
+];
+
+// src/errors.ts
+var BrandInputError = class extends Error {
+  fields;
+  constructor(message, fields) {
+    super(message);
+    this.name = "BrandInputError";
+    this.fields = fields;
+  }
+};
+var BrandNotFoundError = class extends Error {
+  constructor(what) {
+    super(`${what} not found`);
+    this.name = "BrandNotFoundError";
+  }
+};
+
+// src/deps.ts
+async function defaultFetchBytes(url) {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`asset fetch failed: ${res.status} for ${url}`);
+  return {
+    bytes: new Uint8Array(await res.arrayBuffer()),
+    contentType: res.headers.get("content-type") ?? "application/octet-stream"
+  };
+}
+function resolveDeps(deps) {
+  return {
+    db: deps.db,
+    now: deps.now ?? Date.now,
+    newId: deps.newId ?? (() => crypto.randomUUID()),
+    fetchBytes: deps.fetchBytes ?? defaultFetchBytes
+  };
+}
+
+// src/schema.ts
+var a = (type, o = {}) => ({
+  type,
+  unique: false,
+  indexed: false,
+  optional: false,
+  ...o
+});
+var uniq = (type) => a(type, { unique: true, indexed: true });
+var idx = (type, optional = false) => a(type, { indexed: true, optional });
+var opt = (type) => a(type, { optional: true });
+var BRAND_SCHEMA = {
+  entities: {
+    [BRAND_NS.book]: {
+      attrs: {
+        id: uniq("string"),
+        slug: uniq("string"),
+        name: idx("string"),
+        status: idx("string"),
+        // draft | active | archived
+        ownerId: idx("string"),
+        memberIds: a("json"),
+        // the auth roster, incl. the bot agent id
+        channelId: idx("string", true),
+        activePaletteId: opt("string"),
+        tokens: opt("json"),
+        // { light, dark, warnings, compiledAt }
+        summary: opt("string"),
+        createdAt: idx("date"),
+        updatedAt: idx("date")
+      }
+    },
+    [BRAND_NS.section]: {
+      attrs: {
+        key: uniq("string"),
+        // `${bookId}:${kind}` — one section per kind
+        bookId: idx("string"),
+        kind: idx("string"),
+        // palette | typography | voice | logo | imagery
+        status: idx("string"),
+        // draft | approved
+        content: a("json"),
+        audience: a("json"),
+        updatedBy: a("string"),
+        updatedAt: idx("date")
+      }
+    },
+    [BRAND_NS.palette]: {
+      attrs: {
+        id: uniq("string"),
+        bookId: idx("string"),
+        name: a("string"),
+        status: idx("string"),
+        // active | archived
+        swatches: a("json"),
+        // Swatch[] — see the header design note
+        seedHex: opt("string"),
+        source: a("string"),
+        // extracted | derived | manual
+        rationale: opt("string"),
+        proposalId: opt("string"),
+        audience: a("json"),
+        createdAt: idx("date"),
+        updatedAt: idx("date")
+      }
+    },
+    [BRAND_NS.proposal]: {
+      attrs: {
+        id: uniq("string"),
+        bookId: idx("string"),
+        kind: idx("string"),
+        // palette | typography | voice | logo
+        status: idx("string"),
+        // open | accepted | rejected | superseded
+        payload: a("json"),
+        rationale: a("string"),
+        sourceAssetId: opt("string"),
+        messageId: opt("string"),
+        audience: a("json"),
+        createdBy: a("string"),
+        createdAt: idx("date"),
+        resolvedBy: opt("string"),
+        resolvedAt: opt("date"),
+        resolutionNote: opt("string")
+      }
+    },
+    [BRAND_NS.asset]: {
+      attrs: {
+        id: uniq("string"),
+        bookId: idx("string"),
+        kind: idx("string"),
+        // logo | wordmark | inspiration | document | font | other
+        path: idx("string"),
+        url: a("string"),
+        contentType: a("string"),
+        size: a("number"),
+        title: opt("string"),
+        analysis: opt("json"),
+        // { description, dominantColors: hex[], tags }
+        analyzedAt: opt("date"),
+        audience: a("json"),
+        uploadedBy: a("string"),
+        createdAt: idx("date"),
+        deletedAt: opt("date")
+        // tombstone — asset rows are never row-deleted
+      }
+    }
+  },
+  links: {}
+};
+
+// src/rules.ts
+var AUDIENCE = "auth.id in data.audience";
+var BRAND_RULES = {
+  [BRAND_NS.book]: {
+    view: "auth.id in data.memberIds",
+    // Creator is the owner and must include itself in the roster.
+    create: "auth.signedIn && auth.id == data.ownerId && auth.id in data.memberIds",
+    update: "auth.id == data.ownerId",
+    delete: "auth.id == data.ownerId"
+  },
+  [BRAND_NS.section]: {
+    view: AUDIENCE,
+    create: AUDIENCE,
+    update: AUDIENCE,
+    delete: "false"
+    // sections are upserted in place, never removed
+  },
+  [BRAND_NS.palette]: {
+    view: AUDIENCE,
+    create: AUDIENCE,
+    update: AUDIENCE,
+    delete: "false"
+    // archive via status, keep provenance
+  },
+  [BRAND_NS.proposal]: {
+    view: AUDIENCE,
+    create: AUDIENCE,
+    update: AUDIENCE,
+    delete: "false"
+    // resolution history is the audit trail
+  },
+  [BRAND_NS.asset]: {
+    view: "false",
+    create: "false",
+    update: "false",
+    delete: "false"
+  }
+};
+function brandRules() {
+  return Object.fromEntries(Object.entries(BRAND_RULES).map(([ns, r]) => [ns, { ...r }]));
+}
+
+// src/validate.ts
+var MAX_SWATCHES = 24;
+var ASSET_CONTENT_TYPES = /* @__PURE__ */ new Set([
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp",
+  "image/svg+xml",
+  "application/pdf"
+]);
+var HEX_RGB = /^#[0-9a-f]{3}$/;
+var HEX_RRGGBB = /^#[0-9a-f]{6}$/;
+var HEX_ALPHA = /^#[0-9a-f]{4}$|^#[0-9a-f]{8}$/;
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function assertHex(value, label = "color") {
+  if (typeof value !== "string")
+    throw new BrandInputError(`${label} must be a hex string like #1a2b3c`);
+  const hex = value.trim().toLowerCase();
+  if (HEX_ALPHA.test(hex))
+    throw new BrandInputError(`${label} must not carry alpha (got ${value}); use #rrggbb`);
+  if (HEX_RGB.test(hex)) return `#${hex[1]}${hex[1]}${hex[2]}${hex[2]}${hex[3]}${hex[3]}`;
+  if (!HEX_RRGGBB.test(hex))
+    throw new BrandInputError(`${label} must be #rgb or #rrggbb hex (got ${value})`);
+  return hex;
+}
+function capString(value, label, max) {
+  if (typeof value !== "string") throw new BrandInputError(`${label} must be a string`);
+  const s = value.trim();
+  if (s === "") throw new BrandInputError(`${label} must not be empty`);
+  if (s.length > max)
+    throw new BrandInputError(`${label} must be at most ${max} characters (got ${s.length})`);
+  return s;
+}
+function capStringArray(value, label, opts) {
+  if (!Array.isArray(value)) throw new BrandInputError(`${label} must be an array of strings`);
+  const min = opts.minItems ?? 0;
+  if (value.length < min)
+    throw new BrandInputError(`${label} must have at least ${min} item${min === 1 ? "" : "s"}`);
+  if (value.length > opts.maxItems)
+    throw new BrandInputError(`${label} must have at most ${opts.maxItems} items`);
+  return value.map((v, i) => capString(v, `${label}[${i}]`, opts.maxLen));
+}
+function assertSwatches(value) {
+  if (!Array.isArray(value) || value.length === 0)
+    throw new BrandInputError("swatches must be a non-empty array");
+  if (value.length > MAX_SWATCHES)
+    throw new BrandInputError(`swatches must have at most ${MAX_SWATCHES} entries`);
+  return value.map((raw, i) => {
+    if (!isRecord(raw)) throw new BrandInputError(`swatches[${i}] must be an object`);
+    const role = raw.role;
+    if (typeof role !== "string" || !SWATCH_ROLES.includes(role))
+      throw new BrandInputError(
+        `swatches[${i}].role must be one of: ${SWATCH_ROLES.join(", ")}`
+      );
+    const out = { role, hex: assertHex(raw.hex, `swatches[${i}].hex`) };
+    if (raw.name !== void 0) out.name = capString(raw.name, `swatches[${i}].name`, 80);
+    if (raw.rationale !== void 0)
+      out.rationale = capString(raw.rationale, `swatches[${i}].rationale`, 500);
+    return out;
+  });
+}
+function assertPaletteSection(c) {
+  return {
+    paletteId: capString(c.paletteId, "content.paletteId", 128),
+    name: capString(c.name, "content.name", 120),
+    swatches: assertSwatches(c.swatches)
+  };
+}
+function assertTypographySection(c) {
+  const out = {};
+  if (c.fontDisplay !== void 0) out.fontDisplay = capString(c.fontDisplay, "content.fontDisplay", 120);
+  if (c.fontBody !== void 0) out.fontBody = capString(c.fontBody, "content.fontBody", 120);
+  if (c.fontMono !== void 0) out.fontMono = capString(c.fontMono, "content.fontMono", 120);
+  if (c.scale !== void 0) {
+    if (typeof c.scale !== "number" || !Number.isFinite(c.scale) || c.scale <= 1 || c.scale > 2)
+      throw new BrandInputError("content.scale must be a modular type-scale ratio in (1, 2]");
+    out.scale = c.scale;
+  }
+  if (c.notes !== void 0) out.notes = capString(c.notes, "content.notes", 2e3);
+  return out;
+}
+function assertVoiceSection(c) {
+  const out = {
+    tone: capString(c.tone, "content.tone", 200),
+    principles: capStringArray(c.principles, "content.principles", { maxItems: 12, maxLen: 200, minItems: 1 })
+  };
+  if (c.examples !== void 0)
+    out.examples = capStringArray(c.examples, "content.examples", { maxItems: 12, maxLen: 500 });
+  return out;
+}
+function assertLogoSection(c) {
+  const out = {
+    usage: capStringArray(c.usage, "content.usage", { maxItems: 16, maxLen: 300, minItems: 1 }),
+    donts: capStringArray(c.donts, "content.donts", { maxItems: 16, maxLen: 300 })
+  };
+  if (c.clearspace !== void 0) out.clearspace = capString(c.clearspace, "content.clearspace", 120);
+  if (c.minSize !== void 0) out.minSize = capString(c.minSize, "content.minSize", 120);
+  return out;
+}
+function assertImagerySection(c) {
+  return {
+    style: capString(c.style, "content.style", 200),
+    guidance: capStringArray(c.guidance, "content.guidance", { maxItems: 16, maxLen: 300, minItems: 1 })
+  };
+}
+function assertSectionContent(kind, content) {
+  if (!isRecord(content)) throw new BrandInputError("content must be an object");
+  switch (kind) {
+    case "palette":
+      return { ...assertPaletteSection(content) };
+    case "typography":
+      return { ...assertTypographySection(content) };
+    case "voice":
+      return { ...assertVoiceSection(content) };
+    case "logo":
+      return { ...assertLogoSection(content) };
+    case "imagery":
+      return { ...assertImagerySection(content) };
+    default:
+      throw new BrandInputError(`unknown section kind ${kind}; expected one of: ${SECTION_KINDS.join(", ")}`);
+  }
+}
+function safeFileName(name) {
+  if (typeof name !== "string") throw new BrandInputError("file name must be a string");
+  const cleaned = name.replace(/[/\\]/g, "").replace(/[\u0000-\u001f\u007f]/g, "").trim().replace(/^\.+/, "");
+  if (cleaned === "") throw new BrandInputError("file name is empty after sanitizing");
+  return cleaned.slice(0, 120);
+}
+function assertAssetContentType(value) {
+  if (typeof value !== "string") throw new BrandInputError("contentType must be a string");
+  const ct = value.split(";")[0].trim().toLowerCase();
+  if (!ASSET_CONTENT_TYPES.has(ct))
+    throw new BrandInputError(
+      `unsupported content type ${ct || "(empty)"}; allowed: ${[...ASSET_CONTENT_TYPES].join(", ")}`
+    );
+  return ct;
+}
+function assertAnalysis(value) {
+  if (!isRecord(value)) throw new BrandInputError("analysis must be an object");
+  const colors = value.dominantColors;
+  if (!Array.isArray(colors)) throw new BrandInputError("analysis.dominantColors must be an array");
+  if (colors.length > 12)
+    throw new BrandInputError("analysis.dominantColors must have at most 12 entries");
+  return {
+    description: capString(value.description, "analysis.description", 2e3),
+    dominantColors: colors.map((c, i) => assertHex(c, `analysis.dominantColors[${i}]`)),
+    tags: capStringArray(value.tags, "analysis.tags", { maxItems: 24, maxLen: 60 })
+  };
+}
+
+// src/ops/books.ts
+var SLUG_RE = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+function createBookOps(input) {
+  const slug = capString(input.slug, "slug", 80);
+  if (!SLUG_RE.test(slug))
+    throw new BrandInputError("slug must be lowercase letters, digits, and inner hyphens");
+  const name = capString(input.name, "name", 120);
+  const memberIds = Array.from(/* @__PURE__ */ new Set([input.ownerId, ...input.memberIds]));
+  return [
+    {
+      t: "update",
+      ns: BRAND_NS.book,
+      id: input.id,
+      attrs: {
+        id: input.id,
+        slug,
+        name,
+        status: "draft",
+        ownerId: input.ownerId,
+        memberIds,
+        createdAt: input.now,
+        updatedAt: input.now,
+        ...input.channelId ? { channelId: input.channelId } : {}
+      }
+    }
+  ];
+}
+var PATCHABLE = /* @__PURE__ */ new Set(["name", "status", "channelId", "summary", "activePaletteId", "tokens"]);
+var CLEARABLE = /* @__PURE__ */ new Set(["channelId", "summary", "activePaletteId", "tokens"]);
+function validateBookField(key, value) {
+  switch (key) {
+    case "name":
+      return capString(value, "name", 120);
+    case "status":
+      if (typeof value !== "string" || !BOOK_STATUSES.includes(value))
+        throw new BrandInputError(`status must be one of: ${BOOK_STATUSES.join(", ")}`);
+      return value;
+    case "channelId":
+      return capString(value, "channelId", 128);
+    case "summary":
+      return capString(value, "summary", 2e3);
+    case "activePaletteId":
+      return capString(value, "activePaletteId", 128);
+    default: {
+      if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new BrandInputError("tokens must be an object");
+      return value;
+    }
+  }
+}
+function updateBookOps(bookId, patch, now) {
+  const attrs = {};
+  const retract = [];
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) continue;
+    if (!PATCHABLE.has(key)) throw new BrandInputError(`unknown book field: ${key}`);
+    if (value === null) {
+      if (!CLEARABLE.has(key)) throw new BrandInputError(`${key} is required and cannot be cleared`);
+      retract.push(key);
+      continue;
+    }
+    attrs[key] = validateBookField(key, value);
+  }
+  if (Object.keys(attrs).length === 0 && retract.length === 0) return [];
+  const ops = [
+    { t: "update", ns: BRAND_NS.book, id: bookId, attrs: { ...attrs, updatedAt: now } }
+  ];
+  if (retract.length > 0) ops.push({ t: "retract", ns: BRAND_NS.book, id: bookId, attrs: retract });
+  return ops;
+}
+function audienceFanoutOps(book, newMemberIds, children, now) {
+  const memberIds = Array.from(/* @__PURE__ */ new Set([book.ownerId, ...newMemberIds]));
+  const ops = [
+    { t: "update", ns: BRAND_NS.book, id: book.id, attrs: { memberIds, updatedAt: now } }
+  ];
+  const fan = (ns, rows) => {
+    for (const row of rows ?? []) ops.push({ t: "update", ns, id: row.id, attrs: { audience: memberIds } });
+  };
+  fan(BRAND_NS.section, children.sections);
+  fan(BRAND_NS.palette, children.palettes);
+  fan(BRAND_NS.proposal, children.proposals);
+  fan(BRAND_NS.asset, children.assets);
+  return ops;
+}
+
+// src/ops/sections.ts
+function sectionKey(bookId, kind) {
+  return `${bookId}:${kind}`;
+}
+function upsertSectionOps(input) {
+  const status = input.status ?? "draft";
+  if (!SECTION_STATUSES.includes(status))
+    throw new BrandInputError(`status must be one of: ${SECTION_STATUSES.join(", ")}`);
+  const content = assertSectionContent(input.kind, input.content);
+  const key = sectionKey(input.bookId, input.kind);
+  return [
+    {
+      t: "update",
+      ns: BRAND_NS.section,
+      id: { ns: BRAND_NS.section, attr: "key", value: key },
+      attrs: {
+        key,
+        bookId: input.bookId,
+        kind: input.kind,
+        status,
+        content,
+        audience: input.audience,
+        updatedBy: input.updatedBy,
+        updatedAt: input.now
+      }
+    }
+  ];
+}
+
+// src/ops/palettes.ts
+function proposePaletteOps(input) {
+  const name = capString(input.name, "name", 120);
+  const rationale = capString(input.rationale, "rationale", 2e3);
+  const swatches = assertSwatches(input.swatches);
+  const seedHex = input.seedHex === void 0 ? void 0 : assertHex(input.seedHex, "seedHex");
+  const payload = {
+    name,
+    swatches,
+    ...seedHex ? { seedHex } : {},
+    ...input.contrastReport !== void 0 ? { contrastReport: input.contrastReport } : {}
+  };
+  return [
+    {
+      t: "update",
+      ns: BRAND_NS.proposal,
+      id: input.id,
+      attrs: {
+        id: input.id,
+        bookId: input.bookId,
+        kind: "palette",
+        status: "open",
+        payload,
+        rationale,
+        audience: input.audience,
+        createdBy: input.createdBy,
+        createdAt: input.now,
+        ...input.sourceAssetId ? { sourceAssetId: input.sourceAssetId } : {},
+        ...input.messageId ? { messageId: input.messageId } : {}
+      }
+    }
+  ];
+}
+function acceptProposalOps(input) {
+  const { proposal, paletteId, resolvedBy, now } = input;
+  if (proposal.kind !== "palette")
+    throw new BrandInputError(`proposal ${proposal.id} is a ${proposal.kind} proposal, not a palette`);
+  if (proposal.status !== "open")
+    throw new BrandInputError(`proposal ${proposal.id} is ${proposal.status}, not open`);
+  const payload = proposal.payload;
+  const name = capString(payload.name, "payload.name", 120);
+  const swatches = assertSwatches(payload.swatches);
+  const seedHex = payload.seedHex === void 0 ? void 0 : assertHex(payload.seedHex, "payload.seedHex");
+  const source = proposal.sourceAssetId ? "extracted" : seedHex ? "derived" : "manual";
+  return [
+    {
+      t: "update",
+      ns: BRAND_NS.palette,
+      id: paletteId,
+      attrs: {
+        id: paletteId,
+        bookId: proposal.bookId,
+        name,
+        status: "active",
+        swatches,
+        source,
+        rationale: proposal.rationale,
+        proposalId: proposal.id,
+        audience: proposal.audience,
+        createdAt: now,
+        updatedAt: now,
+        ...seedHex ? { seedHex } : {}
+      }
+    },
+    ...upsertSectionOps({
+      bookId: proposal.bookId,
+      kind: "palette",
+      content: { paletteId, name, swatches },
+      status: "approved",
+      audience: proposal.audience,
+      updatedBy: resolvedBy,
+      now
+    }),
+    {
+      t: "update",
+      ns: BRAND_NS.book,
+      id: proposal.bookId,
+      attrs: { activePaletteId: paletteId, updatedAt: now }
+    },
+    {
+      t: "update",
+      ns: BRAND_NS.proposal,
+      id: proposal.id,
+      attrs: {
+        status: "accepted",
+        resolvedBy,
+        resolvedAt: now,
+        ...input.resolutionNote ? { resolutionNote: input.resolutionNote } : {}
+      }
+    }
+  ];
+}
+function rejectProposalOps(input) {
+  const { proposal, resolvedBy, now } = input;
+  if (proposal.status !== "open")
+    throw new BrandInputError(`proposal ${proposal.id} is ${proposal.status}, not open`);
+  return [
+    {
+      t: "update",
+      ns: BRAND_NS.proposal,
+      id: proposal.id,
+      attrs: {
+        status: "rejected",
+        resolvedBy,
+        resolvedAt: now,
+        ...input.resolutionNote ? { resolutionNote: input.resolutionNote } : {}
+      }
+    }
+  ];
+}
+
+// src/ops/assets.ts
+function createAssetOps(input) {
+  if (!ASSET_KINDS.includes(input.kind))
+    throw new BrandInputError(`kind must be one of: ${ASSET_KINDS.join(", ")}`);
+  const contentType = assertAssetContentType(input.contentType);
+  if (typeof input.size !== "number" || !Number.isFinite(input.size) || input.size <= 0)
+    throw new BrandInputError("size must be a positive byte count");
+  const title = input.title === void 0 ? void 0 : capString(input.title, "title", 160);
+  return [
+    {
+      t: "update",
+      ns: BRAND_NS.asset,
+      id: input.id,
+      attrs: {
+        id: input.id,
+        bookId: input.bookId,
+        kind: input.kind,
+        path: capString(input.path, "path", 512),
+        url: capString(input.url, "url", 1024),
+        contentType,
+        size: input.size,
+        audience: input.audience,
+        uploadedBy: input.uploadedBy,
+        createdAt: input.now,
+        ...title ? { title } : {}
+      }
+    }
+  ];
+}
+function tombstoneAssetOps(assetId, now) {
+  return [{ t: "update", ns: BRAND_NS.asset, id: assetId, attrs: { deletedAt: now } }];
+}
+function recordAnalysisOps(assetId, analysis, now) {
+  return [
+    {
+      t: "update",
+      ns: BRAND_NS.asset,
+      id: assetId,
+      attrs: { analysis: assertAnalysis(analysis), analyzedAt: now }
+    }
+  ];
+}
+
+// src/color/hex.ts
+function clamp01(x) {
+  return Number.isNaN(x) ? 0 : x < 0 ? 0 : x > 1 ? 1 : x;
+}
+var HEX3 = /^#[0-9a-f]{3}$/;
+var HEX6 = /^#[0-9a-f]{6}$/;
+var HEX_ALPHA2 = /^#([0-9a-f]{4}|[0-9a-f]{8})$/;
+function parseHex(hex) {
+  const s = hex.trim().toLowerCase();
+  if (HEX_ALPHA2.test(s)) {
+    throw new RangeError(
+      `parseHex: alpha hex "${hex}" is not supported \u2014 use an opaque "#rrggbb" value`
+    );
+  }
+  if (HEX3.test(s)) {
+    return {
+      r: parseInt(s[1] + s[1], 16) / 255,
+      g: parseInt(s[2] + s[2], 16) / 255,
+      b: parseInt(s[3] + s[3], 16) / 255
+    };
+  }
+  if (HEX6.test(s)) {
+    return {
+      r: parseInt(s.slice(1, 3), 16) / 255,
+      g: parseInt(s.slice(3, 5), 16) / 255,
+      b: parseInt(s.slice(5, 7), 16) / 255
+    };
+  }
+  throw new RangeError(`parseHex: expected "#rgb" or "#rrggbb", got "${hex}"`);
+}
+function toHex(rgb) {
+  const ch = (c) => Math.round(clamp01(c) * 255).toString(16).padStart(2, "0");
+  return `#${ch(rgb.r)}${ch(rgb.g)}${ch(rgb.b)}`;
+}
+function normalizeHex(hex) {
+  return toHex(parseHex(hex));
+}
+
+// src/color/convert.ts
+function srgbToLinear(c) {
+  return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+}
+function linearToSrgb(c) {
+  return c <= 31308e-7 ? c * 12.92 : 1.055 * c ** (1 / 2.4) - 0.055;
+}
+function rgbToHsl({ r, g, b }) {
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const l = (max + min) / 2;
+  const d = max - min;
+  if (d === 0) return { h: 0, s: 0, l };
+  const s = d / (1 - Math.abs(2 * l - 1));
+  let h;
+  if (max === r) h = 60 * ((g - b) / d % 6);
+  else if (max === g) h = 60 * ((b - r) / d + 2);
+  else h = 60 * ((r - g) / d + 4);
+  return { h: (h + 360) % 360, s, l };
+}
+function hslToRgb({ h, s, l }) {
+  const hue = (h % 360 + 360) % 360;
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(hue / 60 % 2 - 1));
+  const m = l - c / 2;
+  const sextants = [
+    [c, x, 0],
+    [x, c, 0],
+    [0, c, x],
+    [0, x, c],
+    [x, 0, c],
+    [c, 0, x]
+  ];
+  const [r, g, b] = sextants[Math.floor(hue / 60) % 6];
+  return { r: r + m, g: g + m, b: b + m };
+}
+function rgbToOklab({ r, g, b }) {
+  const R = srgbToLinear(r);
+  const G = srgbToLinear(g);
+  const B = srgbToLinear(b);
+  const l = Math.cbrt(0.4122214708 * R + 0.5363325363 * G + 0.0514459929 * B);
+  const m = Math.cbrt(0.2119034982 * R + 0.6806995451 * G + 0.1073969566 * B);
+  const s = Math.cbrt(0.0883024619 * R + 0.2817188376 * G + 0.6299787005 * B);
+  return {
+    L: 0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+    a: 1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+    b: 0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s
+  };
+}
+function oklabToRgb({ L, a: a2, b }) {
+  const l = (L + 0.3963377774 * a2 + 0.2158037573 * b) ** 3;
+  const m = (L - 0.1055613458 * a2 - 0.0638541728 * b) ** 3;
+  const s = (L - 0.0894841775 * a2 - 1.291485548 * b) ** 3;
+  return {
+    r: linearToSrgb(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s),
+    g: linearToSrgb(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s),
+    b: linearToSrgb(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s)
+  };
+}
+function oklabToOklch({ L, a: a2, b }) {
+  const C = Math.hypot(a2, b);
+  const h = C < 1e-9 ? 0 : (Math.atan2(b, a2) * 180 / Math.PI + 360) % 360;
+  return { L, C, h };
+}
+function oklchToOklab({ L, C, h }) {
+  const rad = h * Math.PI / 180;
+  return { L, a: C * Math.cos(rad), b: C * Math.sin(rad) };
+}
+function hexToOklch(hex) {
+  return oklabToOklch(rgbToOklab(parseHex(hex)));
+}
+function oklchToHex(lch) {
+  return toHex(oklabToRgb(oklchToOklab(lch)));
+}
+var GAMUT_EPS = 1e-6;
+function inSrgbGamut({ r, g, b }) {
+  const ok = (c) => c >= -GAMUT_EPS && c <= 1 + GAMUT_EPS;
+  return ok(r) && ok(g) && ok(b);
+}
+function clampToGamut(lch) {
+  const L = clamp01(lch.L);
+  const h = lch.h;
+  if (inSrgbGamut(oklabToRgb(oklchToOklab({ L, C: lch.C, h })))) return { L, C: lch.C, h };
+  let lo = 0;
+  let hi = lch.C;
+  for (let i = 0; i < 24; i++) {
+    const mid = (lo + hi) / 2;
+    if (inSrgbGamut(oklabToRgb(oklchToOklab({ L, C: mid, h })))) lo = mid;
+    else hi = mid;
+  }
+  return { L, C: lo, h };
+}
+
+// src/color/contrast.ts
+function relativeLuminance(hex) {
+  const { r, g, b } = parseHex(hex);
+  return 0.2126 * srgbToLinear(r) + 0.7152 * srgbToLinear(g) + 0.0722 * srgbToLinear(b);
+}
+function contrastRatio(hexA, hexB) {
+  const la = relativeLuminance(hexA);
+  const lb = relativeLuminance(hexB);
+  return (Math.max(la, lb) + 0.05) / (Math.min(la, lb) + 0.05);
+}
+var AA = { text: 4.5, "large-text": 3, ui: 3 };
+var AAA = { text: 7, "large-text": 4.5 };
+function meetsAA(ratio, kind = "text") {
+  return ratio >= AA[kind];
+}
+function meetsAAA(ratio, kind = "text") {
+  return ratio >= AAA[kind];
+}
+var PICK_TEXT_DEFAULT_CANDIDATES = ["#ffffff", "#050505"];
+function pickTextOn(bgHex, candidates = PICK_TEXT_DEFAULT_CANDIDATES) {
+  if (candidates.length === 0) throw new RangeError("pickTextOn: candidates must be non-empty");
+  let best = candidates[0];
+  let bestRatio = -1;
+  for (const candidate of candidates) {
+    const ratio = contrastRatio(bgHex, candidate);
+    if (ratio > bestRatio) {
+      best = candidate;
+      bestRatio = ratio;
+    }
+  }
+  return best;
+}
+
+// src/color/harmony.ts
+function rotateHue(hex, degrees) {
+  const { L, C, h } = hexToOklch(hex);
+  return oklchToHex(clampToGamut({ L, C, h: ((h + degrees) % 360 + 360) % 360 }));
+}
+function complementary(hex) {
+  return rotateHue(hex, 180);
+}
+function analogous(hex, angle = 30) {
+  return [rotateHue(hex, -angle), rotateHue(hex, angle)];
+}
+function triadic(hex) {
+  return [rotateHue(hex, -120), rotateHue(hex, 120)];
+}
+function splitComplementary(hex) {
+  return [rotateHue(hex, -150), rotateHue(hex, 150)];
+}
+function tetradic(hex) {
+  return [rotateHue(hex, 90), rotateHue(hex, 180), rotateHue(hex, 270)];
+}
+function monochrome(hex, steps = 5) {
+  if (!Number.isInteger(steps) || steps < 2) {
+    throw new RangeError(`monochrome: steps must be an integer >= 2, got ${steps}`);
+  }
+  const { L, C, h } = hexToOklch(hex);
+  const out = [];
+  for (let i = 0; i < steps; i++) {
+    out.push(oklchToHex(clampToGamut({ L, C: C * (1 - i / (steps - 1)), h })));
+  }
+  return out;
+}
+
+// src/color/ramp.ts
+var RAMP_L_MAX = 0.96;
+var RAMP_L_MIN = 0.27;
+var CHROMA_FLOOR = 0.25;
+function tintShadeRamp(hex, steps = 9) {
+  if (!Number.isInteger(steps) || steps < 2) {
+    throw new RangeError(`tintShadeRamp: steps must be an integer >= 2, got ${steps}`);
+  }
+  const { C, h } = hexToOklch(hex);
+  const out = [];
+  for (let i = 0; i < steps; i++) {
+    const t = i / (steps - 1);
+    const L = RAMP_L_MAX + (RAMP_L_MIN - RAMP_L_MAX) * t;
+    const taper = CHROMA_FLOOR + (1 - CHROMA_FLOOR) * (1 - Math.abs(2 * t - 1));
+    out.push(oklchToHex(clampToGamut({ L, C: C * taper, h })));
+  }
+  return out;
+}
+var SCAN_STEPS = 16;
+var BISECT_STEPS = 22;
+function adjustLightnessUntil(hex, predicate, direction) {
+  const start = normalizeHex(hex);
+  if (predicate(start)) return start;
+  const { L, C, h } = hexToOklch(start);
+  const bound = direction === "lighten" ? 1 : 0;
+  const at = (l) => oklchToHex(clampToGamut({ L: l, C, h }));
+  let lastFail = L;
+  let firstPass = Number.NaN;
+  for (let i = 1; i <= SCAN_STEPS; i++) {
+    const l = L + (bound - L) * i / SCAN_STEPS;
+    if (predicate(at(l))) {
+      firstPass = l;
+      break;
+    }
+    lastFail = l;
+  }
+  if (Number.isNaN(firstPass)) return null;
+  for (let i = 0; i < BISECT_STEPS; i++) {
+    const mid = (lastFail + firstPass) / 2;
+    if (predicate(at(mid))) firstPass = mid;
+    else lastFail = mid;
+  }
+  return at(firstPass);
+}
+
+// src/color/delta.ts
+function deltaEOKLab(x, y) {
+  return Math.hypot(x.L - y.L, x.a - y.a, x.b - y.b);
+}
+function deltaEOK(hexA, hexB) {
+  return deltaEOKLab(rgbToOklab(parseHex(hexA)), rgbToOklab(parseHex(hexB)));
+}
+
+// src/color/names.ts
+var TABLE = [
+  ["aliceblue", "#f0f8ff"],
+  ["antiquewhite", "#faebd7"],
+  ["aqua", "#00ffff"],
+  ["aquamarine", "#7fffd4"],
+  ["azure", "#f0ffff"],
+  ["beige", "#f5f5dc"],
+  ["bisque", "#ffe4c4"],
+  ["black", "#000000"],
+  ["blanchedalmond", "#ffebcd"],
+  ["blue", "#0000ff"],
+  ["blueviolet", "#8a2be2"],
+  ["brown", "#a52a2a"],
+  ["burlywood", "#deb887"],
+  ["cadetblue", "#5f9ea0"],
+  ["chartreuse", "#7fff00"],
+  ["chocolate", "#d2691e"],
+  ["coral", "#ff7f50"],
+  ["cornflowerblue", "#6495ed"],
+  ["cornsilk", "#fff8dc"],
+  ["crimson", "#dc143c"],
+  ["cyan", "#00ffff"],
+  ["darkblue", "#00008b"],
+  ["darkcyan", "#008b8b"],
+  ["darkgoldenrod", "#b8860b"],
+  ["darkgray", "#a9a9a9"],
+  ["darkgreen", "#006400"],
+  ["darkgrey", "#a9a9a9"],
+  ["darkkhaki", "#bdb76b"],
+  ["darkmagenta", "#8b008b"],
+  ["darkolivegreen", "#556b2f"],
+  ["darkorange", "#ff8c00"],
+  ["darkorchid", "#9932cc"],
+  ["darkred", "#8b0000"],
+  ["darksalmon", "#e9967a"],
+  ["darkseagreen", "#8fbc8f"],
+  ["darkslateblue", "#483d8b"],
+  ["darkslategray", "#2f4f4f"],
+  ["darkslategrey", "#2f4f4f"],
+  ["darkturquoise", "#00ced1"],
+  ["darkviolet", "#9400d3"],
+  ["deeppink", "#ff1493"],
+  ["deepskyblue", "#00bfff"],
+  ["dimgray", "#696969"],
+  ["dimgrey", "#696969"],
+  ["dodgerblue", "#1e90ff"],
+  ["firebrick", "#b22222"],
+  ["floralwhite", "#fffaf0"],
+  ["forestgreen", "#228b22"],
+  ["fuchsia", "#ff00ff"],
+  ["gainsboro", "#dcdcdc"],
+  ["ghostwhite", "#f8f8ff"],
+  ["gold", "#ffd700"],
+  ["goldenrod", "#daa520"],
+  ["gray", "#808080"],
+  ["green", "#008000"],
+  ["greenyellow", "#adff2f"],
+  ["grey", "#808080"],
+  ["honeydew", "#f0fff0"],
+  ["hotpink", "#ff69b4"],
+  ["indianred", "#cd5c5c"],
+  ["indigo", "#4b0082"],
+  ["ivory", "#fffff0"],
+  ["khaki", "#f0e68c"],
+  ["lavender", "#e6e6fa"],
+  ["lavenderblush", "#fff0f5"],
+  ["lawngreen", "#7cfc00"],
+  ["lemonchiffon", "#fffacd"],
+  ["lightblue", "#add8e6"],
+  ["lightcoral", "#f08080"],
+  ["lightcyan", "#e0ffff"],
+  ["lightgoldenrodyellow", "#fafad2"],
+  ["lightgray", "#d3d3d3"],
+  ["lightgreen", "#90ee90"],
+  ["lightgrey", "#d3d3d3"],
+  ["lightpink", "#ffb6c1"],
+  ["lightsalmon", "#ffa07a"],
+  ["lightseagreen", "#20b2aa"],
+  ["lightskyblue", "#87cefa"],
+  ["lightslategray", "#778899"],
+  ["lightslategrey", "#778899"],
+  ["lightsteelblue", "#b0c4de"],
+  ["lightyellow", "#ffffe0"],
+  ["lime", "#00ff00"],
+  ["limegreen", "#32cd32"],
+  ["linen", "#faf0e6"],
+  ["magenta", "#ff00ff"],
+  ["maroon", "#800000"],
+  ["mediumaquamarine", "#66cdaa"],
+  ["mediumblue", "#0000cd"],
+  ["mediumorchid", "#ba55d3"],
+  ["mediumpurple", "#9370db"],
+  ["mediumseagreen", "#3cb371"],
+  ["mediumslateblue", "#7b68ee"],
+  ["mediumspringgreen", "#00fa9a"],
+  ["mediumturquoise", "#48d1cc"],
+  ["mediumvioletred", "#c71585"],
+  ["midnightblue", "#191970"],
+  ["mintcream", "#f5fffa"],
+  ["mistyrose", "#ffe4e1"],
+  ["moccasin", "#ffe4b5"],
+  ["navajowhite", "#ffdead"],
+  ["navy", "#000080"],
+  ["oldlace", "#fdf5e6"],
+  ["olive", "#808000"],
+  ["olivedrab", "#6b8e23"],
+  ["orange", "#ffa500"],
+  ["orangered", "#ff4500"],
+  ["orchid", "#da70d6"],
+  ["palegoldenrod", "#eee8aa"],
+  ["palegreen", "#98fb98"],
+  ["paleturquoise", "#afeeee"],
+  ["palevioletred", "#db7093"],
+  ["papayawhip", "#ffefd5"],
+  ["peachpuff", "#ffdab9"],
+  ["peru", "#cd853f"],
+  ["pink", "#ffc0cb"],
+  ["plum", "#dda0dd"],
+  ["powderblue", "#b0e0e6"],
+  ["purple", "#800080"],
+  ["rebeccapurple", "#663399"],
+  ["red", "#ff0000"],
+  ["rosybrown", "#bc8f8f"],
+  ["royalblue", "#4169e1"],
+  ["saddlebrown", "#8b4513"],
+  ["salmon", "#fa8072"],
+  ["sandybrown", "#f4a460"],
+  ["seagreen", "#2e8b57"],
+  ["seashell", "#fff5ee"],
+  ["sienna", "#a0522d"],
+  ["silver", "#c0c0c0"],
+  ["skyblue", "#87ceeb"],
+  ["slateblue", "#6a5acd"],
+  ["slategray", "#708090"],
+  ["slategrey", "#708090"],
+  ["snow", "#fffafa"],
+  ["springgreen", "#00ff7f"],
+  ["steelblue", "#4682b4"],
+  ["tan", "#d2b48c"],
+  ["teal", "#008080"],
+  ["thistle", "#d8bfd8"],
+  ["tomato", "#ff6347"],
+  ["turquoise", "#40e0d0"],
+  ["violet", "#ee82ee"],
+  ["wheat", "#f5deb3"],
+  ["white", "#ffffff"],
+  ["whitesmoke", "#f5f5f5"],
+  ["yellow", "#ffff00"],
+  ["yellowgreen", "#9acd32"]
+];
+var CSS_NAMED_COLORS = TABLE.map(([name, hex]) => ({
+  name,
+  hex
+}));
+var labCache = null;
+function nearestNamedColor(hex) {
+  const target = rgbToOklab(parseHex(hex));
+  labCache ??= TABLE.map(([, value2]) => rgbToOklab(parseHex(value2)));
+  let bestIdx = 0;
+  let bestD = Infinity;
+  for (let i = 0; i < labCache.length; i++) {
+    const d = deltaEOKLab(target, labCache[i]);
+    if (d < bestD) {
+      bestD = d;
+      bestIdx = i;
+    }
+  }
+  const [name, value] = TABLE[bestIdx];
+  return { name, hex: value, deltaEOK: bestD };
+}
+
+// src/color/palette.ts
+var CHART_DELTA_MIN = 0.1;
+var CHART_L = 0.7;
+var CHART_C = 0.115;
+var ANCHOR_HUE = 250;
+var ACHROMATIC_C = 0.02;
+var STATUS_HUES = { good: 145, warn: 85, danger: 25 };
+var STATUS_L = 0.7;
+var STATUS_C = 0.14;
+var ROTATIONS = [180, 120, -120, 150, -150];
+function deriveChartColors(seedHex, opts = {}) {
+  const count = opts.count ?? 6;
+  const deltaMin = opts.deltaMin ?? CHART_DELTA_MIN;
+  if (!Number.isInteger(count) || count < 1 || count > 12) {
+    throw new RangeError(`deriveChartColors: count must be an integer in 1..12, got ${count}`);
+  }
+  const lch = hexToOklch(normalizeHex(seedHex));
+  const base = lch.C < ACHROMATIC_C ? ANCHOR_HUE : lch.h;
+  const offsets = [0, 60, 120, 180, 240, 300, 30, 90, 150, 210, 270, 330];
+  const candidates = offsets.map(
+    (deg) => oklchToHex(clampToGamut({ L: CHART_L, C: CHART_C, h: (base + deg) % 360 }))
+  );
+  const picked = [];
+  for (const hex of candidates) {
+    if (picked.length >= count) break;
+    if (picked.includes(hex)) continue;
+    if (picked.every((p) => deltaEOK(p, hex) >= deltaMin)) picked.push(hex);
+  }
+  for (const hex of candidates) {
+    if (picked.length >= count) break;
+    if (!picked.includes(hex)) picked.push(hex);
+  }
+  return picked;
+}
+function derivePalette(seedHex, opts = {}) {
+  const withNames = opts.names !== false;
+  const seed = normalizeHex(seedHex);
+  const seedLch = hexToOklch(seed);
+  const achromatic = seedLch.C < ACHROMATIC_C;
+  const hue = achromatic ? ANCHOR_HUE : seedLch.h;
+  const neutralAt = (L, C) => oklchToHex(clampToGamut({ L, C, h: hue }));
+  const bg = neutralAt(0.985, 5e-3);
+  const surface = neutralAt(0.955, 8e-3);
+  const text = neutralAt(0.24, 0.012);
+  const neutral = neutralAt(0.62, 0.012);
+  const accentBase = achromatic ? oklchToHex(
+    clampToGamut({ L: Math.min(Math.max(seedLch.L, 0.45), 0.75), C: CHART_C, h: ANCHOR_HUE })
+  ) : seed;
+  const cands = ROTATIONS.map((deg) => {
+    const hex = rotateHue(accentBase, deg);
+    return { deg, hex, d: deltaEOK(seed, hex) };
+  });
+  let secondary = cands[0];
+  for (const c of cands) if (c.d > secondary.d) secondary = c;
+  let highlight = cands[0] === secondary ? cands[1] : cands[0];
+  let hiScore = Math.min(highlight.d, deltaEOK(highlight.hex, secondary.hex));
+  for (const c of cands) {
+    if (c === secondary || c === highlight) continue;
+    const score = Math.min(c.d, deltaEOK(c.hex, secondary.hex));
+    if (score > hiScore) {
+      highlight = c;
+      hiScore = score;
+    }
+  }
+  const status = (anchor) => {
+    const start = oklchToHex(clampToGamut({ L: STATUS_L, C: STATUS_C, h: anchor }));
+    return adjustLightnessUntil(start, (c) => contrastRatio(c, bg) >= 3, "darken") ?? text;
+  };
+  const sw = (role, hex, rationale) => ({
+    role,
+    hex,
+    rationale
+  });
+  const swatches = [
+    sw("primary", seed, "seed color"),
+    sw("secondary", secondary.hex, `harmony rotation ${secondary.deg}\xB0, \u0394EOK ${secondary.d.toFixed(3)} from primary`),
+    sw("highlight", highlight.hex, `harmony rotation ${highlight.deg}\xB0, spread from primary and secondary`),
+    sw("good", status(STATUS_HUES.good), "green anchor 145\xB0, \u22653:1 on bg"),
+    sw("warn", status(STATUS_HUES.warn), "amber anchor 85\xB0, \u22653:1 on bg"),
+    sw("danger", status(STATUS_HUES.danger), "red anchor 25\xB0, \u22653:1 on bg"),
+    sw("bg", bg, "near-white tinted with the seed hue"),
+    sw("surface", surface, "raised surface, one step below bg"),
+    sw("text", text, "near-black tinted with the seed hue"),
+    sw("neutral", neutral, "mid neutral for borders and muted marks"),
+    ...deriveChartColors(seed).map((hex, i) => sw("chart", hex, `chart series ${i + 1}`))
+  ];
+  return withNames ? swatches.map((s) => ({ ...s, name: nearestNamedColor(s.hex).name })) : swatches;
+}
+
+// src/tokens/roles.ts
+var BRAND_REQUIRED_TOKENS = [
+  "--ui-bg",
+  "--ui-surface",
+  "--ui-surface-2",
+  "--ui-text",
+  "--ui-text-muted",
+  "--ui-text-faint",
+  "--ui-border",
+  "--ui-border-strong",
+  "--ui-accent",
+  "--ui-accent-strong",
+  "--ui-accent-soft",
+  "--ui-on-accent",
+  "--ui-good",
+  "--ui-good-soft",
+  "--ui-warn",
+  "--ui-warn-soft",
+  "--ui-danger",
+  "--ui-danger-soft",
+  "--ui-code-bg",
+  "--ui-code-text",
+  "--ui-shadow",
+  "--ui-font-sans",
+  "--ui-font-serif",
+  "--ui-font-mono",
+  "--ui-font-display"
+];
+var BRAND_DERIVED_TOKENS = [
+  "--ui-accent-glow",
+  "--ui-accent-2",
+  "--ui-accent-2-soft",
+  "--ui-highlight",
+  "--ui-focus",
+  "--ui-shadow-strong"
+];
+var BRAND_CHART_TOKENS = [
+  "--ui-chart-1",
+  "--ui-chart-2",
+  "--ui-chart-3",
+  "--ui-chart-4",
+  "--ui-chart-5",
+  "--ui-chart-6",
+  "--ui-chart-band",
+  "--ui-chart-band-strong",
+  "--ui-chart-flow",
+  "--ui-chart-glow"
+];
+var BRAND_CHAT_TOKENS = [
+  "--ui-chat-user-bg",
+  "--ui-chat-user-text",
+  "--ui-chat-assistant-bg",
+  "--ui-chat-thinking-bg",
+  "--ui-chat-thinking-text",
+  "--ui-chat-tool-accent"
+];
+var BRAND_EMITTED_TOKENS = [
+  ...BRAND_REQUIRED_TOKENS,
+  ...BRAND_DERIVED_TOKENS,
+  ...BRAND_CHART_TOKENS,
+  ...BRAND_CHAT_TOKENS
+];
+
+// src/tokens/map.ts
+var DEFAULT_ACCENT_SEED = "#3b5e8c";
+var CHROMATIC_C = 0.02;
+var SANS_STACK = `ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif`;
+var SERIF_STACK = `"Iowan Old Style", "Palatino Linotype", Palatino, Georgia, serif`;
+var MONO_STACK = `ui-monospace, "SF Mono", Menlo, Consolas, monospace`;
+var DISPLAY_STACK = `ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, sans-serif`;
+var UI_CHART_DEFAULTS = [
+  "var(--ui-accent)",
+  "var(--ui-good)",
+  "var(--ui-warn)",
+  "var(--ui-danger)",
+  "color-mix(in srgb, var(--ui-accent) 45%, var(--ui-text))",
+  "var(--ui-text-faint)"
+];
+var ROLE_TOKEN = {
+  primary: "--ui-accent",
+  secondary: "--ui-accent-2",
+  highlight: "--ui-highlight",
+  bg: "--ui-bg",
+  surface: "--ui-surface",
+  text: "--ui-text",
+  neutral: "--ui-border-strong",
+  good: "--ui-good",
+  warn: "--ui-warn",
+  danger: "--ui-danger",
+  chart: "--ui-chart-1"
+};
+var mixVar = (name, pct) => `color-mix(in srgb, var(${name}) ${pct}%, transparent)`;
+function shiftL(hex, dL) {
+  const { L, C, h } = hexToOklch(hex);
+  return oklchToHex(clampToGamut({ L: clamp01(L + dL), C, h }));
+}
+function lerpL(fromHex, toHex2, t) {
+  const a2 = hexToOklch(fromHex);
+  const b = hexToOklch(toHex2);
+  return oklchToHex(clampToGamut({ L: a2.L + (b.L - a2.L) * t, C: a2.C, h: a2.h }));
+}
+function ensureOnBg(hex, bg, min) {
+  const pred = (c) => contrastRatio(c, bg) >= min;
+  const away = relativeLuminance(bg) >= relativeLuminance(hex) ? "darken" : "lighten";
+  return adjustLightnessUntil(hex, pred, away) ?? adjustLightnessUntil(hex, pred, away === "darken" ? "lighten" : "darken") ?? pickTextOn(bg);
+}
+var rgbaOf = (hex, alpha) => {
+  const { r, g, b } = parseHex(hex);
+  const c = (v) => Math.round(v * 255);
+  return `rgba(${c(r)}, ${c(g)}, ${c(b)}, ${alpha})`;
+};
+function fontValue(family, stack) {
+  const f = family?.trim() ?? "";
+  if (f === "") return stack;
+  if (f.includes(",") || /^["']/.test(f) || /^[a-zA-Z][a-zA-Z0-9-]*$/.test(f))
+    return `${f}, ${stack}`;
+  return `"${f.replaceAll('"', "")}", ${stack}`;
+}
+function collect(swatches, warnings) {
+  const byRole = {};
+  const charts = [];
+  if (!Array.isArray(swatches)) {
+    warnings.push({ token: "--ui-accent", message: "swatches is not an array; compiling from defaults" });
+    return { byRole, charts };
+  }
+  swatches.forEach((s, i) => {
+    let hex;
+    try {
+      hex = normalizeHex(String(s?.hex));
+    } catch {
+      warnings.push({
+        token: s?.role !== void 0 && ROLE_TOKEN[s.role] || "--ui-accent",
+        message: `swatches[${i}] dropped: invalid hex ${String(s?.hex)}`
+      });
+      return;
+    }
+    const role = s?.role;
+    if (role === "chart") charts.push(hex);
+    else if (role !== void 0 && role !== "custom" && byRole[role] === void 0) byRole[role] = hex;
+  });
+  return { byRole, charts };
+}
+function mapPaletteToTokens(input) {
+  const warnings = [];
+  const { byRole, charts } = collect(input?.swatches, warnings);
+  let accent = byRole.primary;
+  if (accent === void 0) {
+    const chromatic = [...Object.values(byRole), ...charts].find(
+      (h) => h !== void 0 && hexToOklch(h).C >= CHROMATIC_C
+    );
+    accent = chromatic ?? DEFAULT_ACCENT_SEED;
+    warnings.push({
+      token: "--ui-accent",
+      message: `no primary swatch; using ${chromatic !== void 0 ? "the first chromatic swatch" : "the neutral default seed"} ${accent}`
+    });
+  }
+  const fb = /* @__PURE__ */ new Map();
+  for (const s of derivePalette(accent, { names: false })) if (!fb.has(s.role)) fb.set(s.role, s.hex);
+  const pick = (role) => {
+    const own = byRole[role];
+    if (own !== void 0) return own;
+    const derived = fb.get(role);
+    warnings.push({ token: ROLE_TOKEN[role], message: `no ${role} swatch; derived ${derived} from ${accent}` });
+    return derived;
+  };
+  const bg = pick("bg");
+  const surface = pick("surface");
+  const neutral = pick("neutral");
+  const surface2 = shiftL(surface, -0.035);
+  const rawText = pick("text");
+  const text = ensureOnBg(rawText, bg, 4.5);
+  if (text !== rawText)
+    warnings.push({ token: "--ui-text", message: "adjusted to reach 4.5:1 on --ui-bg", adjustedFrom: rawText });
+  const accentStrong = ensureOnBg(accent, bg, 4.5);
+  if (accentStrong !== accent)
+    warnings.push({
+      token: "--ui-accent-strong",
+      message: "moved --ui-accent in lightness to reach 4.5:1 on --ui-bg",
+      adjustedFrom: accent
+    });
+  const status = (role) => {
+    const own = pick(role);
+    const fixed = ensureOnBg(own, bg, 3);
+    if (fixed !== own)
+      warnings.push({ token: ROLE_TOKEN[role], message: "adjusted to reach 3:1 on --ui-bg", adjustedFrom: own });
+    return fixed;
+  };
+  const chromaticCharts = charts.filter((h) => hexToOklch(h).C >= CHROMATIC_C);
+  let chartValues;
+  if (chromaticCharts.length >= 3) {
+    const picked = chromaticCharts.slice(0, 6);
+    for (const c of deriveChartColors(accent, { count: 12 })) {
+      if (picked.length >= 6) break;
+      if (!picked.includes(c)) picked.push(c);
+    }
+    chartValues = picked;
+  } else {
+    warnings.push({
+      token: "--ui-chart-1",
+      message: `fewer than 3 chromatic chart swatches (${chromaticCharts.length}); using the ui derived chart defaults`
+    });
+    chartValues = UI_CHART_DEFAULTS;
+  }
+  const secondary = byRole.secondary;
+  if (secondary === void 0)
+    warnings.push({ token: "--ui-accent-2", message: "no secondary swatch; --ui-accent-2 collapses onto var(--ui-accent) (ui default)" });
+  const highlight = byRole.highlight;
+  if (highlight === void 0)
+    warnings.push({ token: "--ui-highlight", message: "no highlight swatch; --ui-highlight aliases var(--ui-accent-strong) (ui default)" });
+  const t = input?.typography ?? {};
+  const tokens = {
+    "--ui-bg": bg,
+    "--ui-surface": surface,
+    "--ui-surface-2": surface2,
+    "--ui-text": text,
+    "--ui-text-muted": ensureOnBg(lerpL(text, bg, 0.35), bg, 4.5),
+    "--ui-text-faint": lerpL(text, bg, 0.58),
+    "--ui-border": lerpL(neutral, bg, 0.55),
+    "--ui-border-strong": neutral,
+    "--ui-accent": accent,
+    "--ui-accent-strong": accentStrong,
+    "--ui-accent-soft": mixVar("--ui-accent", 10),
+    "--ui-on-accent": pickTextOn(accent),
+    "--ui-good": status("good"),
+    "--ui-good-soft": mixVar("--ui-good", 12),
+    "--ui-warn": status("warn"),
+    "--ui-warn-soft": mixVar("--ui-warn", 12),
+    "--ui-danger": status("danger"),
+    "--ui-danger-soft": mixVar("--ui-danger", 10),
+    "--ui-code-bg": surface2,
+    "--ui-code-text": text,
+    "--ui-shadow": `0 1px 2px ${rgbaOf(text, 0.04)}, 0 8px 24px ${rgbaOf(text, 0.06)}`,
+    "--ui-font-sans": fontValue(t.fontBody, SANS_STACK),
+    "--ui-font-serif": SERIF_STACK,
+    "--ui-font-mono": fontValue(t.fontMono, MONO_STACK),
+    "--ui-font-display": fontValue(t.fontDisplay ?? t.fontBody, DISPLAY_STACK),
+    "--ui-accent-glow": mixVar("--ui-accent", 16),
+    "--ui-accent-2": secondary ?? "var(--ui-accent)",
+    "--ui-accent-2-soft": mixVar("--ui-accent-2", 10),
+    "--ui-highlight": highlight ?? "var(--ui-accent-strong)",
+    "--ui-focus": "0 0 0 3px var(--ui-accent-soft)",
+    "--ui-shadow-strong": "var(--ui-shadow)",
+    "--ui-chart-1": chartValues[0],
+    "--ui-chart-2": chartValues[1],
+    "--ui-chart-3": chartValues[2],
+    "--ui-chart-4": chartValues[3],
+    "--ui-chart-5": chartValues[4],
+    "--ui-chart-6": chartValues[5],
+    "--ui-chart-band": mixVar("--ui-accent", 10),
+    "--ui-chart-band-strong": mixVar("--ui-accent", 22),
+    "--ui-chart-flow": "var(--ui-accent)",
+    "--ui-chart-glow": "var(--ui-accent-strong)",
+    "--ui-chat-user-bg": "var(--ui-accent-soft)",
+    "--ui-chat-user-text": "var(--ui-text)",
+    "--ui-chat-assistant-bg": "var(--ui-surface)",
+    "--ui-chat-thinking-bg": "var(--ui-surface-2)",
+    "--ui-chat-thinking-text": "var(--ui-text-muted)",
+    "--ui-chat-tool-accent": "var(--ui-accent)"
+  };
+  return { tokens, warnings };
+}
+
+// src/tokens/dark.ts
+var DARK_FLIP_L_MIN = 0.2;
+var DARK_FLIP_L_MAX = 0.95;
+var DARK_SHADOW = "0 1px 2px rgba(0, 0, 0, 0.3), 0 8px 24px rgba(0, 0, 0, 0.35)";
+var HEX62 = /^#[0-9a-f]{6}$/;
+var NEUTRAL_FLIP = /* @__PURE__ */ new Set([
+  "--ui-bg",
+  "--ui-surface",
+  "--ui-surface-2",
+  "--ui-text",
+  "--ui-text-muted",
+  "--ui-text-faint",
+  "--ui-border",
+  "--ui-border-strong",
+  "--ui-code-bg",
+  "--ui-code-text"
+]);
+var MIN_RUNG = 0.02;
+var ACCENT_AA = [
+  "--ui-accent",
+  "--ui-accent-strong",
+  "--ui-accent-2",
+  "--ui-highlight",
+  "--ui-good",
+  "--ui-warn",
+  "--ui-danger"
+];
+var CHART_UI = [
+  "--ui-chart-1",
+  "--ui-chart-2",
+  "--ui-chart-3",
+  "--ui-chart-4",
+  "--ui-chart-5",
+  "--ui-chart-6"
+];
+function flipNeutral(hex) {
+  const { L, C, h } = hexToOklch(hex);
+  const flipped = DARK_FLIP_L_MIN + (1 - L) * (DARK_FLIP_L_MAX - DARK_FLIP_L_MIN);
+  return oklchToHex(clampToGamut({ L: flipped, C, h }));
+}
+function rebuildSurfaces(out, light, lightBgL, darkBgL) {
+  const lightSurface = light["--ui-surface"];
+  const lightSurface2 = light["--ui-surface-2"];
+  let surfaceDarkL;
+  let surfaceLightL = lightBgL;
+  if (lightSurface !== void 0 && HEX62.test(lightSurface)) {
+    const { L, C, h } = hexToOklch(lightSurface);
+    surfaceLightL = L;
+    surfaceDarkL = darkBgL + Math.max(Math.abs(L - lightBgL), MIN_RUNG);
+    out["--ui-surface"] = oklchToHex(clampToGamut({ L: surfaceDarkL, C, h }));
+  }
+  if (lightSurface2 !== void 0 && HEX62.test(lightSurface2)) {
+    const { L, C, h } = hexToOklch(lightSurface2);
+    const base = surfaceDarkL ?? darkBgL + MIN_RUNG;
+    const L2 = base + Math.max(Math.abs(L - surfaceLightL), MIN_RUNG);
+    out["--ui-surface-2"] = oklchToHex(clampToGamut({ L: L2, C, h }));
+  }
+  const lightCodeBg = light["--ui-code-bg"];
+  if (lightCodeBg !== void 0 && HEX62.test(lightCodeBg)) {
+    if (lightCodeBg === lightSurface2 && out["--ui-surface-2"] !== void 0) {
+      out["--ui-code-bg"] = out["--ui-surface-2"];
+    } else {
+      const { L, C, h } = hexToOklch(lightCodeBg);
+      const codeL = darkBgL + Math.max(Math.abs(L - lightBgL), MIN_RUNG);
+      out["--ui-code-bg"] = oklchToHex(clampToGamut({ L: codeL, C, h }));
+    }
+  }
+}
+function relight(hex, bg, min) {
+  const pred = (c) => contrastRatio(c, bg) >= min;
+  return adjustLightnessUntil(hex, pred, "lighten") ?? adjustLightnessUntil(hex, pred, "darken") ?? pickTextOn(bg);
+}
+function deriveDarkTokens(light) {
+  const out = {};
+  for (const [name, value] of Object.entries(light)) {
+    if (name === "--ui-shadow") out[name] = DARK_SHADOW;
+    else if (NEUTRAL_FLIP.has(name) && HEX62.test(value)) out[name] = flipNeutral(value);
+    else out[name] = value;
+  }
+  const bg = out["--ui-bg"];
+  const lightBg = light["--ui-bg"];
+  if (bg === void 0 || !HEX62.test(bg) || lightBg === void 0 || !HEX62.test(lightBg)) return out;
+  rebuildSurfaces(out, light, hexToOklch(lightBg).L, hexToOklch(bg).L);
+  for (const name of ["--ui-text", "--ui-text-muted"]) {
+    const v = out[name];
+    if (v !== void 0 && HEX62.test(v)) out[name] = relight(v, bg, 4.5);
+  }
+  const codeBg = out["--ui-code-bg"];
+  const codeText = out["--ui-code-text"];
+  if (codeText !== void 0 && HEX62.test(codeText))
+    out["--ui-code-text"] = relight(codeText, codeBg !== void 0 && HEX62.test(codeBg) ? codeBg : bg, 4.5);
+  for (const name of ACCENT_AA) {
+    const v = out[name];
+    if (v !== void 0 && HEX62.test(v)) out[name] = relight(v, bg, 4.5);
+  }
+  for (const name of CHART_UI) {
+    const v = out[name];
+    if (v !== void 0 && HEX62.test(v)) out[name] = relight(v, bg, 3);
+  }
+  const accent = out["--ui-accent"];
+  const onAccent = out["--ui-on-accent"];
+  if (accent !== void 0 && HEX62.test(accent) && onAccent !== void 0 && HEX62.test(onAccent))
+    out["--ui-on-accent"] = pickTextOn(accent);
+  return out;
+}
+
+// src/tokens/css.ts
+var HEADER = "/* Generated by @odla-ai/brand \u2014 @odla-ai/ui token overrides; pair with @odla-ai/ui css/tokens.css. */";
+var ORDER = new Map(
+  BRAND_EMITTED_TOKENS.map((name, i) => [name, i])
+);
+function orderedNames(tokens) {
+  return Object.keys(tokens).sort((a2, b) => {
+    const ia = ORDER.get(a2);
+    const ib = ORDER.get(b);
+    if (ia !== void 0 && ib !== void 0) return ia - ib;
+    if (ia !== void 0) return -1;
+    if (ib !== void 0) return 1;
+    return a2 < b ? -1 : a2 > b ? 1 : 0;
+  });
+}
+function renderBlock(selector, tokens, names, indent, lead) {
+  const lines = [];
+  if (lead !== void 0) lines.push(`${indent}  ${lead}`);
+  for (const name of names) lines.push(`${indent}  ${name}: ${tokens[name]};`);
+  if (lines.length === 0) return `${indent}${selector} {
+${indent}}`;
+  return `${indent}${selector} {
+${lines.join("\n")}
+${indent}}`;
+}
+function renderTokensCss(light, opts = {}) {
+  const selector = opts.selector ?? ":root";
+  const scoped = selector !== ":root";
+  const parts = [HEADER, renderBlock(selector, light, orderedNames(light), "")];
+  const dark = opts.dark;
+  if (dark !== void 0) {
+    const diffNames = orderedNames(dark).filter((name) => light[name] !== dark[name]);
+    if (diffNames.length > 0) {
+      const attrSelector = scoped ? `[data-theme="dark"] ${selector}, ${selector}[data-theme="dark"]` : `[data-theme="dark"]`;
+      const mediaSelector = scoped ? `:root:not([data-theme="light"]) ${selector}` : `:root:not([data-theme="light"])`;
+      parts.push(renderBlock(attrSelector, dark, diffNames, ""));
+      parts.push(
+        `@media (prefers-color-scheme: dark) {
+${renderBlock(mediaSelector, dark, diffNames, "  ")}
+}`
+      );
+    }
+    if (opts.includeInvert === true) {
+      parts.push(renderBlock(".ui-invert", dark, orderedNames(dark), "", "color-scheme: dark;"));
+    }
+  }
+  return `${parts.join("\n\n")}
+`;
+}
+
+// src/tokens/compile.ts
+var isRecord2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function applyOverrides(light, overrides, warnings) {
+  if (overrides === void 0) return;
+  if (!isRecord2(overrides)) {
+    warnings.push({ token: "--ui-accent", message: "overrides ignored: not an object" });
+    return;
+  }
+  for (const [name, value] of Object.entries(overrides)) {
+    if (!name.startsWith("--")) {
+      warnings.push({ token: name, message: "override ignored: token names must start with --" });
+      continue;
+    }
+    if (typeof value !== "string" || value.trim() === "") {
+      warnings.push({ token: name, message: "override ignored: value must be a non-empty string" });
+      continue;
+    }
+    light[name] = value.trim();
+  }
+}
+function compileBrandTokens(input) {
+  const { tokens: light, warnings } = mapPaletteToTokens(input);
+  applyOverrides(light, input?.overrides, warnings);
+  const dark = deriveDarkTokens(light);
+  return { light, dark, warnings };
+}
+
+// src/skill/asset-tools.ts
+var MAX_VIEW_BYTES = 4718592;
+var IMAGE_TYPES = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
+function base64FromBytes(bytes) {
+  if (typeof btoa === "function") {
+    let binary = "";
+    for (let i = 0; i < bytes.length; i += 8192) {
+      binary += String.fromCharCode(...bytes.subarray(i, i + 8192));
+    }
+    return btoa(binary);
+  }
+  return Buffer.from(bytes).toString("base64");
+}
+var bareType = (ct) => (ct.split(";")[0] ?? "").trim().toLowerCase();
+function viewOutput(asset, bytes, contentType) {
+  const caption = {
+    type: "text",
+    text: `Asset ${asset.id} (${asset.kind}, ${contentType}, ${bytes.byteLength} bytes${asset.title ? `, "${asset.title}"` : ""}):`
+  };
+  if (IMAGE_TYPES.has(contentType)) {
+    const image = {
+      type: "image",
+      source: { type: "base64", mediaType: contentType, data: base64FromBytes(bytes) }
+    };
+    return { content: [caption, image] };
+  }
+  const document = {
+    type: "document",
+    source: { type: "base64", mediaType: "application/pdf", data: base64FromBytes(bytes) }
+  };
+  return { content: [caption, document] };
+}
+function assetTools(ctx) {
+  const loadAsset = async (assetId) => {
+    const res = await ctx.db.query({
+      [BRAND_NS.asset]: { $: { where: { id: assetId, bookId: ctx.bookId } } }
+    });
+    const row = (res[BRAND_NS.asset] ?? [])[0];
+    if (!row || row.deletedAt) throw new BrandNotFoundError(`asset ${assetId}`);
+    return row;
+  };
+  const viewAsset = {
+    name: "view_asset",
+    description: "Look at an uploaded asset: fetches its bytes and returns the image (png/jpeg/gif/webp) or PDF for you to view. Other types cannot be viewed in-conversation.",
+    inputSchema: {
+      type: "object",
+      required: ["assetId"],
+      properties: { assetId: { type: "string", description: "The asset row id from list_assets." } }
+    },
+    outputTaint: ["tool_untrusted:view_asset"],
+    handler: ctx.guard(async (input) => {
+      const asset = await loadAsset(String(input.assetId));
+      if (!ctx.visionInToolResults) {
+        return {
+          content: `This model cannot take images inside tool results. Asset ${asset.id} must be attached as a pre-turn image by the host instead \u2014 ask the human to re-send their message referencing the asset (the dispatcher attaches it up front), or describe it from what they tell you.`
+        };
+      }
+      const url = asset.url.startsWith("http") ? asset.url : ctx.fileBaseUrl + asset.url;
+      const fetched = await ctx.fetchBytes(url);
+      if (fetched.bytes.byteLength > MAX_VIEW_BYTES) {
+        return {
+          content: `Asset ${asset.id} is ${fetched.bytes.byteLength} bytes \u2014 over the ${MAX_VIEW_BYTES}-byte (4.5 MB) in-conversation viewing cap. Ask the human for a smaller export of this file.`
+        };
+      }
+      const served = bareType(fetched.contentType);
+      const effective = IMAGE_TYPES.has(served) || served === "application/pdf" ? served : bareType(asset.contentType);
+      if (!IMAGE_TYPES.has(effective) && effective !== "application/pdf") {
+        return {
+          content: `Asset ${asset.id} is ${effective} \u2014 stored but not viewable in-conversation. Ask the human to describe it, or to upload a PNG/JPEG export you can view.`
+        };
+      }
+      return viewOutput(asset, fetched.bytes, effective);
+    })
+  };
+  const recordAnalysis = {
+    name: "record_asset_analysis",
+    description: "Record what you observed in an asset you viewed: a description, its dominant colors as #rrggbb hex, and tags. Overwrites any prior analysis.",
+    inputSchema: {
+      type: "object",
+      required: ["assetId", "description", "dominantColors", "tags"],
+      properties: {
+        assetId: { type: "string" },
+        description: { type: "string", description: "What the asset shows (max 2000 chars)." },
+        dominantColors: { type: "array", items: { type: "string" }, maxItems: 12, description: "Dominant colors as hex." },
+        tags: { type: "array", items: { type: "string" }, maxItems: 24 }
+      }
+    },
+    handler: ctx.guard(async (input) => {
+      const asset = await loadAsset(String(input.assetId));
+      const analysis = assertAnalysis({
+        description: input.description,
+        dominantColors: input.dominantColors,
+        tags: input.tags
+      });
+      await ctx.db.transact(recordAnalysisOps(asset.id, analysis, ctx.now()), { mutationId: ctx.newId() });
+      return {
+        content: `Recorded analysis for asset ${asset.id}: ${analysis.dominantColors.length} dominant color(s), ${analysis.tags.length} tag(s).`
+      };
+    })
+  };
+  return [viewAsset, recordAnalysis];
+}
+
+// src/skill/book-tools.ts
+function bookTools(ctx) {
+  const updateSection = {
+    name: "update_section",
+    description: "Create or replace one brand-book section (palette, typography, voice, logo, or imagery). Content is validated per kind. Status defaults to draft; a human approves.",
+    inputSchema: {
+      type: "object",
+      required: ["kind", "content"],
+      properties: {
+        kind: { type: "string", enum: [...SECTION_KINDS] },
+        content: { type: "object", description: "The section payload for its kind." },
+        status: { type: "string", enum: ["draft", "approved"] }
+      }
+    },
+    handler: ctx.guard(async (input) => {
+      const book = await ctx.loadBook();
+      const kind = String(input.kind);
+      const ops = upsertSectionOps({
+        bookId: ctx.bookId,
+        kind,
+        content: input.content,
+        status: input.status === void 0 ? void 0 : input.status,
+        audience: book.memberIds,
+        updatedBy: ctx.self.selfId,
+        now: ctx.now()
+      });
+      await ctx.db.transact(ops, { mutationId: ctx.newId() });
+      const status = input.status === void 0 ? "draft" : String(input.status);
+      return { content: `Saved ${kind} section as ${status} (key ${sectionKey(ctx.bookId, kind)}).` };
+    })
+  };
+  const compileTokens = {
+    name: "compile_tokens",
+    description: "Compile the book's palette (paletteId argument, or the active palette) plus the typography section into light/dark @odla-ai/ui tokens, cached on the book. Returns the compiler's warnings.",
+    inputSchema: {
+      type: "object",
+      properties: { paletteId: { type: "string", description: "Defaults to the book's active palette." } }
+    },
+    handler: ctx.guard(async (input) => {
+      const book = await ctx.loadBook();
+      const paletteId = input.paletteId === void 0 ? book.activePaletteId : capString(input.paletteId, "paletteId", 128);
+      if (!paletteId) {
+        throw new BrandInputError("no palette to compile: pass paletteId, or get a palette proposal accepted first");
+      }
+      const pres = await ctx.db.query({
+        [BRAND_NS.palette]: { $: { where: { id: paletteId, bookId: ctx.bookId } } }
+      });
+      const palette = (pres[BRAND_NS.palette] ?? [])[0];
+      if (!palette) throw new BrandNotFoundError(`palette ${paletteId}`);
+      const sres = await ctx.db.query({
+        [BRAND_NS.section]: { $: { where: { key: sectionKey(ctx.bookId, "typography") } } }
+      });
+      const typography = (sres[BRAND_NS.section] ?? [])[0];
+      const compiled = compileBrandTokens({
+        swatches: palette.swatches,
+        ...typography ? { typography: typography.content } : {}
+      });
+      const now = ctx.now();
+      const snapshot = {
+        light: compiled.light,
+        dark: compiled.dark,
+        warnings: compiled.warnings,
+        compiledAt: now
+      };
+      await ctx.db.transact(updateBookOps(ctx.bookId, { tokens: snapshot }, now), { mutationId: ctx.newId() });
+      const count = compiled.warnings.length;
+      const lines = [
+        `Compiled ${Object.keys(compiled.light).length} light + ${Object.keys(compiled.dark).length} dark tokens from palette ${paletteId}; ${count} warning(s).`,
+        ...compiled.warnings.slice(0, 3).map((w) => `- ${w.token}: ${w.message}${w.adjustedFrom ? ` (adjusted from ${w.adjustedFrom})` : ""}`)
+      ];
+      if (count > 3) lines.push(`\u2026 and ${count - 3} more.`);
+      return { content: lines.join("\n") };
+    })
+  };
+  return [updateSection, compileTokens];
+}
+
+// src/skill/palette-tools.ts
+var r2 = (n) => n.toFixed(2);
+var pf = (ok) => ok ? "pass" : "FAIL";
+var verdict = (ratio) => `${r2(ratio)}:1 \u2014 AA text ${pf(meetsAA(ratio))}, AA large/ui ${pf(meetsAA(ratio, "large-text"))}, AAA text ${pf(meetsAAA(ratio))}`;
+var HARMONY_COMPANIONS = {
+  complementary: (s) => [complementary(s)],
+  analogous: (s) => [...analogous(s)],
+  triadic: (s) => [...triadic(s)],
+  split: (s) => [...splitComplementary(s)],
+  tetradic: (s) => tetradic(s).slice(0, 2),
+  monochrome: (s) => monochrome(s, 4).slice(1, 3)
+};
+function applyHarmony(swatches, seedHex, harmony) {
+  if (typeof harmony !== "string" || !(harmony in HARMONY_COMPANIONS)) {
+    throw new BrandInputError(`harmony must be one of: ${Object.keys(HARMONY_COMPANIONS).join(", ")}`);
+  }
+  const [secondary, highlight] = HARMONY_COMPANIONS[harmony](seedHex);
+  return swatches.map((s) => {
+    const hex = s.role === "secondary" ? secondary : s.role === "highlight" ? highlight : void 0;
+    if (!hex) return s;
+    return { ...s, hex, name: nearestNamedColor(hex).name, rationale: `${harmony} companion of the seed` };
+  });
+}
+function contrastReport(swatches) {
+  const byRole = (role) => swatches.find((s) => s.role === role)?.hex;
+  const bg = byRole("bg") ?? "#ffffff";
+  const report = {};
+  const put = (label, fg) => {
+    if (fg) report[label] = Math.round(contrastRatio(fg, bg) * 100) / 100;
+  };
+  put("text-on-bg", byRole("text"));
+  put("primary-on-bg", byRole("primary"));
+  put("good-on-bg", byRole("good"));
+  put("warn-on-bg", byRole("warn"));
+  put("danger-on-bg", byRole("danger"));
+  const primary = byRole("primary");
+  if (primary) report["text-on-primary"] = Math.round(contrastRatio(pickTextOn(primary), primary) * 100) / 100;
+  return report;
+}
+var INCLUDE_SECTIONS = ["harmony", "ramp"];
+function analyzeLines(hex, include) {
+  const lch = hexToOklch(hex);
+  const named = nearestNamedColor(hex);
+  const lines = [
+    `${hex} \u2014 nearest CSS name: ${named.name} (\u0394EOK ${named.deltaEOK.toFixed(3)})`,
+    `OKLCH: L ${lch.L.toFixed(3)}, C ${lch.C.toFixed(3)}, h ${lch.h.toFixed(1)}\xB0`,
+    `relative luminance ${relativeLuminance(hex).toFixed(3)}; contrast ${r2(contrastRatio(hex, "#ffffff"))}:1 on white, ${r2(contrastRatio(hex, "#000000"))}:1 on black`,
+    `readable text on it: ${pickTextOn(hex)}`
+  ];
+  if (include.includes("harmony")) {
+    const [aMinus, aPlus] = analogous(hex);
+    const [tMinus, tPlus] = triadic(hex);
+    const [sMinus, sPlus] = splitComplementary(hex);
+    lines.push(
+      `harmony \u2014 complementary ${complementary(hex)}; analogous ${aMinus} ${aPlus}; triadic ${tMinus} ${tPlus}; split ${sMinus} ${sPlus}`
+    );
+  }
+  if (include.includes("ramp")) lines.push(`ramp \u2014 ${tintShadeRamp(hex).join(" ")}`);
+  return lines;
+}
+function paletteTools(ctx) {
+  const analyzeColor = {
+    name: "analyze_color",
+    description: "Analyze one color: nearest CSS name, OKLCH coordinates, luminance, contrast on white/black. Optionally include harmony companions and a tint/shade ramp.",
+    inputSchema: {
+      type: "object",
+      required: ["hex"],
+      properties: {
+        hex: { type: "string", description: "#rgb or #rrggbb" },
+        include: { type: "array", items: { type: "string", enum: [...INCLUDE_SECTIONS] } }
+      }
+    },
+    handler: ctx.guard(async (input) => {
+      const hex = assertHex(input.hex, "hex");
+      const include = input.include === void 0 ? [] : input.include;
+      if (!Array.isArray(include) || include.some((s) => !INCLUDE_SECTIONS.includes(s))) {
+        throw new BrandInputError(`include entries must be one of: ${INCLUDE_SECTIONS.join(", ")}`);
+      }
+      return { content: analyzeLines(hex, include).join("\n") };
+    })
+  };
+  const evaluateContrast = {
+    name: "evaluate_contrast",
+    description: "WCAG 2.1 contrast: pass pairs ([{fg,bg}]) for specific combinations, or hexes ([\u2026]) for every pairwise ratio. Reports AA/AAA verdicts.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pairs: {
+          type: "array",
+          maxItems: 20,
+          items: { type: "object", required: ["fg", "bg"], properties: { fg: { type: "string" }, bg: { type: "string" } } }
+        },
+        hexes: { type: "array", minItems: 2, maxItems: 8, items: { type: "string" } }
+      }
+    },
+    handler: ctx.guard(async (input) => {
+      if (Array.isArray(input.pairs) && input.pairs.length > 0) {
+        if (input.pairs.length > 20) throw new BrandInputError("pairs must have at most 20 entries");
+        const lines = input.pairs.map((raw, i) => {
+          const p = raw ?? {};
+          const fg = assertHex(p.fg, `pairs[${i}].fg`);
+          const bg = assertHex(p.bg, `pairs[${i}].bg`);
+          return `${fg} on ${bg}: ${verdict(contrastRatio(fg, bg))}`;
+        });
+        return { content: lines.join("\n") };
+      }
+      if (Array.isArray(input.hexes)) {
+        if (input.hexes.length < 2 || input.hexes.length > 8) {
+          throw new BrandInputError("hexes must have 2 to 8 entries");
+        }
+        const hexes = input.hexes.map((h, i) => assertHex(h, `hexes[${i}]`));
+        const lines = [];
+        for (let i = 0; i < hexes.length; i++) {
+          for (let j = i + 1; j < hexes.length; j++) {
+            lines.push(`${hexes[i]} vs ${hexes[j]}: ${verdict(contrastRatio(hexes[i], hexes[j]))}`);
+          }
+        }
+        return { content: lines.join("\n") };
+      }
+      throw new BrandInputError("provide pairs ([{fg,bg}, \u2026]) or hexes ([#rrggbb, \u2026])");
+    })
+  };
+  const proposePalette = {
+    name: "propose_palette",
+    description: "Park a palette proposal for human review (does NOT change the brand). Pass explicit swatches, or a seedHex (and optional harmony) to derive a full palette. A WCAG contrast report is attached automatically.",
+    inputSchema: {
+      type: "object",
+      required: ["name", "rationale"],
+      properties: {
+        name: { type: "string" },
+        rationale: { type: "string", description: "Why these colors \u2014 cite assets, harmony, contrast." },
+        seedHex: { type: "string" },
+        harmony: { type: "string", enum: Object.keys(HARMONY_COMPANIONS) },
+        swatches: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["role", "hex"],
+            properties: {
+              role: { type: "string" },
+              hex: { type: "string" },
+              name: { type: "string" },
+              rationale: { type: "string" }
+            }
+          }
+        }
+      }
+    },
+    handler: ctx.guard(async (input) => {
+      const book = await ctx.loadBook();
+      const seedHex = input.seedHex === void 0 ? void 0 : assertHex(input.seedHex, "seedHex");
+      let swatches;
+      if (input.swatches !== void 0) {
+        swatches = assertSwatches(input.swatches);
+      } else {
+        if (!seedHex) throw new BrandInputError("provide swatches, or a seedHex to derive a palette from");
+        swatches = derivePalette(seedHex);
+        if (input.harmony !== void 0) swatches = applyHarmony(swatches, seedHex, input.harmony);
+      }
+      const report = contrastReport(swatches);
+      const id = ctx.newId();
+      const ops = proposePaletteOps({
+        id,
+        bookId: ctx.bookId,
+        name: String(input.name),
+        rationale: String(input.rationale),
+        swatches,
+        seedHex,
+        contrastReport: report,
+        createdBy: ctx.self.selfId,
+        audience: book.memberIds,
+        now: ctx.now()
+      });
+      await ctx.db.transact(ops, { mutationId: id });
+      const reportText = Object.entries(report).map(([k, v]) => `${k} ${r2(v)}:1`).join(", ");
+      return {
+        content: `Parked palette proposal ${id} ("${String(input.name).trim()}", ${swatches.length} swatches${seedHex ? `, seeded from ${seedHex}` : ""}). Contrast: ${reportText}. Awaiting explicit human approval \u2014 call resolve_proposal only after the human confirms.`
+      };
+    })
+  };
+  const resolveProposal = {
+    name: "resolve_proposal",
+    description: "Apply the human's explicit verdict on an open proposal. ONLY call this after the human has clearly accepted or rejected in the conversation \u2014 never on your own initiative.",
+    inputSchema: {
+      type: "object",
+      required: ["proposalId", "resolution"],
+      properties: {
+        proposalId: { type: "string" },
+        resolution: { type: "string", enum: ["accepted", "rejected"] },
+        note: { type: "string" }
+      }
+    },
+    handler: ctx.guard(async (input) => {
+      const proposalId = String(input.proposalId);
+      const res = await ctx.db.query({
+        [BRAND_NS.proposal]: { $: { where: { id: proposalId, bookId: ctx.bookId } } }
+      });
+      const proposal = (res[BRAND_NS.proposal] ?? [])[0];
+      if (!proposal) throw new BrandNotFoundError(`proposal ${proposalId}`);
+      const note = input.note === void 0 ? void 0 : capString(input.note, "note", 1e3);
+      const now = ctx.now();
+      if (input.resolution === "accepted") {
+        const paletteId = ctx.newId();
+        const ops = acceptProposalOps({ proposal, paletteId, resolvedBy: ctx.self.selfId, now, resolutionNote: note });
+        await ctx.db.transact(ops, { mutationId: paletteId });
+        return { content: `Proposal ${proposalId} accepted \u2014 palette ${paletteId} written and set as the book's active palette.` };
+      }
+      if (input.resolution === "rejected") {
+        const ops = rejectProposalOps({ proposal, resolvedBy: ctx.self.selfId, now, resolutionNote: note });
+        await ctx.db.transact(ops, { mutationId: ctx.newId() });
+        return { content: `Proposal ${proposalId} rejected.` };
+      }
+      throw new BrandInputError('resolution must be "accepted" or "rejected"');
+    })
+  };
+  return [analyzeColor, evaluateContrast, proposePalette, resolveProposal];
+}
+
+// src/skill/read-tools.ts
+var iso = (ms) => new Date(ms).toISOString();
+function bookLines(book) {
+  const lines = [
+    `brand book "${book.name}" (${book.slug}) \u2014 ${book.status}`,
+    `members: ${book.memberIds.join(", ")}`,
+    `active palette: ${book.activePaletteId ?? "(none accepted yet)"}`,
+    book.tokens ? `tokens: compiled ${iso(book.tokens.compiledAt)} with ${book.tokens.warnings.length} warning(s)` : "tokens: (not compiled)"
+  ];
+  if (book.summary) lines.push(`summary: ${book.summary}`);
+  return lines;
+}
+function childLines(sections, palettes, proposals) {
+  return [
+    "sections:",
+    ...sections.length ? sections.map((s) => `- ${s.kind}: ${s.status}, updated ${iso(s.updatedAt)} by ${s.updatedBy}`) : ["- (none)"],
+    "palettes:",
+    ...palettes.length ? palettes.map((p) => `- ${p.id} "${p.name}" (${p.status}, ${p.source}, ${p.swatches.length} swatches)`) : ["- (none)"],
+    "open proposals:",
+    ...proposals.length ? proposals.map((p) => `- ${p.id} (${p.kind}) by ${p.createdBy}: ${p.rationale}`) : ["- (none)"]
+  ];
+}
+function readTools(ctx) {
+  const readBrandBook = {
+    name: "read_brand_book",
+    description: "Read the current brand book: status, members, active palette, compiled tokens, sections, palettes, and open proposals.",
+    inputSchema: { type: "object", properties: {} },
+    handler: ctx.guard(async () => {
+      const res = await ctx.db.query({
+        [BRAND_NS.book]: { $: { where: { id: ctx.bookId } } },
+        [BRAND_NS.section]: { $: { where: { bookId: ctx.bookId }, order: { updatedAt: "asc" } } },
+        [BRAND_NS.palette]: { $: { where: { bookId: ctx.bookId }, order: { createdAt: "asc" } } },
+        [BRAND_NS.proposal]: { $: { where: { bookId: ctx.bookId, status: "open" }, order: { createdAt: "asc" } } }
+      });
+      const book = (res[BRAND_NS.book] ?? [])[0];
+      if (!book) throw new BrandNotFoundError(`brand book ${ctx.bookId}`);
+      const sections = res[BRAND_NS.section] ?? [];
+      const palettes = res[BRAND_NS.palette] ?? [];
+      const proposals = res[BRAND_NS.proposal] ?? [];
+      return { content: [...bookLines(book), ...childLines(sections, palettes, proposals)].join("\n") };
+    })
+  };
+  const listAssets = {
+    name: "list_assets",
+    description: "List the book's uploaded assets (id, kind, content type, size, title, analysis state). Tombstoned assets are excluded.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        kind: { type: "string", enum: [...ASSET_KINDS], description: "Only assets of this kind." }
+      }
+    },
+    handler: ctx.guard(async (input) => {
+      const where = { bookId: ctx.bookId };
+      if (input.kind !== void 0) {
+        if (typeof input.kind !== "string" || !ASSET_KINDS.includes(input.kind)) {
+          throw new BrandInputError(`kind must be one of: ${ASSET_KINDS.join(", ")}`);
+        }
+        where.kind = input.kind;
+      }
+      const res = await ctx.db.query({ [BRAND_NS.asset]: { $: { where, order: { createdAt: "asc" } } } });
+      const rows = (res[BRAND_NS.asset] ?? []).filter((a2) => !a2.deletedAt);
+      if (rows.length === 0) {
+        return { content: input.kind ? `(no ${String(input.kind)} assets uploaded yet)` : "(no assets uploaded yet)" };
+      }
+      const lines = rows.map(
+        (a2) => `${a2.id} \u2014 ${a2.kind}, ${a2.contentType}, ${a2.size} bytes${a2.title ? `, "${a2.title}"` : ""}${a2.analysis ? " (analyzed)" : " (not analyzed)"}`
+      );
+      return { content: lines.join("\n") };
+    })
+  };
+  return [readBrandBook, listAssets];
+}
+
+// src/skill/skill.ts
+var BRAND_INSTRUCTIONS = "You help build and maintain ONE brand book. Workflow, in order:\n1. Understand the brand first: read_brand_book and list_assets before proposing anything.\n2. Look at the real material: view_asset on logos and inspiration, then record what you saw with record_asset_analysis (description, dominant colors as hex, tags).\n3. Explore with the math tools: analyze_color and evaluate_contrast. Never invent a hex without a rationale \u2014 ground every color in an asset's dominant color, a harmony companion, or a contrast fix, and say which.\n4. propose_palette parks a proposal for review. It does NOT change the brand.\n5. WAIT for the human to explicitly accept or reject in the conversation before calling resolve_proposal \u2014 never resolve a proposal on your own initiative.\n6. After acceptance, document the rest with update_section (typography, voice, logo, imagery) and run compile_tokens.\n7. Relay compile warnings conversationally \u2014 explain what was adjusted and why, don't just paste them.";
+function brandSkill(opts) {
+  const deps = resolveDeps({ db: opts.db, now: opts.now, newId: opts.newId, fetchBytes: opts.fetchBytes });
+  const ctx = {
+    db: deps.db,
+    bookId: opts.bookId,
+    self: opts.self,
+    fileBaseUrl: opts.fileBaseUrl,
+    fetchBytes: deps.fetchBytes,
+    visionInToolResults: opts.visionInToolResults !== false,
+    now: deps.now,
+    newId: deps.newId,
+    loadBook: async () => {
+      const res = await deps.db.query({ [BRAND_NS.book]: { $: { where: { id: opts.bookId } } } });
+      const row = (res[BRAND_NS.book] ?? [])[0];
+      if (!row) throw new BrandNotFoundError(`brand book ${opts.bookId}`);
+      return row;
+    },
+    guard: (handler) => async (input, toolCtx) => {
+      try {
+        return await handler(input, toolCtx);
+      } catch (error) {
+        if (error instanceof BrandInputError || error instanceof BrandNotFoundError) {
+          return { content: error.message, isError: true };
+        }
+        throw error;
+      }
+    }
+  };
+  return {
+    name: "brand",
+    instructions: BRAND_INSTRUCTIONS,
+    tools: [...readTools(ctx), ...assetTools(ctx), ...paletteTools(ctx), ...bookTools(ctx)]
+  };
+}
+
+// src/skill/persona.ts
+var DEFAULT_BRAND_SYSTEM = "You are a meticulous brand director for one brand book. You study the real material before forming opinions, you justify every color with math (harmony, \u0394EOK, WCAG contrast) or provenance (an asset's dominant colors), and you present options rather than dictating. Proposals are yours to make; decisions are the human's \u2014 never resolve a proposal without their explicit confirmation in this conversation. When tokens compile with warnings, explain each adjustment in plain language.";
+function createBrandPersona(opts) {
+  return {
+    name: "brand-director",
+    model: opts.model,
+    system: opts.system ?? DEFAULT_BRAND_SYSTEM,
+    webSearch: opts.webSearch ?? true,
+    maxSteps: opts.maxSteps ?? 10,
+    skills: [brandSkill(opts.brand), ...opts.skills ?? []]
+  };
+}
+function supportsBrandVision(spec) {
+  const caps = spec?.capabilities;
+  return !!(caps?.toolResultBlocks && caps.imageIn && caps.documentIn);
+}
+
+// src/routes/http.ts
+var json = (body, status = 200, headers = {}) => new Response(JSON.stringify(body), {
+  status,
+  headers: { "content-type": "application/json", ...headers }
+});
+var errorResponse = (error) => {
+  if (error instanceof BrandInputError)
+    return json({ error: error.message, ...error.fields ? { fields: error.fields } : {} }, 400);
+  if (error instanceof BrandNotFoundError) return json({ error: error.message }, 404);
+  return json({ error: "internal error" }, 500);
+};
+var methodNotAllowed = () => json({ error: "method not allowed" }, 405);
+async function readJson(req) {
+  let body;
+  try {
+    body = await req.json();
+  } catch {
+    throw new BrandInputError("invalid JSON body");
+  }
+  if (typeof body !== "object" || body === null || Array.isArray(body))
+    throw new BrandInputError("body must be a JSON object");
+  return body;
+}
+function str(body, key) {
+  const value = body[key];
+  if (typeof value !== "string" || value === "")
+    throw new BrandInputError(`"${key}" must be a non-empty string`);
+  return value;
+}
+function optStr(body, key) {
+  const value = body[key];
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string") throw new BrandInputError(`"${key}" must be a string`);
+  return value;
+}
+function optStrArray(body, key) {
+  const value = body[key];
+  if (value === void 0 || value === null) return void 0;
+  if (!Array.isArray(value) || value.some((v) => typeof v !== "string"))
+    throw new BrandInputError(`"${key}" must be an array of strings`);
+  return value;
+}
+function isMember(book, actorId) {
+  return Array.isArray(book.memberIds) && book.memberIds.includes(actorId);
+}
+async function loadBook(db, bookId) {
+  const res = await db.query({ [BRAND_NS.book]: { $: { where: { id: bookId } } } });
+  const row = (res[BRAND_NS.book] ?? [])[0];
+  if (!row) throw new BrandNotFoundError(`brand book ${bookId}`);
+  return row;
+}
+async function loadMemberBook(db, bookId, actorId) {
+  const book = await loadBook(db, bookId);
+  if (!isMember(book, actorId)) throw new BrandNotFoundError(`brand book ${bookId}`);
+  return book;
+}
+
+// src/routes/assets.ts
+async function readForm(req) {
+  try {
+    return await req.formData();
+  } catch {
+    throw new BrandInputError('expected a multipart/form-data body with a "file" field');
+  }
+}
+async function uploadAsset(ctx, req, bookId) {
+  const book = await loadMemberBook(ctx.db, bookId, ctx.actor.id);
+  const form = await readForm(req);
+  const file = form.get("file");
+  if (!(file instanceof File)) throw new BrandInputError('"file" must be an uploaded file field');
+  let contentType;
+  try {
+    contentType = assertAssetContentType(file.type);
+  } catch (error) {
+    if (error instanceof BrandInputError) return json({ error: error.message }, 415);
+    throw error;
+  }
+  if (file.size > ctx.maxUploadBytes)
+    return json(
+      { error: `file is ${file.size} bytes; the upload limit is ${ctx.maxUploadBytes}` },
+      413
+    );
+  const kindRaw = form.get("kind");
+  const kind = typeof kindRaw === "string" && kindRaw !== "" ? kindRaw : "other";
+  if (!ASSET_KINDS.includes(kind))
+    throw new BrandInputError(`kind must be one of: ${ASSET_KINDS.join(", ")}`);
+  const titleRaw = form.get("title");
+  const title = typeof titleRaw === "string" && titleRaw !== "" ? capString(titleRaw, "title", 160) : void 0;
+  const id = ctx.newId();
+  const path = `brand/${book.id}/assets/${id}/${safeFileName(file.name)}`;
+  const record = await ctx.db.storage.upload(path, file, contentType);
+  await ctx.db.transact(
+    createAssetOps({
+      id,
+      bookId: book.id,
+      kind,
+      path: record.path,
+      url: record.url,
+      contentType,
+      size: record.size,
+      uploadedBy: ctx.actor.id,
+      audience: book.memberIds,
+      title,
+      now: ctx.now()
+    }),
+    { mutationId: id }
+  );
+  const res = await ctx.db.query({ [BRAND_NS.asset]: { $: { where: { id } } } });
+  return json((res[BRAND_NS.asset] ?? [])[0], 201);
+}
+async function handleAssetsRoot(ctx, req, bookId) {
+  if (req.method === "GET") {
+    const book = await loadMemberBook(ctx.db, bookId, ctx.actor.id);
+    const res = await ctx.db.query({
+      [BRAND_NS.asset]: {
+        // `deletedAt: null` matches ONLY rows without the attr — odla-db's
+        // "absence is a missing triple" semantics — i.e. not tombstoned.
+        $: { where: { bookId: book.id, deletedAt: null }, order: { createdAt: "asc" } }
+      }
+    });
+    return json({ assets: res[BRAND_NS.asset] ?? [] });
+  }
+  if (req.method === "POST") return uploadAsset(ctx, req, bookId);
+  return methodNotAllowed();
+}
+async function handleAssetItem(ctx, req, bookId, assetId) {
+  if (req.method !== "DELETE") return methodNotAllowed();
+  const book = await loadMemberBook(ctx.db, bookId, ctx.actor.id);
+  const res = await ctx.db.query({
+    [BRAND_NS.asset]: { $: { where: { id: assetId, bookId: book.id } } }
+  });
+  const asset = (res[BRAND_NS.asset] ?? [])[0];
+  if (!asset || asset.deletedAt != null) throw new BrandNotFoundError(`asset ${assetId}`);
+  await ctx.db.storage.delete(asset.path);
+  const deletedAt = ctx.now();
+  await ctx.db.transact(tombstoneAssetOps(asset.id, deletedAt));
+  return json({ id: asset.id, deletedAt });
+}
+
+// src/routes/books.ts
+async function handleBooksRoot(ctx, req) {
+  if (req.method === "GET") {
+    const res = await ctx.db.query({ [BRAND_NS.book]: { $: { order: { createdAt: "asc" } } } });
+    const books = (res[BRAND_NS.book] ?? []).filter(
+      (b) => isMember(b, ctx.actor.id)
+    );
+    return json({ books });
+  }
+  if (req.method === "POST") {
+    const body = await readJson(req);
+    const id = ctx.newId();
+    const ops = createBookOps({
+      id,
+      slug: str(body, "slug"),
+      name: str(body, "name"),
+      ownerId: ctx.actor.id,
+      memberIds: optStrArray(body, "memberIds") ?? [],
+      channelId: optStr(body, "channelId"),
+      now: ctx.now()
+    });
+    await ctx.db.transact(ops, { mutationId: id });
+    return json(await loadBook(ctx.db, id), 201);
+  }
+  return methodNotAllowed();
+}
+async function handleBookItem(ctx, req, bookId) {
+  if (req.method !== "GET") return methodNotAllowed();
+  return json(await loadMemberBook(ctx.db, bookId, ctx.actor.id));
+}
+
+// src/routes/tokens.ts
+var isRecord3 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+async function resolveTokenMaps(db, book) {
+  const cache = book.tokens;
+  if (cache && isRecord3(cache.light) && isRecord3(cache.dark))
+    return { light: cache.light, dark: cache.dark };
+  if (!book.activePaletteId) throw new BrandNotFoundError(`compiled tokens for brand book ${book.id}`);
+  const pres = await db.query({
+    [BRAND_NS.palette]: { $: { where: { id: book.activePaletteId } } }
+  });
+  const palette = (pres[BRAND_NS.palette] ?? [])[0];
+  if (!palette) throw new BrandNotFoundError(`compiled tokens for brand book ${book.id}`);
+  const sres = await db.query({
+    [BRAND_NS.section]: { $: { where: { key: `${book.id}:typography` } } }
+  });
+  const typography = (sres[BRAND_NS.section] ?? [])[0]?.content;
+  const compiled = compileBrandTokens({ swatches: palette.swatches, typography });
+  return { light: compiled.light, dark: compiled.dark };
+}
+async function handleTokens(db, req, bookId, which, actor) {
+  if (req.method !== "GET") return methodNotAllowed();
+  const book = actor === null ? await loadBook(db, bookId) : await loadMemberBook(db, bookId, actor.id);
+  const maps = await resolveTokenMaps(db, book);
+  if (which === "tokens.json") return json({ light: maps.light, dark: maps.dark });
+  const etag = `"brand-tokens-${book.updatedAt}"`;
+  const inm = req.headers.get("if-none-match");
+  if (inm && inm.split(",").map((v) => v.trim()).includes(etag))
+    return new Response(null, { status: 304, headers: { etag } });
+  return new Response(renderTokensCss(maps.light, { dark: maps.dark }), {
+    status: 200,
+    headers: { "content-type": "text/css; charset=utf-8", etag }
+  });
+}
+
+// src/routes/index.ts
+var tokensFile = (seg) => seg.length === 3 && seg[0] === "books" && (seg[2] === "tokens.css" || seg[2] === "tokens.json") ? seg[2] : null;
+async function route(ctx, req, seg) {
+  const [head, id, sub, subId] = seg;
+  if (head !== "books") return null;
+  if (seg.length === 1) return handleBooksRoot(ctx, req);
+  if (seg.length === 2) return handleBookItem(ctx, req, id);
+  if (sub === "assets") {
+    if (seg.length === 3) return handleAssetsRoot(ctx, req, id);
+    if (seg.length === 4) return handleAssetItem(ctx, req, id, subId);
+    return null;
+  }
+  const file = tokensFile(seg);
+  if (file) return handleTokens(ctx.db, req, id, file, ctx.actor);
+  return null;
+}
+function createBrandRoutes(options) {
+  const basePath = options.basePath ?? "/api/brand";
+  const publicTokens = options.publicTokens === true;
+  const base = {
+    db: options.db,
+    now: options.now ?? Date.now,
+    newId: options.newId ?? (() => crypto.randomUUID()),
+    maxUploadBytes: options.maxUploadBytes ?? 8 * 1024 * 1024
+  };
+  return async (req) => {
+    const url = new URL(req.url);
+    if (url.pathname !== basePath && !url.pathname.startsWith(`${basePath}/`)) return null;
+    const seg = url.pathname.slice(basePath.length).split("/").filter(Boolean);
+    try {
+      const file = tokensFile(seg);
+      if (publicTokens && file) return await handleTokens(base.db, req, seg[1], file, null);
+      const actor = await options.authorize(req);
+      if (!actor) return json({ error: "unauthorized" }, 401);
+      return await route({ ...base, actor }, req, seg) ?? json({ error: "not found" }, 404);
+    } catch (error) {
+      return errorResponse(error);
+    }
+  };
+}
+
+// src/triggers.ts
+var CHAT_MESSAGE_NS = "chat_message";
+var celString = (value) => value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+function brandBotTrigger(opts) {
+  const clauses = ['data.authorKind == "human"'];
+  if (opts.mention) clauses.push(`data.body.contains("${celString(opts.mention)}")`);
+  if (opts.when) clauses.push(`(${opts.when})`);
+  return {
+    id: opts.id,
+    watch: { ns: CHAT_MESSAGE_NS, on: opts.on ?? "create" },
+    when: clauses.join(" && "),
+    runAs: { agentId: opts.agentId, persona: opts.persona },
+    skill: "brand",
+    maxDepth: 1,
+    ...opts.channels ? { channels: opts.channels } : {}
+  };
+}
+
+// src/dispatch.ts
+function parseBrandDispatch(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const b = raw;
+  const t = b.trigger;
+  const e = b.event;
+  if (typeof b.appId !== "string" || !b.appId) return null;
+  if (!t || typeof t.runAs?.agentId !== "string" || typeof t.runAs?.persona !== "string") return null;
+  if (!e || typeof e.id !== "string" || !e.row || typeof e.row !== "object") return null;
+  return {
+    v: typeof b.v === "number" ? b.v : 1,
+    appId: b.appId,
+    trigger: {
+      id: typeof t.id === "string" ? t.id : "",
+      skill: typeof t.skill === "string" ? t.skill : "",
+      runAs: { agentId: t.runAs.agentId, persona: t.runAs.persona },
+      ...typeof t.maxDepth === "number" ? { maxDepth: t.maxDepth } : {}
+    },
+    event: { ns: typeof e.ns === "string" ? e.ns : CHAT_MESSAGE_NS, id: e.id, row: e.row }
+  };
+}
+async function bookForChannel(db, channelId) {
+  if (!channelId) return null;
+  const res = await db.query({ [BRAND_NS.book]: { $: { where: { channelId } } } });
+  return (res[BRAND_NS.book] ?? [])[0] ?? null;
+}
+function brandInputFor(body, attachments) {
+  const row = body.event.row;
+  const prompt = `A new message arrived in this brand book's channel from ${String(row.authorId ?? "someone")}: "${String(row.body ?? "")}". Ground yourself first (read_brand_book, list_assets), then move the brand work forward: study the material, justify colors with the math tools, and park palette ideas as proposals \u2014 a human must explicitly approve before you resolve or compile. If you reply in chat, keep it concise.`;
+  return attachments?.length ? [...attachments, { type: "text", text: prompt }] : prompt;
+}
+var PRETURN_IMAGE_TYPES = /* @__PURE__ */ new Set([
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp"
+]);
+async function assetBlocksFor(db, fileBaseUrl, raw) {
+  if (!Array.isArray(raw)) return [];
+  const ids = raw.filter((v) => typeof v === "string");
+  if (ids.length === 0) return [];
+  const res = await db.query({ [BRAND_NS.asset]: { $: { where: { id: { $in: ids } } } } });
+  const byId = new Map((res[BRAND_NS.asset] ?? []).map((a2) => [a2.id, a2]));
+  const blocks = [];
+  for (const id of ids) {
+    const asset = byId.get(id);
+    if (!asset || asset.deletedAt != null || !PRETURN_IMAGE_TYPES.has(asset.contentType)) continue;
+    const url = asset.url.startsWith("http") ? asset.url : fileBaseUrl + asset.url;
+    blocks.push({ type: "image", source: { type: "url", url } });
+  }
+  return blocks;
+}
+async function dispatchBrandTurn(deps, body) {
+  const channelId = String(body.event.row.channelId ?? "");
+  const book = await bookForChannel(deps.db, channelId);
+  if (!book) throw new BrandNotFoundError(`brand book for channel ${channelId || "(missing channelId)"}`);
+  const visionInToolResults = supportsBrandVision(deps.catalog?.[deps.model]);
+  const self = {
+    selfId: body.trigger.runAs.agentId,
+    kind: "bot",
+    displayName: body.trigger.runAs.persona
+  };
+  const persona = createBrandPersona({
+    model: deps.model,
+    brand: { db: deps.db, bookId: book.id, self, fileBaseUrl: deps.fileBaseUrl, visionInToolResults },
+    skills: deps.chatSkillFor ? [deps.chatSkillFor(channelId, self)] : []
+  });
+  const attachments = visionInToolResults ? [] : await assetBlocksFor(deps.db, deps.fileBaseUrl, body.event.row.assetIds);
+  const run = await deps.runAgent(deps.inference, persona, { input: brandInputFor(body, attachments) });
+  return { finalText: run.finalText };
+}
+
+// src/descriptor.ts
+var brandIntegration = {
+  id: "brand",
+  title: "Brand books (assets, palettes, proposals, design tokens)",
+  npm: "@odla-ai/brand",
+  settings: [
+    {
+      key: "basePath",
+      description: 'Route mount point the app worker serves brand under. Default "/api/brand".',
+      public: true,
+      perEnv: false,
+      source: "createBrandRoutes({ basePath }) in the app worker"
+    },
+    {
+      key: "publicTokens",
+      description: "Serve GET /books/:id/tokens.css and tokens.json without authorization (compiled tokens only \u2014 books and assets always authorize). Default false.",
+      public: true,
+      perEnv: false,
+      source: "createBrandRoutes({ publicTokens }) in the app worker"
+    }
+  ],
+  secrets: [],
+  schema: BRAND_SCHEMA,
+  rules: brandRules(),
+  triggers: [],
+  provision: {
+    human: [
+      'Choose the trigger mode: one global mention-gated bot (brandBotTrigger({ mention: "@brand" }), no channels) or per-book channel-scoped bots (channels: [book.channelId], no mention).',
+      "Pick the bot's model; when supportsBrandVision(catalog[model]) is false, dispatch attaches assets pre-turn instead of inside tool results.",
+      "Decide whether compiled tokens are public (publicTokens serves tokens.css/tokens.json unauthenticated)."
+    ],
+    cli: [
+      "POST BRAND_SCHEMA to /app/:id/schema.",
+      "Install brandRules() at /app/:id/admin/rules (merged with the app's existing rules).",
+      "Register a brandBotTrigger(...) per bot at /app/:id/admin/triggers \u2014 global mention-gated, or channel-scoped per book.",
+      "Seed the bot's agent id into each brand_book.memberIds roster (audienceFanoutOps covers existing child rows).",
+      "Provision the bot's AI provider secret (via @odla-ai/ai) and the worker's admin odla-db credential."
+    ],
+    doctor: [
+      "All five brand_* namespaces have rules installed (brand_asset fully closed \u2014 worker-mediated only).",
+      "brand_book.id/slug, brand_section.key, and the other mirrored id attrs are unique.",
+      "Each registered trigger's agent id is present in its target books' memberIds rosters.",
+      "Books with channelId set point at real chat channels when @odla-ai/chat is installed."
+    ]
+  }
+};
+function createBrandIntegration(options = {}) {
+  const basePath = options.basePath ?? "/api/brand";
+  if (!/^\/[A-Za-z0-9._~!$&'()*+,;=:@%/-]*$/.test(basePath) || basePath.endsWith("/")) {
+    throw new Error("createBrandIntegration: basePath must be an absolute path without a trailing slash");
+  }
+  const cli = [...brandIntegration.provision.cli];
+  if (options.mention !== void 0)
+    cli.push(`Gate the global bot on mentions: brandBotTrigger({ mention: ${JSON.stringify(options.mention)}, ... }).`);
+  if (options.publicTokens === true)
+    cli.push(`Mount createBrandRoutes({ publicTokens: true }) so ${basePath}/books/:id/tokens.css serves unauthenticated.`);
+  return {
+    ...brandIntegration,
+    provision: { ...brandIntegration.provision, cli },
+    probes: [{ path: `${basePath}/books`, expectedStatus: 401 }]
+  };
+}
+export {
+  ASSET_CONTENT_TYPES,
+  ASSET_KINDS,
+  BOOK_STATUSES,
+  BRAND_CHART_TOKENS,
+  BRAND_CHAT_TOKENS,
+  BRAND_DERIVED_TOKENS,
+  BRAND_EMITTED_TOKENS,
+  BRAND_INSTRUCTIONS,
+  BRAND_NS,
+  BRAND_REQUIRED_TOKENS,
+  BRAND_RULES,
+  BRAND_SCHEMA,
+  BrandInputError,
+  BrandNotFoundError,
+  CHART_DELTA_MIN,
+  CHAT_MESSAGE_NS,
+  CSS_NAMED_COLORS,
+  DARK_FLIP_L_MAX,
+  DARK_FLIP_L_MIN,
+  DEFAULT_ACCENT_SEED,
+  DEFAULT_BRAND_SYSTEM,
+  MAX_SWATCHES,
+  MAX_VIEW_BYTES,
+  PALETTE_SOURCES,
+  PALETTE_STATUSES,
+  PICK_TEXT_DEFAULT_CANDIDATES,
+  PROPOSAL_KINDS,
+  PROPOSAL_STATUSES,
+  RAMP_L_MAX,
+  RAMP_L_MIN,
+  SECTION_KINDS,
+  SECTION_STATUSES,
+  SWATCH_ROLES,
+  acceptProposalOps,
+  adjustLightnessUntil,
+  analogous,
+  assertAnalysis,
+  assertAssetContentType,
+  assertHex,
+  assertSectionContent,
+  assertSwatches,
+  assetTools,
+  audienceFanoutOps,
+  base64FromBytes,
+  bookForChannel,
+  bookTools,
+  brandBotTrigger,
+  brandInputFor,
+  brandIntegration,
+  brandRules,
+  brandSkill,
+  capString,
+  capStringArray,
+  clamp01,
+  clampToGamut,
+  compileBrandTokens,
+  complementary,
+  contrastRatio,
+  createAssetOps,
+  createBookOps,
+  createBrandIntegration,
+  createBrandPersona,
+  createBrandRoutes,
+  deltaEOK,
+  deltaEOKLab,
+  deriveChartColors,
+  deriveDarkTokens,
+  derivePalette,
+  dispatchBrandTurn,
+  hexToOklch,
+  hslToRgb,
+  inSrgbGamut,
+  linearToSrgb,
+  mapPaletteToTokens,
+  meetsAA,
+  meetsAAA,
+  monochrome,
+  nearestNamedColor,
+  normalizeHex,
+  oklabToOklch,
+  oklabToRgb,
+  oklchToHex,
+  oklchToOklab,
+  paletteTools,
+  parseBrandDispatch,
+  parseHex,
+  pickTextOn,
+  proposePaletteOps,
+  readTools,
+  recordAnalysisOps,
+  rejectProposalOps,
+  relativeLuminance,
+  renderTokensCss,
+  resolveDeps,
+  rgbToHsl,
+  rgbToOklab,
+  rotateHue,
+  safeFileName,
+  sectionKey,
+  splitComplementary,
+  srgbToLinear,
+  supportsBrandVision,
+  tetradic,
+  tintShadeRamp,
+  toHex,
+  tombstoneAssetOps,
+  triadic,
+  updateBookOps,
+  upsertSectionOps
+};
+//# sourceMappingURL=index.js.map