@bridge-ds/core 0.6.0 → 0.7.0

package/dist/jira.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The Jira key given when a branch is created, normalised ("ds-42 " is "DS-42"), or null when empty. Throws a
+ * sentence that says how to fix it when the text is not a key.
+ */
+export declare function parseJiraKey(input: string | null | undefined): string | null;
+/** Whether a text is a Jira key, without throwing (for live field validation). */
+export declare const isJiraKey: (input: string) => boolean;
+/** The Jira key a title starts with ("DS-42 tokens: darker primary" gives "DS-42"), else null. */
+export declare function jiraKeyOf(title: string): string | null;
+/** The title without its leading Jira key. */
+export declare const withoutJiraKey: (title: string) => string;
+/** The pull request title with the key first: "DS-42 tokens: darker primary". Idempotent; no key, no change. */
+export declare function titleWithJiraKey(title: string, key: string | null): string;
+/** The branch name with the key first in its last part: "tokens/DS-42-darker-primary-20261019-1200". */
+export declare function branchWithJiraKey(branch: string, key: string | null): string;

package/dist/library-update.d.ts

@@ -0,0 +1,145 @@
+import type { GitHubClient, TreeEntry } from './github-client';
+import { type LayoutOptions, type TokenSet } from './token-set';
+import { type ContrastPair } from './wcag';
+import { type MergeChoices, type TokenMergeConflict, type TokenMergeInput, type TokenMergePlan } from './token-merge';
+/** A file of a compare (GET /repos/{o}/{r}/compare/{base}...{head}). */
+export interface CompareFile {
+    filename: string;
+    status: string;
+    previous_filename?: string | undefined;
+    sha?: string | null | undefined;
+}
+/** Files both the branch and main changed since they parted, split into token files and the rest (code). */
+export declare function overlap(changeFiles: CompareFile[], libraryFiles: CompareFile[], isTokenFile: (path: string) => boolean): {
+    tokenFiles: string[];
+    codeFiles: string[];
+};
+/** GitHub lists at most 300 files per compare: past that, Bridge cannot know what both sides touched. */
+export declare const COMPARE_FILE_LIMIT = 300;
+export type ConflictRoute = {
+    kind: 'tokens';
+    files: string[];
+} | {
+    kind: 'code';
+    alsoTokens: boolean;
+    files: string[];
+};
+/**
+ * Who resolves the conflict. Only token files on both sides: the designer, in Bridge. Any code file on both sides, a
+ * file list GitHub cut short, or no shared file at all (GitHub saw a conflict Bridge cannot explain): a developer.
+ */
+export declare function conflictRoute(o: {
+    tokenFiles: string[];
+    codeFiles: string[];
+}, opts?: {
+    truncated?: boolean;
+}): ConflictRoute;
+/** A rule from GET /repos/{o}/{r}/rules/branches/{branch}. */
+export interface BranchRuleLike {
+    type: string;
+    parameters?: {
+        dismiss_stale_reviews_on_push?: boolean;
+    } | null;
+}
+/**
+ * Whether GitHub dismisses approvals when new commits arrive, from the rules that apply to the library branch. True
+ * or false when a pull request rule says so; null when no rule says (classic branch protection is not readable
+ * without admin rights).
+ */
+export declare function dismissStaleFrom(rules: BranchRuleLike[] | null | undefined): boolean | null;
+/** The commit message of the resolution, so History and the branch say what the person chose. */
+export declare function resolutionMessage(input: {
+    library: string;
+    conflicts: TokenMergeConflict[];
+    choices: MergeChoices;
+    who?: string | null | undefined;
+}): string;
+export type LibraryState = 'current' | 'behind' | 'conflict' | 'unknown';
+export interface Freshness {
+    state: LibraryState;
+    /** Library updates (commits on the library branch) since the change started; null when not read. */
+    behindBy: number | null;
+    /** The commit the change and the library share. */
+    mergeBase: string | null;
+}
+/**
+ * How the change stands against the latest library. A conflict (mergeable false) wins: GitHub cannot combine them.
+ * Otherwise it is behind when the library has commits the change has not. A shipped or closed change has nothing to
+ * bring in. A compare that could not be read says unknown, never "up to date".
+ */
+export declare function freshness<C extends {
+    behind_by?: number | undefined;
+    merge_base_commit?: {
+        sha: string;
+    } | null | undefined;
+}>(input: {
+    compare: C | null | undefined;
+    mergeable: boolean | null | undefined;
+    open: boolean;
+}): Freshness;
+/** The compare of main and a branch head, in the shape the conflict reader needs (client.compareDetailed). */
+export interface LibraryCompare {
+    mergeBase: string | null;
+    baseSha: string | null;
+    baseTree: string | null;
+    files: CompareFile[];
+}
+export interface LibraryConflicts {
+    route: ConflictRoute;
+    /** Present for a pure token-file conflict. */
+    tokens?: {
+        root: string;
+        plan: TokenMergePlan;
+        input: TokenMergeInput;
+        sets: {
+            base: TokenSet;
+            mine: TokenSet;
+            theirs: TokenSet;
+        };
+        /** Every token file of each side, relative to the tokens root. */
+        mineFiles: Record<string, string>;
+        theirsFiles: Record<string, string>;
+        pairs: ContrastPair[];
+        options: LayoutOptions;
+    };
+    /** What the commit needs: main's tip and its tree, the branch head tree and its own files. */
+    write?: {
+        mainSha: string;
+        mainTree: string;
+        headSha: string;
+        headTree: Map<string, TreeEntry>;
+        changeFiles: CompareFile[];
+    };
+}
+/**
+ * What conflicts and who resolves it. Reads the files main changed since the branch started (one compare), then, for
+ * a pure token-file conflict, the token files at the shared start, in the branch and in main. `tokensRoot` is the
+ * best guess before the config is read (Studio: its site config); `contrastFallback` the contrast checks to use when
+ * main has none.
+ */
+export declare function readLibraryConflicts(gh: GitHubClient, compare: LibraryCompare, headSha: string, opts?: {
+    tokensRoot?: string | undefined;
+    contrastFallback?: string | undefined;
+}): Promise<LibraryConflicts>;
+/**
+ * Every token file once resolved, relative to the tokens root: main's files, the branch's own token files where only
+ * the branch touched them, and the merged files where both did.
+ */
+export declare function resolvedTokenFiles(data: LibraryConflicts, choices: MergeChoices): {
+    all: Record<string, string>;
+    merged: Record<string, string | null>;
+};
+/**
+ * Commits the resolution to the branch: a merge commit of main and the branch, whose tree is main plus the branch's
+ * own files plus the merged token files. Fast-forward only: when the branch moved meanwhile, GitHub refuses and
+ * nothing is lost.
+ */
+export declare function commitLibraryResolution(gh: GitHubClient, pull: {
+    head: {
+        ref: string;
+        sha: string;
+    };
+    base: {
+        ref: string;
+    };
+}, data: LibraryConflicts, choices: MergeChoices, who: string | null | undefined): Promise<string>;

package/dist/node/component-specs.d.ts

@@ -3,6 +3,8 @@ import { buildTokenSet } from '../token-set';
 export interface TokenInfo {
     path: string;
     type: string;
+    /** Durations and easings: the value in the default modes (`{ value: 150, unit: 'ms' }`, `[0.2, 0, 0, 1]`), for motion. */
+    value?: unknown;
 }
 export interface SpecGeneratorOptions {
     /** Repo-relative components directory ("packages/react/src/components"). */

package/dist/node/index.d.ts

@@ -3,3 +3,4 @@ export * from './git-history';
 export * from './audit';
 export * from './component-specs';
 export * from './spec-css';
+export * from './spec-motion';

package/dist/node/index.js

@@ -2,7 +2,7 @@ import { execFile } from "node:child_process";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve, relative, dirname, sep, posix } from "node:path";
-import { a as assertSafeBranch, c as collectHistory, p as packageDirCandidates, b as parseChangelog, m as mergeReleases, r as releasesFromTags, d as buildReport, e as prNumberFromSubject, l as loadConfig, s as specHash, v as validateComponentSpec, h as hashSpec, i as iconComponentName, f as variantKeyOf, C as CONFIG_FILE, g as layoutOptions, j as buildTokenSet, t as tokenCssVar, k as COMPONENT_SPECS_VERSION, n as COLOR_FIELDS } from "../component-spec-GFVEE6Fc.js";
+import { a as assertSafeBranch, c as collectHistory, p as packageDirCandidates, b as parseChangelog, m as mergeReleases, r as releasesFromTags, d as buildReport, e as prNumberFromSubject, l as loadConfig, s as specHash, v as validateComponentSpec, h as hashSpec, i as iconComponentName, f as variantKeyOf, C as CONFIG_FILE, g as layoutOptions, j as buildTokenSet, k as defaultContext, t as tokenCssVar, n as resolve$1, o as COMPONENT_SPECS_VERSION, q as COLOR_FIELDS } from "../component-spec-1z2ih4E3.js";
 import { s as selectTokenFiles, g as globToRegExp, L as LayeredTokenSet } from "../layered-BnbmToGs.js";
 import { statSync, readFileSync, existsSync, writeFileSync, readdirSync } from "node:fs";
 import { v as isAuditable, Q as planCssFixes, O as parseAllowlist, c as DesignSystemIndex, k as buildAuditReport, n as compareWithBaseline, a as AUDIT_IGNORE_DIRS } from "../report-iPSnsjYi.js";
@@ -784,6 +784,236 @@ function computeValues(own, parent) {
   }
   return out;
 }
+const KEYWORDS = {
+  ease: [0.25, 0.1, 0.25, 1],
+  "ease-in": [0.42, 0, 1, 1],
+  "ease-out": [0, 0, 0.58, 1],
+  "ease-in-out": [0.42, 0, 0.58, 1]
+};
+const SILENT = /^(cursor|pointer-events|user-select|-webkit-.*|transition.*|animation.*|will-change|outline.*|content|touch-action)$/;
+function substituteVars(raw, computed, tokens, depth = 0) {
+  if (depth > 12) return raw;
+  return raw.replace(/var\(\s*(--[\w-]+)\s*(?:,\s*([^()]*(?:\([^()]*\)[^()]*)*))?\)/g, (m, name, fallback) => {
+    if (tokens.has(name)) return m;
+    const v = computed.get(name);
+    if (v !== void 0 && v !== "initial") return substituteVars(v, computed, tokens, depth + 1);
+    return fallback !== void 0 ? substituteVars(fallback.trim(), computed, tokens, depth + 1) : m;
+  });
+}
+const isTime = (t, tokens) => /^-?[\d.]+m?s$/i.test(t) || tokens.get(varName(t) ?? "")?.type === "duration";
+const varName = (t) => /^var\(\s*(--[\w-]+)/.exec(t)?.[1];
+function parseTransitions(computed, tokens) {
+  const sub = (k) => {
+    const v = computed.get(k);
+    return v === void 0 ? void 0 : substituteVars(v, computed, tokens);
+  };
+  const out = [];
+  const short = sub("transition");
+  if (short && short !== "none") {
+    for (const item of splitTop(short, ",")) {
+      const words = splitTop(item.trim(), /\s/).filter(Boolean);
+      const e = { property: "all", duration: "0s", easing: "ease", delay: "0s" };
+      let times = 0;
+      for (const w of words) {
+        if (isTime(w, tokens)) {
+          if (times++ === 0) e.duration = w;
+          else e.delay = w;
+        } else if (KEYWORDS[w] || w === "linear" || /^(cubic-bezier|steps|linear)\(/.test(w) || /^step-(start|end)$/.test(w) || tokens.get(varName(w) ?? "")?.type === "cubicBezier") e.easing = w;
+        else e.property = w;
+      }
+      out.push(e);
+    }
+  }
+  const props = sub("transition-property");
+  if (props === void 0) return out;
+  const list = (k, def) => {
+    const v = sub(k);
+    return v === void 0 ? [def] : splitTop(v, ",").map((x) => x.trim());
+  };
+  const durations = list("transition-duration", "0s");
+  const easings = list("transition-timing-function", "ease");
+  const delays = list("transition-delay", "0s");
+  return splitTop(props, ",").map((p) => p.trim()).filter((p) => p && p !== "none").map((property, i) => ({ property, duration: durations[i % durations.length], easing: easings[i % easings.length], delay: delays[i % delays.length] }));
+}
+function resolveDuration(raw, tokens) {
+  const v = raw.trim();
+  const lit = /^(-?[\d.]+)(m?s)$/i.exec(v);
+  if (lit) return { ms: Number(lit[1]) * (lit[2].toLowerCase() === "s" ? 1e3 : 1) };
+  const t = tokens.get(varName(v) ?? "");
+  if (!t || t.type !== "duration") return void 0;
+  const value = t.value;
+  if (typeof value === "string") {
+    const r = resolveDuration(value, /* @__PURE__ */ new Map());
+    return r ? { ms: r.ms, token: t.path } : void 0;
+  }
+  if (value && typeof value.value === "number") return { ms: value.value * (value.unit === "s" ? 1e3 : 1), token: t.path };
+  return void 0;
+}
+function resolveEasing(raw, tokens) {
+  const v = raw.trim().toLowerCase();
+  const curve = (b) => b[0] === 0 && b[1] === 0 && b[2] === 1 && b[3] === 1 ? { type: "LINEAR" } : { type: "CUSTOM_CUBIC_BEZIER", bezier: [b[0], b[1], b[2], b[3]] };
+  if (v === "linear") return { easing: { type: "LINEAR" } };
+  if (KEYWORDS[v]) return { easing: curve(KEYWORDS[v]) };
+  const cb = /^cubic-bezier\(([^)]*)\)$/.exec(v);
+  if (cb) {
+    const n = cb[1].split(",").map((x) => Number(x.trim()));
+    return n.length === 4 && n.every((x) => Number.isFinite(x)) ? { easing: curve(n) } : void 0;
+  }
+  if (/^(steps\(|step-(start|end)$)/.test(v)) return { easing: { type: "LINEAR" }, approximated: `${raw.trim()} moves in steps, Figma has no stepped easing: linear` };
+  if (/^linear\(/.test(v)) return { easing: { type: "LINEAR" }, approximated: "a linear() curve has no Figma easing: linear" };
+  const t = tokens.get(varName(raw.trim()) ?? "");
+  if (!t || t.type !== "cubicBezier") return void 0;
+  const value = t.value;
+  if (Array.isArray(value) && value.length === 4 && value.every((x) => typeof x === "number")) return { easing: curve(value), token: t.path };
+  if (typeof value === "string") {
+    const r = resolveEasing(value, /* @__PURE__ */ new Map());
+    return r ? { ...r, token: t.path } : void 0;
+  }
+  return void 0;
+}
+const shorthandOf = (prop) => prop.replace(/-(top|bottom)-(left|right)(?=-|$)/, "").replace(/-(top|right|bottom|left)(?=-|$)/, "").replace(/-(block|inline)(-(start|end))?(?=-|$)/, "");
+function entryFor(prop, entries) {
+  const general = shorthandOf(prop);
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const p = entries[i].property;
+    if (p === "all" || p === prop || p === general || prop.startsWith(`${p}-`) || general.startsWith(`${p}-`)) return entries[i];
+  }
+  return void 0;
+}
+function changedProperties(from, to, tokens) {
+  const a = from ?? /* @__PURE__ */ new Map();
+  const b = to ?? /* @__PURE__ */ new Map();
+  const out = [];
+  for (const k of /* @__PURE__ */ new Set([...a.keys(), ...b.keys()])) {
+    if (k.startsWith("--") || SILENT.test(k)) continue;
+    const x = a.get(k);
+    const y = b.get(k);
+    if ((x === void 0 ? void 0 : substituteVars(x, a, tokens)) !== (y === void 0 ? void 0 : substituteVars(y, b, tokens))) out.push(k);
+  }
+  return out.sort();
+}
+const fmtMs = (ms) => `${Math.round(ms)} ms`;
+function transitionBetween(from, to, tokens) {
+  const animated = [];
+  for (const id of /* @__PURE__ */ new Set([...from.keys(), ...to.keys()])) {
+    const changed = changedProperties(from.get(id), to.get(id), tokens);
+    if (!changed.length) continue;
+    const entries = parseTransitions(to.get(id) ?? /* @__PURE__ */ new Map(), tokens);
+    for (const prop of changed) {
+      const e = entryFor(prop, entries);
+      if (!e) continue;
+      const d = resolveDuration(e.duration, tokens);
+      const ease = resolveEasing(e.easing, tokens);
+      if (!d || d.ms <= 0 || !ease) continue;
+      const delay = resolveDuration(e.delay, tokens)?.ms ?? 0;
+      animated.push({ prop, ms: d.ms, ...d.token ? { durationToken: d.token } : {}, easing: ease.easing, ...ease.token ? { easingToken: ease.token } : {}, ...ease.approximated ? { approximated: ease.approximated } : {}, delay });
+    }
+  }
+  if (!animated.length) return null;
+  const main = animated.reduce((m, x) => x.ms > m.ms ? x : m, animated[0]);
+  const notes = [];
+  const speeds = new Set(animated.map((x) => `${x.ms}|${JSON.stringify(x.easing)}`));
+  if (speeds.size > 1) {
+    const others = [...new Set(animated.filter((x) => x.ms !== main.ms).map((x) => fmtMs(x.ms)))];
+    notes.push(others.length ? `parts move at ${[fmtMs(main.ms), ...others].join(" and ")} in code, Figma plays one speed: ${fmtMs(main.ms)}` : "parts use different easings in code, Figma plays one");
+  }
+  if (animated.some((x) => x.delay > 0)) notes.push("a transition delay in code is not played");
+  for (const x of animated) if (x.approximated && !notes.includes(x.approximated)) notes.push(x.approximated);
+  return {
+    duration: main.ms,
+    ...main.durationToken ? { durationToken: main.durationToken } : {},
+    easing: main.easing,
+    ...main.easingToken ? { easingToken: main.easingToken } : {},
+    properties: [...new Set(animated.map((x) => shorthandOf(x.prop)))].sort(),
+    ...notes.length ? { approximated: notes.join("; ") } : {}
+  };
+}
+function targetClasses(rule) {
+  const last = rule.selector.parts[rule.selector.parts.length - 1];
+  return (last?.compound ?? []).filter((s) => s.t === "class").map((s) => `${rule.module}|${s.name}`);
+}
+const OPEN_ATTR = /\[data-(starting-style|ending-style|open|closed|popup-open|panel-open|expanded)\]/;
+function motionNotes(rules, classes, tokens, view, elements = [...classes].map((c) => [c])) {
+  const out = [];
+  const add = (n) => {
+    if (!out.some((x) => x.what === n.what)) out.push(n);
+  };
+  const styled = (r) => targetClasses(r).some((c) => classes.has(c));
+  const opened = /* @__PURE__ */ new Set();
+  for (const r of rules) {
+    if (!styled(r)) continue;
+    const values = new Map(r.decls.map((d) => [d.prop, d.value]));
+    const anim = values.get("animation") ?? values.get("animation-name");
+    if (anim && !/^none\b/.test(anim.trim())) {
+      const words = splitTop(anim.trim(), /\s/).filter(Boolean);
+      const name = values.get("animation-name") ?? words.find((w) => !isTime(w, tokens) && !resolveEasing(w, tokens) && !/^(infinite|\d+|alternate|reverse|normal|forwards|backwards|both|running|paused)$/.test(w));
+      const dur = words.map((w) => resolveDuration(w, tokens)).find(Boolean) ?? (values.get("animation-duration") ? resolveDuration(values.get("animation-duration"), tokens) : void 0);
+      const loops = /\binfinite\b/.test(anim) || values.get("animation-iteration-count") === "infinite";
+      add({
+        what: `${loops ? "Looping animation" : "Keyframe animation"} ${name ?? ""}${dur ? `, ${fmtMs(dur.ms)}` : ""}`.replace(/\s+,/, ",").trim(),
+        reason: loops ? "a Figma component cannot loop an animation on its own" : "keyframes have no Figma equivalent between variants",
+        ...dur?.token ? { durationToken: dur.token } : {}
+      });
+    }
+    if (/:focus(-visible|-within)?\b/.test(r.text)) add({ what: "Keyboard focus", reason: "the focus ring shows when a keyboard moves to the component; Figma prototypes have no focus state" });
+    if (OPEN_ATTR.test(r.text)) {
+      for (const c of targetClasses(r)) if (classes.has(c)) opened.add(c);
+      add({
+        what: view === "popup" ? "Opening and closing the popup" : "Opening and closing",
+        reason: view === "popup" ? "the popup is its own set; a Figma component cannot open another one from its trigger" : "the open state is not drawn as a variant"
+      });
+    }
+  }
+  const note = out.find((n) => n.what.startsWith("Opening and closing"));
+  if (note) {
+    const { enter, exit } = openingTransitions(rules, elements.filter((el) => el.some((c) => opened.has(c))), tokens);
+    if (enter) note.enter = enter;
+    if (exit) note.exit = exit;
+  }
+  return out;
+}
+const ENDING_ATTR = /\[data-(ending-style|closed)\]/;
+const STATE_PSEUDO = /:(hover|active|focus|focus-visible|focus-within|disabled|checked)\b/;
+function openingTransitions(rules, elements, tokens) {
+  const best = {};
+  for (const el of elements) {
+    const mine = rules.filter((r) => targetClasses(r).some((c) => el.includes(c))).sort((a, b) => a.order - b.order);
+    const base = mine.filter((r) => !/\[data-/.test(r.text) && !STATE_PSEUDO.test(r.text));
+    const states = mine.filter((r) => OPEN_ATTR.test(r.text));
+    const opens = states.filter((r) => !/\[data-(starting-style|ending-style|closed)\]/.test(r.text));
+    const endings = states.filter((r) => ENDING_ATTR.test(r.text));
+    const changed = new Set(states.flatMap((r) => r.decls.map((d) => d.prop)).filter((p) => !p.startsWith("--") && !SILENT.test(p)));
+    if (!changed.size) continue;
+    const settle = (list) => {
+      const computed = /* @__PURE__ */ new Map();
+      for (const r of [...list].sort((a, b) => a.order - b.order)) for (const d of r.decls) computed.set(d.prop, d.value);
+      return computed;
+    };
+    const find = (computed) => {
+      const entries = parseTransitions(computed, tokens);
+      let main;
+      const props = /* @__PURE__ */ new Set();
+      for (const prop of changed) {
+        const e = entryFor(prop, entries);
+        if (!e) continue;
+        const d = resolveDuration(e.duration, tokens);
+        const ease = resolveEasing(e.easing, tokens);
+        if (!d || d.ms <= 0 || !ease) continue;
+        props.add(shorthandOf(prop));
+        if (!main || d.ms > main.ms) main = { ms: d.ms, ...d.token ? { durationToken: d.token } : {}, easing: ease.easing, ...ease.token ? { easingToken: ease.token } : {}, props };
+      }
+      return main;
+    };
+    for (const [dir, found] of [["enter", find(settle([...base, ...opens]))], ["exit", find(settle([...base, ...endings]))]]) {
+      if (!found) continue;
+      const cur = best[dir];
+      if (!cur || found.ms > cur.ms) best[dir] = { ...found, props: /* @__PURE__ */ new Set([...cur?.props ?? [], ...found.props]) };
+      else for (const p of found.props) cur.props.add(p);
+    }
+  }
+  const out = (f) => f ? { duration: f.ms, ...f.durationToken ? { durationToken: f.durationToken } : {}, easing: f.easing, ...f.easingToken ? { easingToken: f.easingToken } : {}, properties: [...f.props].sort() } : null;
+  return { enter: out(best.enter), exit: out(best.exit) };
+}
 const STATES = [
   { name: "Default", state: DEFAULT_STATE },
   { name: "Hover", state: { hover: true, active: false, disabled: false } },
@@ -2802,6 +3032,15 @@ function generateComponentSpec(name, opts, view, setName = name, fixed = {}) {
       delete e.props[axis.name];
     }
   }
+  const interactions = deriveInteractions(axes, evaluated, opts.tokens, /radio/i.test(setName));
+  const drawnClasses = /* @__PURE__ */ new Set();
+  const drawnElements = /* @__PURE__ */ new Map();
+  for (const { ev } of evaluated)
+    for (const n of ev.built.parts.values()) {
+      for (const c of n.classes) drawnClasses.add(c);
+      if (n.classes.length) drawnElements.set([...n.classes].sort().join(" "), [...n.classes]);
+    }
+  const motion = motionNotes(rules, drawnClasses, opts.tokens, view, [...drawnElements.values()]);
   const variants = [];
   const unmapped = [];
   const neverShown = new Set(order.filter((id) => evaluated.every((e) => e.ev.hidden.has(id))));
@@ -2907,8 +3146,50 @@ function generateComponentSpec(name, opts, view, setName = name, fixed = {}) {
     ...view ? { view } : {},
     ...example ? { example } : {}
   };
-  const spec = { name: setName, ...component, source, axes, properties, parts, variants, unmapped: dedup };
-  return { name: setName, ...component, hash: hashSpec(spec), source, axes, properties, parts, variants, unmapped: dedup };
+  const motionFields = { ...interactions.length ? { interactions } : {}, ...motion.length ? { motion } : {} };
+  const spec = { name: setName, ...component, source, axes, properties, parts, variants, unmapped: dedup, ...motionFields };
+  return { name: setName, ...component, hash: hashSpec(spec), source, axes, properties, parts, variants, unmapped: dedup, ...motionFields };
+}
+function deriveInteractions(axes, evaluated, tokens, radio) {
+  const byKey = new Map(evaluated.map((e) => [variantKeyOf(e.props), e]));
+  const state = axes.find((a) => a.name === "State");
+  const checked = axes.find((a) => a.name === "Checked");
+  const rules = [];
+  if (state) {
+    const has = (v) => state.values.includes(v);
+    if (has("Hover")) {
+      if (checked) rules.push({ trigger: "MOUSE_ENTER", axis: "State", from: "Default", to: "Hover" }, { trigger: "MOUSE_LEAVE", axis: "State", from: "Hover", to: "Default" });
+      else rules.push({ trigger: "ON_HOVER", axis: "State", from: "Default", to: "Hover" });
+    }
+    if (has("Pressed")) rules.push({ trigger: "ON_PRESS", axis: "State", from: has("Hover") ? "Hover" : "Default", to: "Pressed" });
+  }
+  if (checked) {
+    const pairs = [["false", "true"]];
+    if (!radio) pairs.push(["true", "false"]);
+    if (checked.values.includes("mixed")) pairs.push(["mixed", "true"]);
+    const only = (p) => p.State === void 0 || p.State === "Default" || p.State === "Hover";
+    for (const [from, to] of pairs) rules.push({ trigger: "ON_CLICK", axis: "Checked", from, to, only });
+  }
+  const out = [];
+  for (const r of rules) {
+    const groups = /* @__PURE__ */ new Map();
+    let candidates = 0;
+    for (const e of evaluated) {
+      if (e.props[r.axis] !== r.from) continue;
+      candidates++;
+      if (r.only && !r.only(e.props)) continue;
+      const target = byKey.get(variantKeyOf({ ...e.props, [r.axis]: r.to }));
+      if (!target || drawn(target.ev) === drawn(e.ev)) continue;
+      const transition = transitionBetween(e.ev.computed, target.ev.computed, tokens);
+      const k = JSON.stringify(transition);
+      const g = groups.get(k) ?? { transition, keys: [] };
+      g.keys.push(variantKeyOf(e.props));
+      groups.set(k, g);
+    }
+    const total = [...groups.values()].reduce((n, g) => n + g.keys.length, 0);
+    for (const g of groups.values()) out.push({ trigger: r.trigger, axis: r.axis, from: r.from, to: r.to, ...groups.size > 1 || total < candidates ? { variants: g.keys } : {}, transition: g.transition });
+  }
+  return out;
 }
 function specDrawsSomething(spec) {
   const kinds = new Map(spec.parts.map((p) => [p.id, p]));
@@ -3286,9 +3567,12 @@ function draftedSpec(folder, opts) {
 function tokenCssIndex(files, opts = {}) {
   const set = buildTokenSet(files, opts.layout ?? {});
   const out = /* @__PURE__ */ new Map();
+  const ctx = defaultContext(set);
   for (const t of set.tokens.values()) {
     const v = tokenCssVar(t.path, opts.prefix, opts.separator);
-    if (!out.has(v)) out.set(v, { path: t.path, type: t.type });
+    if (out.has(v)) continue;
+    const value = t.type === "duration" || t.type === "cubicBezier" ? resolve$1(set.byPath, t.path, ctx).value : void 0;
+    out.set(v, { path: t.path, type: t.type, ...value !== void 0 ? { value } : {} });
   }
   return out;
 }
@@ -3333,6 +3617,7 @@ export {
   MEDIA_SLOT,
   UnsupportedComponentError,
   branchExists,
+  changedProperties,
   collectAuditFiles,
   commitToNewLocalBranch,
   computeValues,
@@ -3340,6 +3625,7 @@ export {
   declaredFor,
   draftedCodeHash,
   draftedSpec,
+  entryFor,
   expandDecl,
   findDesignSystemRoot,
   fixCss,
@@ -3360,17 +3646,25 @@ export {
   localTags,
   matchComplex,
   mediaApplies,
+  motionNotes,
+  openingTransitions,
   originRepo,
   overridesDirOf,
   parseCssModule,
   parseSelector,
+  parseTransitions,
   repoSpecOptions,
+  resolveDuration,
+  resolveEasing,
   runAudit,
   sentenceCase,
   serializeComponentSpecs,
+  shorthandOf,
   showFile,
   specDrawsSomething,
   splitTop,
-  tokenCssIndex
+  substituteVars,
+  tokenCssIndex,
+  transitionBetween
 };
 //# sourceMappingURL=index.js.map