konpeki 0.1.0

package/composition/vector.ts

@@ -0,0 +1,143 @@
+import { DOMParser } from "@xmldom/xmldom";
+import {
+  vectorElementKinds,
+  type VectorElement,
+  type VectorElementKind,
+} from "./types.ts";
+
+export const vectorAttributeNames = new Set([
+  "x", "y", "dx", "dy", "x1", "y1", "x2", "y2", "width", "height", "rx", "ry",
+  "cx", "cy", "r", "d", "points", "transform", "fill", "fill-opacity",
+  "stroke", "stroke-width", "stroke-opacity", "stroke-linecap", "stroke-linejoin",
+  "stroke-dasharray", "opacity", "font-family", "font-size", "font-weight",
+  "font-style", "text-anchor", "dominant-baseline", "vector-effect",
+]);
+
+/** Remove a subtree, never leaving orphaned descendants. */
+export function removeVectorElement(elements: VectorElement[], id: string) {
+  const removed = new Set([id]);
+  for (const element of elements) {
+    if (element.parentId && removed.has(element.parentId)) removed.add(element.id);
+  }
+  return elements.filter((element) => !removed.has(element.id));
+}
+
+/** Swap sibling subtrees while retaining parent-before-child serialization. */
+export function moveVectorElement(elements: VectorElement[], id: string, direction: -1 | 1) {
+  const selected = elements.find((element) => element.id === id);
+  if (!selected) return elements;
+  const children = new Map<string | undefined, VectorElement[]>();
+  for (const element of elements) {
+    const peers = children.get(element.parentId) ?? [];
+    peers.push(element);
+    children.set(element.parentId, peers);
+  }
+  const siblings = children.get(selected.parentId)!;
+  const index = siblings.indexOf(selected);
+  const other = siblings[index + direction];
+  if (!other) return elements;
+  [siblings[index], siblings[index + direction]] = [other, selected];
+  const result: VectorElement[] = [];
+  function visit(parentId?: string) {
+    for (const child of children.get(parentId) ?? []) {
+      result.push(child);
+      visit(child.id);
+    }
+  }
+  visit();
+  return result;
+}
+
+function uniqueId(preferred: string, used: Set<string>, index: number) {
+  const base = preferred.trim().replace(/[^a-zA-Z0-9_-]+/g, "-") || `vector-${index}`;
+  if (!used.has(base)) return base;
+  let suffix = 2;
+  while (used.has(`${base}-${suffix}`)) suffix += 1;
+  return `${base}-${suffix}`;
+}
+
+function attributesOf(element: Element) {
+  const attributes: Record<string, string | number> = {};
+  for (let index = 0; index < element.attributes.length; index += 1) {
+    const attribute = element.attributes.item(index);
+    if (!attribute || attribute.name === "id") continue;
+    if (attribute.name === "style") {
+      for (const declaration of attribute.value.split(";")) {
+        const separator = declaration.indexOf(":");
+        if (separator < 0) continue;
+        const name = declaration.slice(0, separator).trim();
+        const value = declaration.slice(separator + 1).trim();
+        if (vectorAttributeNames.has(name) && value && !/url\s*\(/i.test(value))
+          attributes[name] = value;
+      }
+      continue;
+    }
+    if (vectorAttributeNames.has(attribute.name)) attributes[attribute.name] = attribute.value;
+  }
+  return attributes;
+}
+
+export function parseEditableSvg(source: string) {
+  const document = new DOMParser().parseFromString(source, "image/svg+xml");
+  const root = document.documentElement;
+  if (!root || root.localName !== "svg") throw new Error("The visual must have an SVG root.");
+  const values = root.getAttribute("viewBox")?.trim().split(/[\s,]+/).map(Number);
+  if (!values || values.length !== 4 || values.some((value) => !Number.isFinite(value)))
+    throw new Error("The SVG root needs a numeric viewBox.");
+  const [x, y, width, height] = values;
+  if (width <= 0 || height <= 0) throw new Error("The SVG viewBox must be positive.");
+
+  const elements: VectorElement[] = [];
+  const used = new Set<string>();
+  function visit(element: Element, parentId?: string) {
+    const kind = element.localName as VectorElementKind;
+    if (!vectorElementKinds.includes(kind))
+      throw new Error(`Unsupported editable SVG element: ${element.localName}.`);
+    const id = uniqueId(element.getAttribute("id") ?? "", used, elements.length + 1);
+    used.add(id);
+    const mixedText = (kind === "text" || kind === "tspan") &&
+      Array.from({ length: element.childNodes.length }, (_, index) =>
+        element.childNodes.item(index),
+      ).some((node) => node?.nodeType === 1);
+    const text = [...Array.from({ length: element.childNodes.length }, (_, index) =>
+      element.childNodes.item(index),
+    )]
+      .filter((node) => node?.nodeType === 3)
+      .map((node) => node?.nodeValue ?? "")
+      .join("");
+    elements.push({
+      id,
+      kind,
+      ...(parentId ? { parentId } : {}),
+      attributes: attributesOf(element),
+      ...(!mixedText && text && (kind === "text" || kind === "tspan") ? { text } : {}),
+    });
+    for (let index = 0; index < element.childNodes.length; index += 1) {
+      const child = element.childNodes.item(index);
+      if (mixedText && child?.nodeType === 3 && child.nodeValue) {
+        const textId = uniqueId("", used, elements.length + 1);
+        used.add(textId);
+        elements.push({ id: textId, kind: "tspan", parentId: id, attributes: {}, text: child.nodeValue });
+      }
+      if (child?.nodeType !== 1) continue;
+      visit(child as unknown as Element, id);
+    }
+  }
+
+  const rootAttributes = attributesOf(root as unknown as Element);
+  let parentId: string | undefined;
+  if (Object.keys(rootAttributes).length) {
+    parentId = "vector-root";
+    used.add(parentId);
+    elements.push({ id: parentId, kind: "g", attributes: rootAttributes });
+  }
+  for (let index = 0; index < root.childNodes.length; index += 1) {
+    const child = root.childNodes.item(index);
+    if (child?.nodeType !== 1) continue;
+    const name = (child as unknown as Element).localName;
+    if (name === "title" || name === "desc") continue;
+    visit(child as unknown as Element, parentId);
+  }
+  if (!elements.length) throw new Error("The SVG contains no editable elements.");
+  return { viewBox: { x, y, width, height }, elements };
+}

package/composition/visualizations.ts

@@ -0,0 +1,335 @@
+export type DiagramLayoutEngine =
+  | "linear"
+  | "branching"
+  | "cyclical"
+  | "layered"
+  | "request-flow"
+  | "hub-and-spoke";
+
+export type DiagramDefinition = {
+  label: string;
+  category:
+    | "Systems & technical structure"
+    | "Flow, interaction & behavior"
+    | "Data & software modeling"
+    | "Hierarchy, containment & organization"
+    | "Time & work"
+    | "Quantitative & analytical"
+    | "Conceptual & strategic";
+  layout: DiagramLayoutEngine;
+  slotRole: "process-step" | "entity";
+  expression: string;
+};
+
+export type ChartDefinition = {
+  label: string;
+  expression: string;
+  source: "diagram-design" | "konpeki";
+};
+
+export const diagramDefinitions = {
+  architecture: {
+    label: "Architecture",
+    category: "Systems & technical structure",
+    layout: "hub-and-spoke",
+    slotRole: "entity",
+    expression: "Show system boundaries, responsibilities, interfaces, and directional communication without implying physical deployment.",
+  },
+  "it-current-state": {
+    label: "IT current state",
+    category: "Systems & technical structure",
+    layout: "hub-and-spoke",
+    slotRole: "entity",
+    expression: "Show the systems that exist today, their ownership, integration paths, friction, duplication, and known constraints.",
+  },
+  "high-level": {
+    label: "High-level overview",
+    category: "Systems & technical structure",
+    layout: "layered",
+    slotRole: "entity",
+    expression: "Reduce the system to a small number of named capabilities and major relationships; suppress implementation detail.",
+  },
+  deployment: {
+    label: "Deployment",
+    category: "Systems & technical structure",
+    layout: "layered",
+    slotRole: "entity",
+    expression: "Place software artifacts inside the environments, hosts, zones, or runtimes where they execute and show cross-zone communication.",
+  },
+  flowchart: {
+    label: "Flowchart",
+    category: "Flow, interaction & behavior",
+    layout: "branching",
+    slotRole: "process-step",
+    expression: "Distinguish actions, decisions, merge points, and start or end states; label decision branches explicitly.",
+  },
+  sequence: {
+    label: "Sequence",
+    category: "Flow, interaction & behavior",
+    layout: "request-flow",
+    slotRole: "entity",
+    expression: "Order actors horizontally and messages vertically through time; distinguish calls, returns, asynchronous messages, and branches.",
+  },
+  "state-machine": {
+    label: "State machine",
+    category: "Flow, interaction & behavior",
+    layout: "branching",
+    slotRole: "entity",
+    expression: "Treat nodes as legal states and edges as guarded transitions; preserve initial, terminal, retry, and invalid transition semantics.",
+  },
+  swimlane: {
+    label: "Swimlane",
+    category: "Flow, interaction & behavior",
+    layout: "layered",
+    slotRole: "process-step",
+    expression: "Partition steps by responsible actor or team and make every cross-lane handoff visible.",
+  },
+  process: {
+    label: "Process",
+    category: "Flow, interaction & behavior",
+    layout: "linear",
+    slotRole: "process-step",
+    expression: "Show ordered work from trigger to outcome, including branches, loops, owners, and exceptional paths when supplied.",
+  },
+  "data-flow": {
+    label: "Data flow",
+    category: "Flow, interaction & behavior",
+    layout: "hub-and-spoke",
+    slotRole: "entity",
+    expression: "Show data producers, transformations, stores, and consumers; label payloads and direction independently from control flow.",
+  },
+  "dp-integration": {
+    label: "Data-product integration",
+    category: "Flow, interaction & behavior",
+    layout: "request-flow",
+    slotRole: "entity",
+    expression: "Show producer and consumer responsibilities, contracts, integration boundaries, and exchange direction for each data product.",
+  },
+  "er-data-model": {
+    label: "ER / data model",
+    category: "Data & software modeling",
+    layout: "hub-and-spoke",
+    slotRole: "entity",
+    expression: "Represent entities with key attributes and label relationship cardinality and optionality at both endpoints.",
+  },
+  medallion: {
+    label: "Medallion",
+    category: "Data & software modeling",
+    layout: "layered",
+    slotRole: "entity",
+    expression: "Arrange data products by progressive quality tier and show transformations from raw through refined to consumption-ready data.",
+  },
+  "dp-security-matrix": {
+    label: "Data-product security matrix",
+    category: "Data & software modeling",
+    layout: "layered",
+    slotRole: "entity",
+    expression: "Use rows and columns as explicit subject and resource axes; encode permissions or controls at their intersections.",
+  },
+  "dependency-graph": {
+    label: "Dependency graph",
+    category: "Data & software modeling",
+    layout: "branching",
+    slotRole: "entity",
+    expression: "Preserve many-parent fan-in, shared dependencies, and cycles; orient every dependency edge consistently.",
+  },
+  "uml-class": {
+    label: "UML class",
+    category: "Data & software modeling",
+    layout: "hub-and-spoke",
+    slotRole: "entity",
+    expression: "Keep class names, attributes, and operations in separate compartments and preserve inheritance, aggregation, and composition notation.",
+  },
+  "database-schema": {
+    label: "Database schema",
+    category: "Data & software modeling",
+    layout: "hub-and-spoke",
+    slotRole: "entity",
+    expression: "Show tables with typed columns, keys, constraints, and column-level foreign-key endpoints.",
+  },
+  nested: {
+    label: "Nested containment",
+    category: "Hierarchy, containment & organization",
+    layout: "layered",
+    slotRole: "entity",
+    expression: "Use enclosure to express scope and ownership; containment must not be replaced by proximity alone.",
+  },
+  tree: {
+    label: "Tree",
+    category: "Hierarchy, containment & organization",
+    layout: "branching",
+    slotRole: "entity",
+    expression: "Show a strict one-parent hierarchy with consistent depth and sibling ordering.",
+  },
+  "org-chart": {
+    label: "Org chart",
+    category: "Hierarchy, containment & organization",
+    layout: "branching",
+    slotRole: "entity",
+    expression: "Show reporting structure, role ownership, and escalation paths; do not imply technical dependency.",
+  },
+  "layer-stack": {
+    label: "Layer stack",
+    category: "Hierarchy, containment & organization",
+    layout: "layered",
+    slotRole: "entity",
+    expression: "Order abstraction or responsibility layers consistently and show only legitimate cross-layer dependencies.",
+  },
+  "pyramid-funnel": {
+    label: "Pyramid / funnel",
+    category: "Hierarchy, containment & organization",
+    layout: "layered",
+    slotRole: "entity",
+    expression: "Use width and vertical order to encode rank, concentration, or drop-off; state which meaning applies.",
+  },
+  timeline: {
+    label: "Timeline",
+    category: "Time & work",
+    layout: "linear",
+    slotRole: "process-step",
+    expression: "Place dated events on an honest temporal axis and preserve meaningful interval differences.",
+  },
+  gantt: {
+    label: "Gantt",
+    category: "Time & work",
+    layout: "layered",
+    slotRole: "process-step",
+    expression: "Encode task start, duration, overlap, milestones, dependencies, and ownership against a shared time scale.",
+  },
+  kanban: {
+    label: "Kanban",
+    category: "Time & work",
+    layout: "layered",
+    slotRole: "entity",
+    expression: "Use columns as workflow states, preserve card ownership and priority, and show WIP limits when supplied.",
+  },
+  "user-journey": {
+    label: "User journey",
+    category: "Time & work",
+    layout: "linear",
+    slotRole: "process-step",
+    expression: "Order experience stages and align actions, touchpoints, pain points, and sentiment to each stage.",
+  },
+  "story-map": {
+    label: "Story map",
+    category: "Time & work",
+    layout: "layered",
+    slotRole: "entity",
+    expression: "Use columns for narrative activity order and rows for release slices; preserve the release-cut line.",
+  },
+  quadrant: {
+    label: "Quadrant",
+    category: "Quantitative & analytical",
+    layout: "layered",
+    slotRole: "entity",
+    expression: "Position items against two named axes with meaningful scales and make quadrant interpretation explicit.",
+  },
+  "loop-flywheel": {
+    label: "Loop / flywheel",
+    category: "Conceptual & strategic",
+    layout: "cyclical",
+    slotRole: "process-step",
+    expression: "Show a reinforcing cycle with explicit direction and explain how each stage increases momentum or feeds the next.",
+  },
+  venn: {
+    label: "Venn",
+    category: "Conceptual & strategic",
+    layout: "hub-and-spoke",
+    slotRole: "entity",
+    expression: "Use overlapping regions to encode set membership and label every meaningful intersection.",
+  },
+  fishbone: {
+    label: "Fishbone",
+    category: "Conceptual & strategic",
+    layout: "branching",
+    slotRole: "entity",
+    expression: "Group candidate causes by category along branches that converge on one clearly stated effect.",
+  },
+  "wardley-map": {
+    label: "Wardley map",
+    category: "Conceptual & strategic",
+    layout: "layered",
+    slotRole: "entity",
+    expression: "Position components by user visibility and evolution, then show value-chain dependencies and movement without treating the map as runtime architecture.",
+  },
+} as const satisfies Record<string, DiagramDefinition>;
+
+export type DiagramType = keyof typeof diagramDefinitions;
+
+export const diagramTypes = Object.keys(diagramDefinitions) as DiagramType[];
+
+export const chartDefinitions = {
+  "grouped-bar": {
+    label: "Grouped bar",
+    expression: "Compare quantitative values across categories with a shared zero baseline; use grouped series only when each category has comparable values.",
+    source: "diagram-design",
+  },
+  line: {
+    label: "Line",
+    expression: "Encode values on a shared scale and connect observations in meaningful order, usually time; preserve intervals and do not imply missing measurements.",
+    source: "diagram-design",
+  },
+  pie: {
+    label: "Pie",
+    expression: "Show a small set of mutually exclusive parts of one whole; preserve the total and label values directly when comparison by angle is difficult.",
+    source: "konpeki",
+  },
+  "annotated-detail": {
+    label: "Annotated detail",
+    expression: "Focus on one visual detail and connect concise annotations to exact evidence without obscuring the underlying image or chart.",
+    source: "konpeki",
+  },
+  radar: {
+    label: "Radar",
+    expression: "Compare multivariate profiles on consistently normalized radial axes; preserve axis order, scale, and direction across every series.",
+    source: "diagram-design",
+  },
+  treemap: {
+    label: "Treemap",
+    expression: "Encode part-to-whole magnitude by rectangle area within explicit hierarchy; preserve parent totals and avoid implying rank from position.",
+    source: "diagram-design",
+  },
+  scatter: {
+    label: "Scatter",
+    expression: "Position observations by two measured quantitative variables; preserve axis scales, units, outliers, and uncertainty about correlation.",
+    source: "diagram-design",
+  },
+  sankey: {
+    label: "Sankey",
+    expression: "Encode conserved quantity through splits and merges using proportional ribbon width; preserve node totals, flow direction, and units.",
+    source: "diagram-design",
+  },
+} as const satisfies Record<string, ChartDefinition>;
+
+export type ChartTemplate = keyof typeof chartDefinitions;
+
+export const chartTemplates = Object.keys(chartDefinitions) as ChartTemplate[];
+
+export const visualizationDefinitions = {
+  diagram: diagramDefinitions,
+  chart: chartDefinitions,
+} as const;
+
+export const diagramCategories = Array.from(
+  new Set(Object.values(diagramDefinitions).map((definition) => definition.category)),
+);
+
+export function diagramDefinition(type: DiagramType): DiagramDefinition {
+  return diagramDefinitions[type];
+}
+
+export function migrateLegacyDiagramType(
+  type: unknown,
+  layout: unknown,
+): DiagramType | undefined {
+  if (typeof type !== "string" || typeof layout !== "string") return undefined;
+  const legacyTypes: Record<string, DiagramType> = {
+    "process/linear": "process",
+    "process/branching": "flowchart",
+    "process/cyclical": "loop-flywheel",
+    "system/layered": "layer-stack",
+    "system/request-flow": "sequence",
+    "system/hub-and-spoke": "architecture",
+  };
+  return legacyTypes[`${type}/${layout}`];
+}

package/design/README.md

@@ -0,0 +1,17 @@
+# Find an authoring resource
+
+[AUTHORING](../AUTHORING.md) owns design defaults and font suggestions. Consult
+the resources below for a specific need; none impose a composition or reading order.
+
+| Need | Where | Use |
+| --- | --- | --- |
+| Choose the rules | [Authoring mode](../AUTHORING.md#authoring-mode) | Default (original rules) or dynamic (relaxed visual rules); optional paired comparison |
+| Choose a visual structure | [Semantic patterns](semantic-patterns.md) | Audience question → relationships → visual structure |
+| Review rendered pages | [Review categories](visual-review.md) | Text, typography, layout, color/theme and visuals; optional parallel review |
+| Colors only | [palettes](palettes/README.md) | Base, eight light/dark palettes, Mineral/Botanical light candidates |
+| Typography + colors | [themes](themes/README.md) | Ready theme roles; no content or layout |
+| Art direction | [Technical product language](visual-languages/technical-product.md) | How imagery, emphasis and diagrams work together |
+| Add a deck | [Deck directory guide](../slides/README.md) | Routes, prompt records and example deliverables |
+
+Start freely when no example fits. Reuse implementation, not composition.
+A case-specific check is not a design rule.

package/design/palettes/README.md

@@ -0,0 +1,14 @@
+# Color palettes
+
+Color resources only; no typography, layout or content.
+
+- [index.ts](index.ts): `resolvePalette(name, 'paper' | 'night')` for Plex,
+  Precision, Editorial, Blue–cyan, Orange–coral, Yellow, Green and Graphite.
+  Contains surface/text roles, categorical colors, sequential ramps and status.
+- [candidates.ts](candidates.ts): `lightPalettes`, Mineral and Botanical,
+  including named series and diverging ramps. Light-only; not auto-inverted.
+- [base.ts](base.ts): original specimen roles, still re-exported by
+  `lib/taste.ts` for existing runtime consumers. Definitions are not duplicated.
+
+Choose only the needed series. Keep category meaning separate from status.
+For typography with a palette, use [themes](../themes/README.md).

package/design/palettes/base.ts

@@ -0,0 +1,14 @@
+// Original specimen palette. Named palettes build on these color roles.
+export const palettes = {
+  paper: {
+    bg: '#FFFFFF', fg: '#000000', muted: '#3F4A54', line: '#BCC6CE',
+    surface: '#EAEFF3', wash: '#E3EAF8', accent: '#2458C7', inverse: '#FFFFFF',
+    emphasis: '#98451F', emphasisWash: '#F1E1D4',
+  },
+  night: {
+    bg: '#000000', fg: '#FFFFFF', muted: '#B2C1CC', line: '#4C6072',
+    surface: '#202E3C', wash: '#233857', accent: '#97B9FF', inverse: '#000000',
+    emphasis: '#F0AC7D', emphasisWash: '#443025',
+  },
+};
+export type Palette = typeof palettes.paper;

package/design/palettes/candidates.ts

@@ -0,0 +1,19 @@
+// Approved light-only color candidates. No layout or typography.
+export const lightPalettes = [
+  {
+    name: 'Mineral', bg: '#FFFFFF', ink: '#18232D', muted: '#526170',
+    surface: '#F0F3F5', line: '#CBD3DA', accent: '#2458B8', wash: '#E8EFFB',
+    colors: ['#3569B7', '#167D8D', '#8061A8', '#A27616', '#BA536A', '#59734A'],
+    names: ['Cobalt', 'Petrol', 'Iris', 'Ochre', 'Rose', 'Moss'],
+    sequential: ['#E8EFFB', '#B9CDEA', '#7CA2D4', '#4677B8', '#24518D'],
+    diverging: ['#A14B26', '#D79A73', '#F0F1F2', '#83B9C1', '#216775'],
+  },
+  {
+    name: 'Botanical', bg: '#FFFFFF', ink: '#222923', muted: '#59625B',
+    surface: '#F1F4F1', line: '#CBD4CB', accent: '#32634D', wash: '#E7F0E9',
+    colors: ['#43785B', '#5375B5', '#B45A38', '#8B5B96', '#8A781B', '#287F92'],
+    names: ['Fern', 'Denim', 'Terracotta', 'Plum', 'Brass', 'Lake'],
+    sequential: ['#E7F0E9', '#B9D1BF', '#83AD90', '#528566', '#2D5941'],
+    diverging: ['#86508D', '#BE9AC1', '#F0F1F2', '#8DB7A8', '#326C59'],
+  },
+];

package/design/palettes/index.ts

@@ -0,0 +1,78 @@
+import { palettes, type Palette } from './base.ts';
+
+// Color-only resources. These are our adaptations, not extracted brand tokens.
+// Keep category identity/order stable across modes; status is a separate channel.
+export const paletteNames = ['Plex', 'Precision', 'Editorial', 'Blue–cyan', 'Orange–coral', 'Yellow', 'Green', 'Graphite'] as const;
+export type PaletteName = typeof paletteNames[number];
+export type PaletteMode = 'paper' | 'night';
+type SixColors = [string, string, string, string, string, string];
+type FiveColors = [string, string, string, string, string];
+type PaletteDefinition = {
+  accent: [string, string];
+  wash: [string, string];
+  surface: [string, string];
+  categorical: [SixColors, SixColors];
+  sequential: [FiveColors, FiveColors];
+};
+
+const definitions: Record<PaletteName, PaletteDefinition> = {
+  Plex: {
+    accent: ['#2458B8', '#91B9FF'], wash: ['#EAF0FA', '#18273F'], surface: ['#F1F3F5', '#171B21'],
+    categorical: [['#3569B7', '#167D8D', '#8061A8', '#A27616', '#BA536A', '#59734A'], ['#82AEF2', '#63C3CD', '#BAA0DF', '#D7B55B', '#E899AA', '#A6C58E']],
+    sequential: [['#E8EFFB', '#B9CDEA', '#7CA2D4', '#4677B8', '#24518D'], ['#192B45', '#305381', '#4C7CB4', '#82AEF2', '#C2DAFF']],
+  },
+  Precision: {
+    accent: ['#3D3A8F', '#B6B2FF'], wash: ['#EEEFFD', '#22213D'], surface: ['#F2F2F5', '#19191F'],
+    categorical: [['#4B469D', '#2F6A8F', '#76538F', '#8A5A25', '#9A475F', '#4F7040'], ['#AAA5F4', '#82BCE2', '#C69DDF', '#DEB071', '#E89AAF', '#A6C88D']],
+    sequential: [['#EEEFFD', '#C9C7EC', '#9792D0', '#6761AE', '#3D3A8F'], ['#23223F', '#454278', '#716CB2', '#AAA5F4', '#D9D7FF']],
+  },
+  Editorial: {
+    accent: ['#93451F', '#F2B38C'], wash: ['#F6ECE5', '#30231D'], surface: ['#F4F3F2', '#1B1918'],
+    categorical: [['#AF5934', '#387684', '#8A619A', '#8C791D', '#AD5071', '#4D7757'], ['#EFA77F', '#86C3CD', '#C6A3D5', '#D4C17A', '#E9A2BF', '#A0C9A5']],
+    sequential: [['#F7EEE7', '#EACAB4', '#CD9875', '#AB6A45', '#794021'], ['#35271F', '#664832', '#A07350', '#D5A17B', '#F6D5B8']],
+  },
+  'Blue–cyan': {
+    accent: ['#007C88', '#63D6E3'], wash: ['#EAF9FA', '#112E33'], surface: ['#F0F9FA', '#121D20'],
+    categorical: [['#007C88', '#007F8E', '#275F9A', '#95631F', '#A64D68', '#39724F'], ['#63D6E3', '#79E3EB', '#8FBCEF', '#DBB267', '#E799AF', '#89C9A1']],
+    sequential: [['#EAF9FA', '#B7E7EA', '#72C3CA', '#2B9AA5', '#007C88'], ['#123136', '#225D65', '#388F99', '#63C6D0', '#A8EFF4']],
+  },
+  'Orange–coral': {
+    accent: ['#A23E20', '#FFB28E'], wash: ['#FFF0E8', '#33231D'], surface: ['#F5F3F2', '#1D1917'],
+    categorical: [['#BA5A31', '#B94970', '#4876AA', '#247D76', '#8861A3', '#92771D'], ['#F3A47C', '#ED99B7', '#91B8E8', '#76C7BE', '#BFA3DD', '#D7BF70']],
+    sequential: [['#FCEDE5', '#EDC3AD', '#D89370', '#B66A44', '#88411E'], ['#36251F', '#6D4430', '#A9704D', '#DF9F73', '#FFD1AC']],
+  },
+  Yellow: {
+    accent: ['#756000', '#F1D66D'], wash: ['#FBF5D9', '#302A17'], surface: ['#F5F5F0', '#1C1C18'],
+    categorical: [['#95761C', '#416FA4', '#A95670', '#397D71', '#8862A2', '#AD612C'], ['#E0C264', '#91B6E5', '#E1A1B6', '#8AC8B8', '#BFA5D9', '#E4B181']],
+    sequential: [['#F8F3D9', '#E5D9A4', '#C4B369', '#9B8433', '#705C12'], ['#302B19', '#5A4C25', '#917A38', '#C9AF59', '#F5DE91']],
+  },
+  Green: {
+    accent: ['#216B3D', '#98DCAF'], wash: ['#EAF3ED', '#1A2D22'], surface: ['#F1F5F2', '#171D19'],
+    categorical: [['#43785B', '#5375B5', '#B45A38', '#8B5B96', '#8A781B', '#287F92'], ['#91C7A6', '#9AB8EA', '#E9AB8A', '#CBA4D5', '#D1C278', '#7BC8D8']],
+    sequential: [['#E7F0E9', '#B9D1BF', '#83AD90', '#528566', '#2D5941'], ['#1B3023', '#325A40', '#578569', '#91C7A6', '#CBECD6']],
+  },
+  Graphite: {
+    accent: ['#242424', '#F2F2F2'], wash: ['#EDEDED', '#242424'], surface: ['#F5F5F5', '#171717'],
+    categorical: [['#3268B5', '#187F86', '#8A5DA6', '#A87922', '#B55372', '#5A7847'], ['#85B2F3', '#77C9CF', '#C3A2E0', '#DDBB78', '#E6A0B8', '#ADC991']],
+    sequential: [['#EFEFEF', '#CBCBCB', '#999999', '#666666', '#303030'], ['#282828', '#505050', '#838383', '#B8B8B8', '#EFEFEF']],
+  },
+};
+
+export function resolvePalette(name: PaletteName, mode: PaletteMode): Palette & {
+  categorical: SixColors; sequential: FiveColors; status: { complete: string; attention: string; blocked: string };
+} {
+  const d = definitions[name], dark = mode === 'night', i = dark ? 1 : 0;
+  return {
+    ...palettes[mode],
+    bg: dark ? '#000000' : '#FFFFFF', fg: dark ? '#F2F2F2' : '#20242A',
+    muted: dark ? '#B7BCC4' : '#505B68', line: dark ? '#454B54' : '#C9CFD6',
+    ...(name === 'Graphite' ? {
+      fg: dark ? '#F2F2F2' : '#202020', muted: dark ? '#B8B8B8' : '#595959',
+      line: dark ? '#454545' : '#CECECE', emphasis: d.accent[i], emphasisWash: d.wash[i],
+    } : {}),
+    accent: d.accent[i], wash: d.wash[i], surface: d.surface[i],
+    categorical: [...d.categorical[i]], sequential: [...d.sequential[i]],
+    status: dark ? { complete: '#94D3AB', attention: '#E3C477', blocked: '#F0A1AF' }
+      : { complete: '#276749', attention: '#946200', blocked: '#AC3348' },
+  };
+}