@flashdsm/genome 0.1.0

package/dist/chunk-6OCQZNS7.js

@@ -0,0 +1,851 @@
+// ../core/dist/schemas.js
+import { z } from "zod";
+var TokenTypeSchema = z.enum([
+  "color",
+  "font",
+  "size",
+  "radius",
+  "shadow",
+  "motion",
+  "gradient",
+  "border",
+  "effect",
+  "icon",
+  // Motion sub-types mapping onto the DTCG duration/cubicBezier/transition
+  // types. "motion" above stays valid for tokens authored before the split.
+  "duration",
+  "cubicBezier",
+  "transition"
+]);
+var TokenCategorySchema = z.enum([
+  "colors",
+  "spacing",
+  "typography",
+  "radius",
+  "motion",
+  "shadow",
+  "border",
+  "effects",
+  "icons"
+]);
+var TokenStatusSchema = z.enum(["active", "deprecated", "legacy"]);
+var TokenSchema = z.object({
+  name: z.string(),
+  value: z.string(),
+  type: TokenTypeSchema,
+  category: TokenCategorySchema,
+  fallbackValue: z.string().optional(),
+  derivedFrom: z.string().optional(),
+  status: TokenStatusSchema.optional(),
+  description: z.string().optional(),
+  aliases: z.array(z.string()).optional(),
+  usedBy: z.array(z.string()).optional(),
+  foundationDetachedRowIds: z.array(z.string()).optional(),
+  foundationServingRowIds: z.array(z.string()).optional(),
+  metadata: z.record(z.any()).optional(),
+  documentation: z.string().optional(),
+  lastModified: z.number().optional(),
+  lastSynced: z.number().optional(),
+  id: z.string().optional(),
+  layer: z.enum(["primitive", "alias"]).optional(),
+  colorGroup: z.enum([
+    "primary",
+    "secondary",
+    "neutral",
+    "semantic",
+    "text",
+    "background",
+    "border",
+    // Semantic layer groups. Kept in lockstep with Token["colorGroup"] in
+    // tokens.ts - a value this schema rejects is a token the MCP server
+    // drops on the floor.
+    "brand",
+    "control",
+    "status",
+    "focus"
+  ]).optional(),
+  referencedTokenId: z.string().optional(),
+  tokenId: z.number().int().optional()
+});
+var DesignTokenSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  type: z.enum([
+    "color",
+    "spacing",
+    "typography",
+    "shadow",
+    "border",
+    "opacity",
+    "other"
+  ]),
+  value: z.union([z.string(), z.number()]),
+  description: z.string().optional(),
+  category: z.string().optional(),
+  metadata: z.record(z.any()).optional()
+});
+var DetectedComponentSchema = z.object({
+  name: z.string(),
+  category: z.string(),
+  variants: z.number().optional(),
+  states: z.number().optional(),
+  description: z.string().optional(),
+  detectedFrom: z.enum(["figma", "storybook", "url", "image", "github"]),
+  tokens: z.record(z.string()).optional()
+});
+var SimpleTokenSchema = z.object({
+  name: z.string(),
+  value: z.string(),
+  type: z.string(),
+  category: z.string(),
+  description: z.string().optional()
+});
+var NormalizedTokenSetSchema = z.object({
+  colors: z.array(SimpleTokenSchema).optional(),
+  spacing: z.array(SimpleTokenSchema).optional(),
+  typography: z.array(SimpleTokenSchema).optional(),
+  radius: z.array(SimpleTokenSchema).optional(),
+  shadows: z.array(SimpleTokenSchema).optional()
+});
+var JsonValueSchema = z.union([
+  z.record(z.any()),
+  z.array(z.any()),
+  z.null()
+]);
+var DesignSystemApiCreateSchema = z.object({
+  name: z.string().min(1).max(256),
+  version: z.string().max(64).default("0.1.0"),
+  schema_version: z.string().max(64).default("1.0.0"),
+  project_id: z.number().int().nullable().optional(),
+  tokens: JsonValueSchema.optional(),
+  components: JsonValueSchema.optional()
+});
+var DesignSystemApiUpdateSchema = z.object({
+  name: z.string().min(1).max(256).optional(),
+  version: z.string().max(64).optional(),
+  schema_version: z.string().max(64).optional(),
+  project_id: z.number().int().nullable().optional(),
+  tokens: JsonValueSchema.optional(),
+  components: JsonValueSchema.optional()
+});
+var DesignSystemApiOutSchema = z.object({
+  id: z.number().int(),
+  user_id: z.number().int(),
+  project_id: z.number().int().nullable(),
+  name: z.string(),
+  version: z.string(),
+  schema_version: z.string(),
+  tokens: JsonValueSchema,
+  components: JsonValueSchema,
+  created_at: z.string().datetime({ offset: true }).or(z.string()),
+  updated_at: z.string().datetime({ offset: true }).or(z.string())
+});
+
+// ../core/dist/atomic-document.js
+import { z as z2 } from "zod";
+var ComponentPreviewStateSchema = z2.enum([
+  "default",
+  "hover",
+  "pressed",
+  "loading",
+  "error",
+  "open",
+  "disabled"
+]);
+var AtomicComponentCategorySchema = z2.enum([
+  "actions",
+  "inputs",
+  "controls",
+  "navigation",
+  "containers",
+  "feedback",
+  "media"
+]);
+var BindingSlotSchema = z2.enum([
+  "background",
+  "foreground",
+  "accent",
+  "border",
+  "padding",
+  "margin",
+  "gap",
+  "borderRadius",
+  "fontSize",
+  "fontWeight",
+  "lineHeight",
+  "letterSpacing",
+  "color",
+  "boxShadow",
+  "minHeight",
+  "transition"
+]);
+var TokenRelationTypeSchema = z2.enum(["alias_of", "semantic_of"]);
+var ImportSourceTypeSchema = z2.enum([
+  "figma",
+  "github",
+  "storybook",
+  "website",
+  "image",
+  "mcp",
+  "scratch",
+  "template"
+]);
+var AtomicTokenSchema = TokenSchema.extend({
+  tokenId: z2.number().int().optional()
+});
+var AtomicVariantSchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string().min(1)
+});
+var AtomicBindingSchema = z2.object({
+  variantId: z2.string().optional(),
+  stateId: ComponentPreviewStateSchema.optional(),
+  slot: BindingSlotSchema.or(z2.string().min(1)),
+  tokenId: z2.string().min(1)
+});
+var AtomicComponentProvenanceSchema = z2.object({
+  figmaNodeId: z2.string().optional(),
+  gitPath: z2.string().optional()
+});
+var AtomicComponentSchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string().min(1),
+  category: AtomicComponentCategorySchema,
+  description: z2.string().optional(),
+  host: z2.string().optional(),
+  variants: z2.array(AtomicVariantSchema).default([]),
+  states: z2.array(ComponentPreviewStateSchema).default([]),
+  bindings: z2.array(AtomicBindingSchema).default([]),
+  provenance: AtomicComponentProvenanceSchema.optional(),
+  needsReview: z2.boolean().optional()
+});
+var AtomicModulePartSchema = z2.object({
+  slotId: z2.string().min(1),
+  componentId: z2.string().min(1),
+  variantId: z2.string().optional()
+});
+var AtomicModuleSchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string().min(1),
+  parts: z2.array(AtomicModulePartSchema).default([]),
+  bindings: z2.array(AtomicBindingSchema).default([])
+});
+var AtomicPageSlotSchema = z2.object({
+  moduleId: z2.string().min(1)
+});
+var AtomicPageBandSchema = z2.object({
+  slots: z2.array(AtomicPageSlotSchema).default([])
+});
+var AtomicPageSchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string().min(1),
+  bands: z2.array(AtomicPageBandSchema).default([])
+});
+var AtomicFoundationsSchema = z2.object({
+  colors: z2.array(AtomicTokenSchema).default([]),
+  typography: z2.array(AtomicTokenSchema).default([]),
+  spacing: z2.array(AtomicTokenSchema).default([]),
+  radius: z2.array(AtomicTokenSchema).default([]),
+  shadows: z2.array(AtomicTokenSchema).default([]),
+  border: z2.array(AtomicTokenSchema).default([]),
+  motion: z2.array(AtomicTokenSchema).default([]),
+  effects: z2.array(AtomicTokenSchema).default([]),
+  icons: z2.array(AtomicTokenSchema).default([])
+});
+var AtomicTokenRelationSchema = z2.object({
+  source: z2.string().min(1),
+  target: z2.string().min(1),
+  type: TokenRelationTypeSchema
+});
+var AtomicRelationsSchema = z2.object({
+  tokens: z2.array(AtomicTokenRelationSchema).default([])
+});
+var AtomicImportSourceSchema = z2.object({
+  type: ImportSourceTypeSchema,
+  ref: z2.string().min(1),
+  contentHash: z2.string().optional(),
+  label: z2.string().optional()
+});
+var AtomicDocumentMetaSchema = z2.object({
+  stack: z2.string().optional(),
+  sources: z2.array(AtomicImportSourceSchema).default([]),
+  brandDna: z2.record(z2.unknown()).optional(),
+  designStrategy: z2.record(z2.unknown()).optional()
+});
+var FLASH_ATOMIC_SCHEMA_VERSION = "2.0.0";
+var FlashAtomicDocumentSchema = z2.object({
+  schemaVersion: z2.literal(FLASH_ATOMIC_SCHEMA_VERSION),
+  id: z2.union([z2.string(), z2.number()]).optional(),
+  name: z2.string().min(1),
+  version: z2.string().min(1).default("0.1.0"),
+  foundations: AtomicFoundationsSchema.default({}),
+  semantics: z2.array(AtomicTokenSchema).default([]),
+  components: z2.array(AtomicComponentSchema).default([]),
+  modules: z2.array(AtomicModuleSchema).default([]),
+  pages: z2.array(AtomicPageSchema).optional(),
+  relations: AtomicRelationsSchema.default({ tokens: [] }),
+  meta: AtomicDocumentMetaSchema.optional()
+}).strict();
+function parseFlashAtomicDocument(input) {
+  return FlashAtomicDocumentSchema.parse(input);
+}
+
+// ../core/dist/genome-config.js
+import { z as z3 } from "zod";
+var GENOME_CONFIG_FILENAME = "genome.config.json";
+var LEGACY_CONFIG_FILENAME = "flash-ds.config.json";
+var GenomeInputsSchema = z3.object({
+  /** Token files the repo authors: DTCG JSON and CSS custom properties. */
+  tokens: z3.array(z3.string().min(1)).default([]),
+  /** A Tailwind config to read the theme from, when there is one. */
+  tailwind: z3.string().min(1).optional(),
+  /** Directories whose components the scan should read. */
+  components: z3.array(z3.string().min(1)).default([])
+});
+var GenomeOutputsSchema = z3.object({
+  tokensDtcg: z3.string().min(1).default("design-tokens.json"),
+  tokensCss: z3.string().min(1).default("tokens.css"),
+  agentsMd: z3.string().min(1).default("AGENTS.md"),
+  cursorRules: z3.string().min(1).default(".cursor/rules/flash-genome.mdc"),
+  /** Directory for the kit, tokens, components mirror and the lock file. */
+  genomeDir: z3.string().min(1).default("genome/"),
+  /**
+   * Where the icons folder lands: SVG drawings, the Material Symbols
+   * stylesheet and the licence notice.
+   *
+   * Optional rather than defaulted, so an unset value can follow `genomeDir`
+   * (`<genomeDir>/icons/`) instead of pinning a path that ignores it. Kept out
+   * of the repo root on purpose: plenty of repos already have an `icons/`,
+   * and Flash's glyphs arriving in the middle of the team's own would be
+   * worse than one line of config to move them.
+   */
+  icons: z3.string().min(1).optional()
+});
+var GenomeCodebaseSchema = z3.object({
+  id: z3.string().min(1),
+  name: z3.string().min(1)
+});
+var GenomeConfigSchema = z3.object({
+  version: z3.literal(2),
+  /** The design system id in Flash Web this repo is bound to. */
+  genomeId: z3.number().int().positive(),
+  name: z3.string().min(1),
+  apiUrl: z3.string().url().default("https://flashdsm.com"),
+  /** The web revision the repo last pulled; drift is measured against it. */
+  revision: z3.union([z3.string(), z3.number()]).optional(),
+  /** Hash of the last pulled projection, as `documentToRepoBundle` computes it. */
+  contentHash: z3.string().optional(),
+  inputs: GenomeInputsSchema.default({}),
+  outputs: GenomeOutputsSchema.default({}),
+  framework: z3.string().optional(),
+  /** Absent only in configs written before codebase identity existed. */
+  codebase: GenomeCodebaseSchema.optional()
+});
+
+// ../core/dist/change-plan.js
+import { z as z4 } from "zod";
+var ChangeActionSchema = z4.enum(["create", "update", "skip", "flag"]);
+var ChangeTargetKindSchema = z4.enum([
+  "file",
+  "token",
+  "variable",
+  "style",
+  "component"
+]);
+var ChangePlanEntrySchema = z4.object({
+  action: ChangeActionSchema,
+  targetKind: ChangeTargetKindSchema,
+  /** Repo path, token name, variable path, style name, component id. */
+  path: z4.string().min(1),
+  /** The value on the target before; null when it did not exist. */
+  before: z4.string().nullable().optional(),
+  /** The value after; null when the entry removes the target. */
+  after: z4.string().nullable().optional(),
+  /** Why an entry is flagged or skipped, in a sentence a person can act on. */
+  reason: z4.string().optional(),
+  /** Machine code for the reason: `alias-missing`, `path-collision`, … */
+  code: z4.string().optional()
+});
+var ChangePlanCountsSchema = z4.object({
+  create: z4.number().int().nonnegative(),
+  update: z4.number().int().nonnegative(),
+  skip: z4.number().int().nonnegative(),
+  flag: z4.number().int().nonnegative()
+});
+var ChangePlanSchema = z4.object({
+  /** True when nothing was written; the entries say what would be. */
+  dryRun: z4.boolean(),
+  entries: z4.array(ChangePlanEntrySchema),
+  counts: ChangePlanCountsSchema
+});
+function countChangePlan(entries) {
+  const counts = { create: 0, update: 0, skip: 0, flag: 0 };
+  for (const entry of entries)
+    counts[entry.action] += 1;
+  return counts;
+}
+function makeChangePlan(entries, dryRun) {
+  return { dryRun, entries: [...entries], counts: countChangePlan(entries) };
+}
+function tokenChangeToPlanEntry(change) {
+  const base = {
+    targetKind: "token",
+    path: change.name,
+    before: change.before ?? null,
+    after: change.after ?? null
+  };
+  switch (change.kind) {
+    case "added":
+      return { ...base, action: "create" };
+    case "changed":
+      return { ...base, action: "update" };
+    case "removed":
+      return {
+        ...base,
+        action: "flag",
+        code: "removed",
+        reason: "Not in the incoming set; applying removes it from the system."
+      };
+  }
+}
+
+// ../core/dist/graph.js
+var FOUNDATION_ORDER = [
+  "colors",
+  "typography",
+  "spacing",
+  "radius",
+  "shadows",
+  "border",
+  "motion",
+  "effects",
+  "icons"
+];
+var isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var str = (v) => typeof v === "string" && v ? v : void 0;
+var list = (v) => Array.isArray(v) ? v : [];
+var byId = (a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+function plural(n, one, many) {
+  return `${n} ${n === 1 ? one : many}`;
+}
+function tokensOf(doc) {
+  const out = /* @__PURE__ */ new Map();
+  const foundations = isObject(doc.foundations) ? doc.foundations : {};
+  const lists = [
+    ...FOUNDATION_ORDER.map((key) => list(foundations[key])),
+    list(doc.semantics)
+  ];
+  for (const tokens of lists) {
+    for (const token of tokens) {
+      if (!isObject(token))
+        continue;
+      const key = str(token.id) ?? str(token.name);
+      if (key && !out.has(key))
+        out.set(key, token);
+    }
+  }
+  return out;
+}
+function resolver(tokens) {
+  const byName = /* @__PURE__ */ new Map();
+  const byLower = /* @__PURE__ */ new Map();
+  for (const [key, token] of tokens) {
+    const name = str(token.name);
+    if (name && !byName.has(name))
+      byName.set(name, key);
+    for (const candidate of [key, name]) {
+      if (candidate && !byLower.has(candidate.toLowerCase())) {
+        byLower.set(candidate.toLowerCase(), key);
+      }
+    }
+  }
+  return (ref) => {
+    const wanted = str(ref);
+    if (!wanted)
+      return void 0;
+    if (tokens.has(wanted))
+      return wanted;
+    return byName.get(wanted) ?? byLower.get(wanted.toLowerCase());
+  };
+}
+function edgesOf(doc, tokens, resolve2) {
+  const seen = /* @__PURE__ */ new Set();
+  const edges = [];
+  const add = (source, target, type = "alias_of") => {
+    if (!source || !target || source === target)
+      return;
+    const key = `${source}\0${target}`;
+    if (seen.has(key))
+      return;
+    seen.add(key);
+    edges.push({ source, target, type });
+  };
+  for (const relation of list(doc.relations?.tokens)) {
+    if (!isObject(relation))
+      continue;
+    add(resolve2(relation.source), resolve2(relation.target), str(relation.type) ?? "alias_of");
+  }
+  for (const [key, token] of tokens) {
+    add(key, resolve2(token.referencedTokenId));
+  }
+  return edges.sort((a, b) => a.source !== b.source ? a.source < b.source ? -1 : 1 : a.target < b.target ? -1 : a.target > b.target ? 1 : 0);
+}
+function bindingsOf(owner) {
+  const out = [];
+  for (const binding of list(owner.bindings)) {
+    if (!isObject(binding))
+      continue;
+    const slot = str(binding.slot);
+    const tokenId = str(binding.tokenId);
+    if (!slot || !tokenId)
+      continue;
+    const entry = { slot, tokenId };
+    const variantId = str(binding.variantId);
+    const stateId = str(binding.stateId);
+    if (variantId)
+      entry.variantId = variantId;
+    if (stateId)
+      entry.stateId = stateId;
+    out.push(entry);
+  }
+  return out;
+}
+function ownersOf(items) {
+  return items.filter((item) => isObject(item) && !!str(item.id) && !!str(item.name));
+}
+function tokenSummary(key, token) {
+  const out = { id: key, name: str(token.name) ?? key };
+  const layer = str(token.layer);
+  const category = str(token.category);
+  if (layer)
+    out.layer = layer;
+  if (category)
+    out.category = category;
+  return out;
+}
+function listModules(doc) {
+  const components = new Map(ownersOf(list(doc.components)).map((c) => [str(c.id), str(c.name)]));
+  return ownersOf(list(doc.modules)).map((module) => {
+    const used = [];
+    const seen = /* @__PURE__ */ new Set();
+    const parts = list(module.parts).filter(isObject);
+    for (const part of parts) {
+      const id = str(part.componentId);
+      if (!id || seen.has(id))
+        continue;
+      seen.add(id);
+      used.push({ id, name: components.get(id) ?? null });
+    }
+    return {
+      id: str(module.id),
+      name: str(module.name),
+      parts: parts.length,
+      components: used,
+      bindings: bindingsOf(module).length
+    };
+  });
+}
+function getModule(doc, ref) {
+  const modules = ownersOf(list(doc.modules));
+  const wanted = ref.trim().toLowerCase();
+  const module = modules.find((m) => str(m.id) === ref) ?? modules.find((m) => str(m.name) === ref) ?? modules.find((m) => str(m.id).toLowerCase() === wanted || str(m.name).toLowerCase() === wanted);
+  if (!module) {
+    return {
+      found: false,
+      available: modules.map((m) => str(m.name))
+    };
+  }
+  const components = new Map(ownersOf(list(doc.components)).map((c) => [str(c.id), str(c.name)]));
+  const parts = list(module.parts).filter(isObject).flatMap((part) => {
+    const slotId = str(part.slotId);
+    const componentId = str(part.componentId);
+    if (!slotId || !componentId)
+      return [];
+    const entry = {
+      slotId,
+      componentId,
+      componentName: components.get(componentId) ?? null
+    };
+    const variantId = str(part.variantId);
+    if (variantId)
+      entry.variantId = variantId;
+    return [entry];
+  });
+  return {
+    found: true,
+    module: {
+      id: str(module.id),
+      name: str(module.name),
+      parts,
+      bindings: bindingsOf(module)
+    }
+  };
+}
+function getRelations(doc, ref) {
+  const tokens = tokensOf(doc);
+  const resolve2 = resolver(tokens);
+  const edges = edgesOf(doc, tokens, resolve2);
+  const components = ownersOf(list(doc.components));
+  const modules = ownersOf(list(doc.modules));
+  if (ref === void 0 || ref === "") {
+    const bindings = [];
+    for (const [kind, owners2] of [
+      ["component", components],
+      ["module", modules]
+    ]) {
+      for (const owner of owners2) {
+        for (const binding of bindingsOf(owner)) {
+          bindings.push({ owner: kind, ownerId: str(owner.id), ...binding });
+        }
+      }
+    }
+    const parts = [];
+    for (const module of modules) {
+      for (const part of list(module.parts).filter(isObject)) {
+        const slotId = str(part.slotId);
+        const componentId = str(part.componentId);
+        if (!slotId || !componentId)
+          continue;
+        parts.push({ moduleId: str(module.id), slotId, componentId });
+      }
+    }
+    return { tokens: edges, bindings, parts };
+  }
+  const key = resolve2(ref);
+  if (!key)
+    return { found: false, token: ref };
+  const boundHere = (owner) => bindingsOf(owner).filter((b) => resolve2(b.tokenId) === key);
+  const owners = (items) => items.map((owner) => ({
+    id: str(owner.id),
+    name: str(owner.name),
+    bindings: boundHere(owner)
+  })).filter((o) => o.bindings.length).sort(byId);
+  return {
+    found: true,
+    token: tokenSummary(key, tokens.get(key)),
+    aliasOf: edges.filter((e) => e.source === key).map((e) => ({ id: e.target, type: e.type })),
+    aliasedBy: edges.filter((e) => e.target === key).map((e) => ({ id: e.source, type: e.type })),
+    components: owners(components),
+    modules: owners(modules)
+  };
+}
+function getImpact(doc, ref) {
+  const tokens = tokensOf(doc);
+  const resolve2 = resolver(tokens);
+  const root = resolve2(ref);
+  if (!root)
+    return { found: false, token: ref };
+  const edges = edgesOf(doc, tokens, resolve2);
+  const pointedAtBy = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    const sources = pointedAtBy.get(edge.target) ?? [];
+    sources.push(edge.source);
+    pointedAtBy.set(edge.target, sources);
+  }
+  const reached = /* @__PURE__ */ new Map();
+  let frontier = [root];
+  let depth = 0;
+  while (frontier.length) {
+    depth += 1;
+    const next = [];
+    for (const target of frontier) {
+      for (const source of (pointedAtBy.get(target) ?? []).slice().sort()) {
+        if (source === root || reached.has(source))
+          continue;
+        reached.set(source, { depth, via: target });
+        next.push(source);
+      }
+    }
+    frontier = next.sort();
+  }
+  const affected = /* @__PURE__ */ new Set([root, ...reached.keys()]);
+  const hits = (owner) => bindingsOf(owner).filter((b) => {
+    const key = resolve2(b.tokenId);
+    return key !== void 0 && affected.has(key);
+  });
+  const components = ownersOf(list(doc.components)).map((c) => ({ id: str(c.id), name: str(c.name), bindings: hits(c) })).filter((c) => c.bindings.length).sort(byId);
+  const affectedComponents = new Set(components.map((c) => c.id));
+  const modules = ownersOf(list(doc.modules)).map((m) => {
+    const reasons = hits(m).map((b) => ({ kind: "binding", ...b }));
+    for (const part of list(m.parts).filter(isObject)) {
+      const componentId = str(part.componentId);
+      const slotId = str(part.slotId);
+      if (componentId && slotId && affectedComponents.has(componentId)) {
+        reasons.push({ kind: "part", slotId, componentId });
+      }
+    }
+    return { id: str(m.id), name: str(m.name), reasons };
+  }).filter((m) => m.reasons.length).sort(byId);
+  const reachedTokens = [...reached.entries()].map(([id, r]) => ({
+    ...tokenSummary(id, tokens.get(id)),
+    depth: r.depth,
+    via: r.via
+  })).sort((a, b) => a.depth !== b.depth ? a.depth - b.depth : byId(a, b));
+  return {
+    found: true,
+    token: tokenSummary(root, tokens.get(root)),
+    tokens: reachedTokens,
+    components,
+    modules,
+    summary: `Changing ${root} reaches ${plural(reachedTokens.length, "token", "tokens")}, ${plural(components.length, "component", "components")} and ${plural(modules.length, "module", "modules")}.`
+  };
+}
+
+// src/load-tokens.ts
+import { readFile } from "fs/promises";
+import { dirname, isAbsolute, resolve } from "path";
+var CATEGORY_KEYS = TokenCategorySchema.options;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseToken(value) {
+  const result = TokenSchema.safeParse(value);
+  return result.success ? result.data : null;
+}
+function normalizeTokenDocument(raw) {
+  if (Array.isArray(raw)) {
+    return {
+      tokens: raw.map(parseToken).filter((t) => t !== null)
+    };
+  }
+  if (!isRecord(raw)) {
+    return { tokens: [] };
+  }
+  const name = typeof raw.name === "string" ? raw.name : void 0;
+  if (Array.isArray(raw.tokens)) {
+    return {
+      name,
+      tokens: raw.tokens.map(parseToken).filter((t) => t !== null)
+    };
+  }
+  const tokens = [];
+  for (const category of CATEGORY_KEYS) {
+    const bucket = raw[category];
+    if (!Array.isArray(bucket)) continue;
+    for (const item of bucket) {
+      if (!isRecord(item)) continue;
+      const withCategory = { ...item, category };
+      const token = parseToken(withCategory);
+      if (token) tokens.push(token);
+    }
+  }
+  const aliases = {
+    shadows: "shadow",
+    borderRadius: "radius",
+    color: "colors"
+  };
+  for (const [key, category] of Object.entries(aliases)) {
+    const bucket = raw[key];
+    if (!Array.isArray(bucket)) continue;
+    for (const item of bucket) {
+      if (!isRecord(item)) continue;
+      const withCategory = { ...item, category };
+      const token = parseToken(withCategory);
+      if (token) tokens.push(token);
+    }
+  }
+  return { name, tokens };
+}
+function configCandidates(explicit, cwd) {
+  if (explicit) {
+    return [isAbsolute(explicit) ? explicit : resolve(cwd, explicit)];
+  }
+  return [
+    resolve(cwd, GENOME_CONFIG_FILENAME),
+    resolve(cwd, LEGACY_CONFIG_FILENAME)
+  ];
+}
+async function loadConfig(configPath) {
+  try {
+    const text = await readFile(configPath, "utf8");
+    const parsed = JSON.parse(text);
+    if (!isRecord(parsed)) return null;
+    if (parsed.version === 2) {
+      const genome = GenomeConfigSchema.safeParse(parsed);
+      if (!genome.success) return null;
+      return {
+        version: 2,
+        name: genome.data.name,
+        tokenFile: genome.data.outputs.tokensDtcg
+      };
+    }
+    if (typeof parsed.tokenFile !== "string") return null;
+    return {
+      version: typeof parsed.version === "number" ? parsed.version : void 0,
+      name: typeof parsed.name === "string" ? parsed.name : void 0,
+      tokenFile: parsed.tokenFile
+    };
+  } catch {
+    return null;
+  }
+}
+async function resolveTokenFilePath(options) {
+  const cwd = options.cwd ?? process.cwd();
+  if (options.tokensPath) {
+    return isAbsolute(options.tokensPath) ? options.tokensPath : resolve(cwd, options.tokensPath);
+  }
+  for (const configPath of configCandidates(options.configPath, cwd)) {
+    const config = await loadConfig(configPath);
+    if (!config) continue;
+    const base = dirname(configPath);
+    return isAbsolute(config.tokenFile) ? config.tokenFile : resolve(base, config.tokenFile);
+  }
+  return resolve(cwd, "design-tokens.json");
+}
+async function loadTokensFromFile(tokenFile) {
+  const text = await readFile(tokenFile, "utf8");
+  const raw = JSON.parse(text);
+  const { tokens, name } = normalizeTokenDocument(raw);
+  return { source: tokenFile, tokens, name };
+}
+function filterTokensByCategory(tokens, category) {
+  if (!category) return tokens;
+  return tokens.filter((t) => t.category === category);
+}
+
+// src/tools/get-design-tokens.ts
+function parseCategoryInput(value) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const parsed = TokenCategorySchema.safeParse(value);
+  if (!parsed.success) {
+    throw new Error(
+      `Invalid category "${String(value)}". Expected one of: ${TokenCategorySchema.options.join(", ")}`
+    );
+  }
+  return parsed.data;
+}
+async function getDesignTokens(tokenFile, args = {}) {
+  const loaded = await loadTokensFromFile(tokenFile);
+  const tokens = filterTokensByCategory(loaded.tokens, args.category);
+  return {
+    source: loaded.source,
+    name: loaded.name,
+    category: args.category,
+    count: tokens.length,
+    tokens
+  };
+}
+
+export {
+  TokenTypeSchema,
+  TokenCategorySchema,
+  TokenSchema,
+  parseFlashAtomicDocument,
+  makeChangePlan,
+  tokenChangeToPlanEntry,
+  GENOME_CONFIG_FILENAME,
+  LEGACY_CONFIG_FILENAME,
+  GenomeConfigSchema,
+  listModules,
+  getModule,
+  getRelations,
+  getImpact,
+  normalizeTokenDocument,
+  configCandidates,
+  resolveTokenFilePath,
+  loadTokensFromFile,
+  parseCategoryInput,
+  getDesignTokens
+};