@flashdsm/genome 0.1.0 → 0.2.0

package/README.md

@@ -13,18 +13,28 @@ your project is enough.
 
 ## Connect it to a Flash design system
 
-Mint an MCP token in Flash under Connect, then in your repository:
+Sign in once. Genome opens Flash in the browser, the same OAuth flow Cursor uses, and stores the session under `~/.config/flash-dsm/`. Nothing is printed and nothing goes in the repo.
 
 ```bash
-export FLASH_GENOME_TOKEN=flash_mcp_…
+npx @flashdsm/genome login
 npx @flashdsm/genome link
 ```
 
-`link` asks the server which system the token belongs to and writes
-`genome.config.json` next to your code: the system's id, its revision, and
-where token files and agent context live. The token is never written to that
-file - it is committed, and a token in it would be a token in the
-repository's history.
+`link` asks the server which system you signed in to and writes `genome.config.json` next to your code.
+
+A script that cannot open a browser can still set `FLASH_GENOME_TOKEN` to a `flash_mcp_…` value. That is the same kind of token OAuth issues.
+
+## No design system yet? Start from your code
+
+In your app's folder, in a terminal or in your AI editor's chat:
+
+```bash
+npx @flashdsm/genome@latest connect
+```
+
+`connect` scans the folder (stylesheets, CSS inside JS/TS, Tailwind config, theme modules, tokens files; nothing else is read) and opens Flash in your browser, showing what it found and a short code that matches the one in your terminal. Click **Connect** there: Flash creates the system in your account, and the command links the repo (`genome.config.json`), writes the system into it (`pull --confirm`) and stores a token bound to that system under `~/.config/flash-dsm/`. Inside Claude Code it also adds Genome as the project's MCP server; elsewhere it prints the line to add. `--name` overrides the name, which otherwise comes from `package.json`; `--no-open` prints the link instead of opening it.
+
+The link works once and expires after 15 minutes. `init --code` does the same with a setup code instead of the browser.
 
 ## Quick start
 
@@ -50,6 +60,38 @@ With no flags it looks for `./genome.config.json`, then the older
 `./components.json`, and finally falls back to a small bundled fixture so the
 server always boots. It logs which file it resolved to stderr.
 
+## Project shell preview
+
+After `scan_workspace` creates a design system from local tokens, capture a
+running preview so Flash can show **Your project** in the editor:
+
+| Tool                    | What it does                                                              |
+| ----------------------- | ------------------------------------------------------------------------- |
+| `capture_project_shell` | Headless capture of a preview URL → upload + attach as `source: project`  |
+| `scan_usage`            | Where the repo's own components are used → the editor's "In your product" |
+
+**Localhost vs public URL:** Flash’s API cannot open `localhost` on your
+laptop, so Genome always captures on your machine (Playwright). Pass
+`http://localhost:6006/` (or any public `https://…` preview you can reach
+locally). The API only stores the sanitised HTML+CSS — it never fetches the
+URL for you. Full teammate loop: [docs/workflows/README.md](../../docs/workflows/README.md)
+§ E.
+
+Set an optional default URL in `genome.config.json`:
+
+```json
+{
+  "version": 2,
+  "genomeId": 42,
+  "name": "Acme Product",
+  "previewUrl": "http://localhost:6006/"
+}
+```
+
+Then call `capture_project_shell` with no `url`, or pass `url` and
+`designSystemId` explicitly. Sign in with `flash-genome login` or
+`FLASH_GENOME_TOKEN` (same credential as other hosted tools — never commit it).
+
 ## Keeping a repo in sync
 
 Once linked:
@@ -83,6 +125,34 @@ is ahead of `genome/genome.lock`, because a value left over from the last
 pull would otherwise look like an edit and undo someone's change. Pull,
 re-apply your edits, then push.
 
+### Tokens that change with the viewport
+
+A system with breakpoints writes each size that moves at its widest step,
+and lists every step beside it:
+
+```json
+"type-h1": {
+  "$value": "48px",
+  "$type": "font",
+  "$extensions": {
+    "com.flashdsm.breakpoints": [
+      { "name": "phone", "minWidth": 0, "value": "36px" },
+      { "name": "tablet", "minWidth": 768, "value": "42px" },
+      { "name": "desktop", "minWidth": 1280, "value": "48px" }
+    ]
+  }
+}
+```
+
+`tokens.css` carries the same steps as media queries, so `var(--type-h1)`
+is already responsive.
+
+A push carries the narrowest step only, because that is the one value Flash
+stores for the token. Change `phone` in the list and it is proposed like any
+other edit. Change `$value` or a wider step and it is flagged: set those
+sizes in Flash, then pull. A repo that pulled before Genome wrote steps is
+told to pull again.
+
 `AGENTS.md` is written once and then left alone however far it drifts: it is
 where a team puts its own instructions. The Cursor rule is Genome's to keep
 current, because a stale rule file is worse than none.
@@ -102,18 +172,20 @@ name. No linked repo needed.
 
 ## Tools
 
-| Tool                        | Args                | Description                                                      |
-| --------------------------- | ------------------- | ---------------------------------------------------------------- |
-| `get_tokens`                | `category?`         | Read tokens from the local token file. Read-only                 |
-| `list_components`           | `category?`         | List components from `components.json`                           |
-| `get_component`             | `name`              | One component spec                                               |
-| `get_brand_dna`             | -                   | Brand DNA from a sibling file or `tokens['dsm-brand-dna']`       |
-| `suggest_token`             | `context`           | Nearest-token suggestions for hex/px in a snippet. Deterministic |
-| `apply_token_patch`         | `patch`, `confirm?` | Upsert/remove tokens. Dry-run unless `confirm: true`             |
-| `generate_component_prompt` | `name`              | Handoff prompt for a component plus its tokens                   |
-| `check_violations`          | `file`              | Lint a source file for hardcoded colors / arbitrary Tailwind     |
-| `api_health`                | -                   | `GET {api}/health` against a Flash DSM backend                   |
-| `list_design_systems`       | -                   | List your systems from a Flash DSM backend (needs a token)       |
+| Tool                        | Args                                        | Description                                                      |
+| --------------------------- | ------------------------------------------- | ---------------------------------------------------------------- |
+| `get_tokens`                | `category?`                                 | Read tokens from the local token file. Read-only                 |
+| `list_components`           | `category?`                                 | List components from `components.json`                           |
+| `get_component`             | `name`                                      | One component spec                                               |
+| `get_brand_dna`             | -                                           | Brand DNA from a sibling file or `tokens['dsm-brand-dna']`       |
+| `suggest_token`             | `context`                                   | Nearest-token suggestions for hex/px in a snippet. Deterministic |
+| `apply_token_patch`         | `patch`, `confirm?`                         | Upsert/remove tokens. Dry-run unless `confirm: true`             |
+| `generate_component_prompt` | `name`                                      | Handoff prompt for a component plus its tokens                   |
+| `check_violations`          | `file`                                      | Lint a source file for hardcoded colors / arbitrary Tailwind     |
+| `capture_project_shell`     | `url?`, `designSystemId?`, `viewportWidth?` | Local preview capture → upload + attach (localhost OK)           |
+| `scan_usage`                | `designSystemId?`, `countsOnly?`, `dryRun?` | Count where components are used; `dryRun` sends nothing          |
+| `api_health`                | -                                           | `GET {api}/health` against a Flash DSM backend                   |
+| `list_design_systems`       | -                                           | List your systems from a Flash DSM backend (needs a token)       |
 
 Writes are guarded: `apply_token_patch` is a dry-run unless you pass
 `confirm: true`, so a curious agent cannot rewrite your tokens by accident.
@@ -140,6 +212,90 @@ flash-genome --tokens ./design-tokens.json --components ./components.json
 Against a backend on your own machine, pass
 `--api-url http://localhost:8008`.
 
+### Sync commands: `pull`, `push`, `drift`
+
+Scripts and CI need no MCP client. These run the same code as the MCP tools
+`pull_from_web`, `push_to_web` and `detect_drift`, in the repo that holds
+`genome.config.json` (run `link` first).
+
+```bash
+flash-genome pull                 # print what would be written; writes nothing
+flash-genome pull --confirm       # write the token files, the mirror and genome.lock
+flash-genome push                 # print the token edits that would be proposed
+flash-genome push --confirm       # open the change set for review in Flash
+flash-genome drift                # has the repo moved, has Flash, which tokens
+flash-genome drift --json         # the same, as one JSON object (for watchers)
+flash-genome pull --cwd ../web    # run against another repo root
+```
+
+| Flag                               | Applies to | Meaning                                                                    |
+| ---------------------------------- | ---------- | -------------------------------------------------------------------------- |
+| `--confirm`                        | pull, push | Write / propose. Without it the command is a dry run                       |
+| `--json`                           | all three  | Print one JSON object on stdout instead of the plan (errors too)           |
+| `--cwd`                            | all three  | Repo root (default: the current directory); `--config` resolves against it |
+| `--config`, `--api-url`, `--token` | all three  | As in the table above                                                      |
+
+The human output is the plan: `+ create`, `~ update`, `! flag` lines (a flag
+is something a person must look at), and a count of the unchanged items.
+
+**Exit codes**
+
+| Code | Meaning                                                                                                                                                                                                   |
+| ---- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `0`  | Done. A dry run that printed its plan is done. `drift` exits 0 whether or not it found drift: read the output                                                                                             |
+| `1`  | Refused or failed: `push` while Flash is ahead of the last pull, `push` or `drift` in a repo that never pulled, a `pull` where a file was flagged (refused or failed to write), or a network/server error |
+| `2`  | Auth or config: no token, a token Flash rejects (401/403), no `genome.config.json`, or a token for a different design system than the config names                                                        |
+
+**`--json` output.** Always one object on stdout, always with `ok`, `command`,
+`exitCode` (equal to the process exit code) and `schemaVersion` (currently
+`1`; it moves only if a field is removed or changes meaning, fields are
+otherwise only added).
+
+- `pull` / `push`: `{ ok, command, exitCode, schemaVersion, result }`, where
+  `result` is the tool's own result (the change plan: `dryRun`, `entries`,
+  `counts`, plus `written` for pull, `status` / `changeSetId` for push).
+- Any failure: `{ ok: false, command, exitCode, schemaVersion, error: { kind, message } }`
+  with `kind` one of `auth`, `config`, `refused`, `error`.
+- `drift`:
+
+```json
+{
+  "ok": true,
+  "command": "drift",
+  "exitCode": 0,
+  "schemaVersion": 1,
+  "genomeId": 42,
+  "state": "repo-dirty",
+  "neverPulled": false,
+  "flashAhead": false,
+  "dirty": true,
+  "pushable": 2,
+  "changedFiles": ["design-tokens.json"],
+  "missingFiles": [],
+  "changedTokens": [
+    {
+      "path": "color.brand-500 (dark)",
+      "before": "#2563eb",
+      "after": "#ff0000",
+      "code": "repo-edit"
+    }
+  ],
+  "pulledPublishedVersionId": 100,
+  "publishedVersionId": 100,
+  "pulledRevision": 7,
+  "revision": 7,
+  "summary": "The repo changed 2 token values. Run push_to_web to propose them for review in Flash."
+}
+```
+
+`state` is one of `in-step`, `flash-ahead` (Flash published since the pull),
+`repo-dirty` (a pulled file changed or is missing), `both`, `never-pulled`.
+`flashAhead` and `dirty` are the booleans behind it; `changedTokens` lists
+the token values the repo changed (`code: "repo-edit"`, what `push` would
+propose) and anything else a push does not carry (any other `code`).
+`never-pulled` is the one `drift` result with exit code `1` and `ok: false`;
+the object is still printed in full.
+
 ## Hosted alternative
 
 If your design system lives in Flash DSM, you may not need this package at all:

package/dist/{chunk-6OCQZNS7.js → chunk-PHEWKKKF.js}

@@ -29,6 +29,7 @@ var TokenCategorySchema = z.enum([
   "icons"
 ]);
 var TokenStatusSchema = z.enum(["active", "deprecated", "legacy"]);
+var ColorGroupTypeSchema = z.enum(["solid", "gradient"]);
 var TokenSchema = z.object({
   name: z.string(),
   value: z.string(),
@@ -43,6 +44,7 @@ var TokenSchema = z.object({
   foundationDetachedRowIds: z.array(z.string()).optional(),
   foundationServingRowIds: z.array(z.string()).optional(),
   metadata: z.record(z.any()).optional(),
+  responsive: z.record(z.string()).optional(),
   documentation: z.string().optional(),
   lastModified: z.number().optional(),
   lastSynced: z.number().optional(),
@@ -65,6 +67,7 @@ var TokenSchema = z.object({
     "focus"
   ]).optional(),
   referencedTokenId: z.string().optional(),
+  inheritsLight: z.boolean().optional(),
   tokenId: z.number().int().optional()
 });
 var DesignTokenSchema = z.object({
@@ -201,7 +204,10 @@ var AtomicBindingSchema = z2.object({
   variantId: z2.string().optional(),
   stateId: ComponentPreviewStateSchema.optional(),
   slot: BindingSlotSchema.or(z2.string().min(1)),
-  tokenId: z2.string().min(1)
+  tokenId: z2.string().min(1),
+  /** The Dark side, when it differs from Light (`tokenId`); missing, Dark
+   *  reads `tokenId`. */
+  darkTokenId: z2.string().min(1).optional()
 });
 var AtomicComponentProvenanceSchema = z2.object({
   figmaNodeId: z2.string().optional(),
@@ -339,357 +345,14 @@ var GenomeConfigSchema = z3.object({
   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
+  codebase: GenomeCodebaseSchema.optional(),
+  /**
+   * Local or public preview URL for `capture_project_shell` (Storybook,
+   * Vite preview, etc.). Capture runs on the developer machine, so
+   * localhost is fine — Flash’s servers never fetch this URL.
+   */
+  previewUrl: z3.string().url().optional()
 });
-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";
@@ -833,15 +496,9 @@ export {
   TokenCategorySchema,
   TokenSchema,
   parseFlashAtomicDocument,
-  makeChangePlan,
-  tokenChangeToPlanEntry,
   GENOME_CONFIG_FILENAME,
   LEGACY_CONFIG_FILENAME,
   GenomeConfigSchema,
-  listModules,
-  getModule,
-  getRelations,
-  getImpact,
   normalizeTokenDocument,
   configCandidates,
   resolveTokenFilePath,