rastack 0.0.57 → 0.0.59

package/test/tokens.spec.ts

@@ -1,302 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
-import { join } from "path";
-import {
-  defineTheme,
-  defineTokens,
-  emitCss,
-  emitTs,
-  cssVarName,
-  formatCssValue,
-  ref,
-  resolveTokens,
-  resolveTheme,
-  t,
-  ThemedTokens,
-  TokenDocument,
-} from "../src/tokens";
-import { compileTokens, loadTokens } from "../src/tokens/compile";
-import { renderStudio } from "../src/tokens/studio";
-
-const workRoot = join(__dirname, "tokens-fixtures");
-
-function findTok<T extends { path: string }>(list: T[], path: string): T {
-  const found = list.find((x) => x.path === path);
-  if (!found) throw new Error(`missing token ${path}`);
-  return found;
-}
-
-describe("design tokens — resolution", () => {
-  it("inherits a group $type down to its tokens", () => {
-    const doc: TokenDocument = {
-      color: { $type: "color", brand: { 500: { $value: "#4F6BFF" } } },
-    };
-    const resolved = resolveTokens(doc);
-    expect(findTok(resolved, "color.brand.500").type).toBe("color");
-  });
-
-  it("resolves alias values transitively and records the immediate target", () => {
-    const doc: TokenDocument = {
-      color: {
-        $type: "color",
-        brand: { 500: { $value: "#4F6BFF" } },
-        accent: { $value: ref("color.brand.500") },
-        cta: { $value: ref("color.accent") },
-      },
-    };
-    const resolved = resolveTokens(doc);
-    const accent = findTok(resolved, "color.accent");
-    const cta = findTok(resolved, "color.cta");
-    expect(accent.value).toBe("#4F6BFF");
-    expect(accent.aliasOf).toBe("color.brand.500");
-    // transitive: cta -> accent -> brand.500
-    expect(cta.value).toBe("#4F6BFF");
-    expect(cta.aliasOf).toBe("color.accent");
-  });
-
-  it("throws on a dangling alias", () => {
-    const doc: TokenDocument = { color: { a: { $type: "color", $value: ref("color.missing") } } };
-    expect(() => resolveTokens(doc)).toThrow(/unknown token "color.missing"/);
-  });
-
-  it("throws on an alias cycle", () => {
-    const doc: TokenDocument = {
-      a: { $type: "color", $value: ref("b") },
-      b: { $type: "color", $value: ref("a") },
-    };
-    expect(() => resolveTokens(doc)).toThrow(/cycle/i);
-  });
-
-  it("names CSS variables from dotted paths (kebab, camel-split, prefix)", () => {
-    expect(cssVarName("color.brand.500")).toBe("--color-brand-500");
-    expect(cssVarName("color.surfaceAlt")).toBe("--color-surface-alt");
-    expect(cssVarName("color.accent", "rs")).toBe("--rs-color-accent");
-  });
-});
-
-describe("design tokens — DSL builders", () => {
-  it("t.dimension coerces bare numbers to px; t.duration to ms", () => {
-    const doc = defineTokens({
-      space: { md: t.dimension(16) },
-      motion: { fast: t.duration(150) },
-    }).tokens;
-    const resolved = resolveTokens(doc);
-    expect(findTok(resolved, "space.md").value).toBe("16px");
-    expect(findTok(resolved, "motion.fast").value).toBe("150ms");
-  });
-
-  it("defineTokens normalises a bare tree and a themed shape alike", () => {
-    const bare = defineTokens({ color: { bg: t.color("#fff") } });
-    expect(bare.tokens.color).toBeDefined();
-    expect(bare.modes).toEqual({});
-
-    const themed = defineTokens({ tokens: { color: { bg: t.color("#fff") } }, defaultMode: "light" });
-    expect(themed.defaultMode).toBe("light");
-  });
-});
-
-describe("design tokens — CSS emission", () => {
-  const themed: ThemedTokens = {
-    tokens: {
-      color: {
-        $type: "color",
-        brand: { 500: { $value: "#4F6BFF" } },
-        accent: { $value: ref("color.brand.500") },
-        bg: { $value: "#FFFFFF" },
-      },
-      space: { $type: "dimension", md: { $value: "16px" } },
-      font: { family: { $type: "fontFamily", sans: { $value: ["Inter", "sans-serif"] } } },
-      shadow: { $type: "shadow", sm: { $value: { offsetX: "0", offsetY: "1px", blur: "2px", color: "#0001" } } },
-    },
-    modes: { dark: { color: { bg: { $value: "#06080F" } } } },
-    defaultMode: "light",
-  };
-
-  const css = emitCss(themed);
-
-  it("emits :root custom properties", () => {
-    expect(css).toMatch(/:root\s*\{/);
-    expect(css).toContain("--color-brand-500: #4F6BFF;");
-    expect(css).toContain("--space-md: 16px;");
-  });
-
-  it("preserves aliases as var() references so themes cascade", () => {
-    expect(css).toContain("--color-accent: var(--color-brand-500);");
-  });
-
-  it("quotes font families with spaces and joins the stack", () => {
-    expect(css).toContain('--font-family-sans: Inter, sans-serif;');
-  });
-
-  it("renders shadows as box-shadow strings", () => {
-    expect(css).toContain("--shadow-sm: 0 1px 2px #0001;");
-  });
-
-  it("scopes a mode override to its selector and omits unchanged tokens", () => {
-    expect(css).toContain('[data-theme="dark"]');
-    // only bg changed in dark
-    const darkBlock = css.slice(css.indexOf('[data-theme="dark"]'));
-    expect(darkBlock).toContain("--color-bg: #06080F;");
-    expect(darkBlock).not.toContain("--color-brand-500");
-  });
-
-  it("respects a variable prefix", () => {
-    expect(emitCss(themed, { prefix: "rs" })).toContain("--rs-color-brand-500:");
-  });
-});
-
-describe("design tokens — typed TS emission", () => {
-  const base = resolveTokens({
-    color: { $type: "color", brand: { 500: { $value: "#4F6BFF" } }, surfaceAlt: { $value: "#eee" } },
-  });
-  const source = emitTs(base);
-
-  it("emits a nested theme tree of var() references", () => {
-    expect(source).toContain('"500": "var(--color-brand-500)"');
-    expect(source).toContain('surfaceAlt: "var(--color-surface-alt)"');
-  });
-
-  it("emits a TokenPath union of every token", () => {
-    expect(source).toContain('| "color.brand.500"');
-    expect(source).toContain('| "color.surfaceAlt"');
-  });
-});
-
-describe("design tokens — compile to disk", () => {
-  const outDir = join(workRoot, "out");
-  const jsonSrc = join(workRoot, "sample.tokens.json");
-
-  beforeAll(() => {
-    mkdirSync(workRoot, { recursive: true });
-    writeFileSync(
-      jsonSrc,
-      JSON.stringify({
-        tokens: { color: { $type: "color", accent: { $value: "#4F6BFF" } } },
-        modes: { dark: { color: { accent: { $value: "#8BA4FF" } } } },
-        defaultMode: "light",
-      }),
-    );
-  });
-  afterAll(() => rmSync(workRoot, { recursive: true, force: true }));
-
-  it("writes tokens.rastack.json, tokens.css and tokens.ts", () => {
-    const { files } = compileTokens(jsonSrc, outDir);
-    expect(files.map((f) => f.split("/").pop())).toEqual([
-      "tokens.rastack.json",
-      "tokens.css",
-      "tokens.ts",
-    ]);
-    for (const f of files) expect(existsSync(f)).toBe(true);
-    expect(readFileSync(join(outDir, "tokens.css"), "utf8")).toContain("--color-accent: #4F6BFF;");
-    expect(readFileSync(join(outDir, "tokens.ts"), "utf8")).toContain('| "color.accent"');
-  });
-
-  it("loadTokens parses a bare DTCG tree as well as a themed doc", () => {
-    const bareSrc = join(workRoot, "bare.tokens.json");
-    writeFileSync(bareSrc, JSON.stringify({ color: { $type: "color", bg: { $value: "#fff" } } }));
-    const themed = loadTokens(bareSrc);
-    expect(themed.tokens.color).toBeDefined();
-  });
-});
-
-describe("design tokens — studio page", () => {
-  const themed = defineTokens({
-    tokens: { color: { brand: { 500: t.color("#4F6BFF") }, accent: t.color(ref("color.brand.500")) } },
-    modes: { dark: { color: { brand: { 500: t.color("#8BA4FF") } } } },
-    defaultMode: "light",
-  });
-
-  it("renders a self-contained HTML page embedding the tokens + CSS", () => {
-    const html = renderStudio(themed, { editable: true });
-    expect(html).toMatch(/^<!doctype html>/);
-    expect(html).toContain("--color-brand-500: #4F6BFF;");
-    expect(html).toContain('id="studio-data"');
-    // the embedded payload carries the layers + raw doc for the editor
-    expect(html).toContain('"color.accent"');
-    expect(html).toContain('"editable":true');
-  });
-});
-
-describe("design tokens — defineTheme() intent layer", () => {
-  it("derives a full 50–950 brand scale from one colour, with 500 = the seed", () => {
-    const resolved = resolveTheme(defineTheme({ brand: "#4F6BFF" }));
-    expect(findTok(resolved.base, "color.brand.500").value).toBe("#4F6BFF");
-    for (const step of ["50", "100", "200", "300", "400", "600", "700", "800", "900", "950"]) {
-      expect(findTok(resolved.base, `color.brand.${step}`).value).toMatch(/^#[0-9A-F]{6}$/);
-    }
-  });
-
-  it("generates semantic tokens plus a dark mode by default", () => {
-    const themed = defineTheme({ brand: "#4F6BFF" });
-    expect(Object.keys(themed.modes ?? {})).toEqual(["dark"]);
-    const resolved = resolveTheme(themed);
-    for (const name of ["bg", "surface", "border", "text", "text-muted", "accent", "on-accent"]) {
-      expect(findTok(resolved.base, `color.${name}`)).toBeDefined();
-    }
-    // The accent is an alias of the brand ramp, and reads lighter in dark.
-    expect(findTok(resolved.base, "color.accent").aliasOf).toBe("color.brand.500");
-    expect(findTok(resolved.modes.dark, "color.accent").aliasOf).toBe("color.brand.400");
-    // dark bg is dark, light bg is white
-    expect(findTok(resolved.base, "color.bg").value).toBe("#FFFFFF");
-    expect(findTok(resolved.modes.dark, "color.bg").value).not.toBe("#FFFFFF");
-  });
-
-  it("picks a readable on-accent colour by contrast", () => {
-    expect(findTok(resolveTheme(defineTheme({ brand: "#FACC15" })).base, "color.on-accent").value).toBe("#0B1020");
-    expect(findTok(resolveTheme(defineTheme({ brand: "#1D4ED8" })).base, "color.on-accent").value).toBe("#FFFFFF");
-  });
-
-  it("maps radius keywords and honours a numeric radius", () => {
-    expect(findTok(resolveTheme(defineTheme({ brand: "#4F6BFF", radius: "sharp" })).base, "color.brand.500")).toBeDefined();
-    const r = resolveTheme(defineTheme({ brand: "#4F6BFF", radius: 20 }));
-    expect(findTok(r.base, "radius.md").value).toBe("20px");
-  });
-
-  it("lowers to the same ThemedTokens shape and compiles to valid CSS", () => {
-    const css = emitCss(defineTheme({ brand: "#4F6BFF", font: "Poppins" }));
-    expect(css).toContain("--color-brand-500: #4F6BFF;");
-    expect(css).toContain("--color-accent: var(--color-brand-500);");
-    expect(css).toContain('[data-theme="dark"]');
-    expect(css).toContain("--font-family-sans: Poppins;");
-  });
-
-  it("applies colour overrides and the extend escape hatch", () => {
-    const themed = defineTheme({
-      brand: "#4F6BFF",
-      colors: { success: "#00A86B" },
-      extend: { tokens: { z: { index: { modal: { $type: "number", $value: 1000 } } } } },
-    });
-    const base = resolveTheme(themed).base;
-    expect(findTok(base, "color.success").value).toBe("#00A86B");
-    expect(findTok(base, "z.index.modal").value).toBe(1000);
-  });
-
-  it("appearance:'light' emits no dark mode; 'dark' makes :root dark", () => {
-    expect(Object.keys(defineTheme({ brand: "#4F6BFF", appearance: "light" }).modes ?? {})).toEqual([]);
-    const dark = defineTheme({ brand: "#4F6BFF", appearance: "dark" });
-    expect(dark.defaultMode).toBe("dark");
-    expect(findTok(resolveTheme(dark).base, "color.bg").value).not.toBe("#FFFFFF");
-  });
-});
-
-describe("design tokens — the repo's own theme.tokens.ts + .json agree", () => {
-  it("the TS authoring source resolves and matches the JSON source", () => {
-    // Executed by ts-jest, importing the package by its subpath name.
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const tsThemed = require("../../tokens/theme.tokens").default as ThemedTokens;
-    const jsonThemed = loadTokens(join(__dirname, "..", "..", "tokens", "theme.tokens.json"));
-
-    const fromTs = resolveTheme(tsThemed);
-    const fromJson = resolveTheme(jsonThemed);
-
-    // Same set of token paths and the same emitted CSS values (composite types
-    // like shadows may be authored with numbers in TS and strings in JSON, but
-    // must render identically).
-    const map = (r: ReturnType<typeof resolveTheme>) =>
-      Object.fromEntries(r.base.map((tok) => [tok.path, formatCssValue(tok)]));
-    expect(map(fromTs)).toEqual(map(fromJson));
-
-    // Alias cascades through the dark mode (accent follows brand.500).
-    const darkAccent = findTok(fromTs.modes.dark, "color.accent");
-    expect(darkAccent.value).toBe("#8BA4FF");
-  });
-});

package/test/transitions.spec.ts

@@ -1,372 +0,0 @@
-import { mkdirSync, rmSync, writeFileSync } from "fs";
-import { join } from "path";
-import {
-  analyzeProject,
-  analyzeResources,
-  buildOpenApi,
-  writeSchema,
-} from "../src/compile";
-import {
-  allowedTransitions,
-  applyTransition,
-  compileRecordMachine,
-  describeTransitions,
-  findTransition,
-  normalizeTransitions,
-  runRecordMachine,
-  specsFromResource,
-  transitionGuard,
-  transitionProblems,
-  type TransitionsModel,
-} from "../src/validate";
-import { validateDataset } from "../src/import/tabular";
-
-/** The flight lifecycle used throughout — mirrors `resources/airports.ts`. */
-const FLIGHT: TransitionsModel = {
-  field: "status",
-  states: ["scheduled", "boarding", "departed", "cancelled"],
-  initial: "scheduled",
-  on: {
-    board: { from: ["scheduled"], to: "boarding" },
-    depart: { from: ["boarding"], to: "departed", set: { gate: null } },
-    cancel: { from: ["scheduled", "boarding"], to: "cancelled" },
-  },
-};
-
-describe("transitions — the pure core", () => {
-  it("normalises an authored block (scalar `from` becomes a list)", () => {
-    const model = normalizeTransitions({
-      field: "status",
-      states: ["a", "b"],
-      initial: "a",
-      on: { go: { from: "a", to: "b" } },
-    });
-    expect(model).toEqual({
-      field: "status",
-      states: ["a", "b"],
-      initial: "a",
-      on: { go: { from: ["a"], to: "b" } },
-    });
-  });
-
-  it("rejects structurally broken blocks and drops malformed edges", () => {
-    expect(normalizeTransitions(undefined)).toBeUndefined();
-    expect(normalizeTransitions("nope")).toBeUndefined();
-    expect(normalizeTransitions({ field: "s", states: [] })).toBeUndefined();
-    const model = normalizeTransitions({
-      field: "s",
-      states: ["a", "b"],
-      on: { ok: { from: "a", to: "b" }, broken: { from: "a" } },
-    });
-    expect(Object.keys(model!.on)).toEqual(["ok"]);
-  });
-
-  it("reports authoring problems against the resource's fields", () => {
-    const fields = [{ name: "status" }, { name: "gate" }];
-    expect(transitionProblems(FLIGHT, fields)).toEqual([]);
-
-    const broken: TransitionsModel = {
-      field: "state", // not a field
-      states: ["a"],
-      initial: "b", // not a state
-      on: {
-        go: { from: ["a"], to: "z", set: { state: "x", ghost: 1 } }, // bad to/set
-      },
-    };
-    const problems = transitionProblems(broken, [{ name: "status" }]);
-    expect(problems).toEqual(
-      expect.arrayContaining([
-        expect.stringContaining('"state" is not a field'),
-        expect.stringContaining('initial state "b"'),
-        expect.stringContaining('to-state "z"'),
-        expect.stringContaining("must not patch the state field"),
-        expect.stringContaining('unknown field "ghost"'),
-      ]),
-    );
-  });
-
-  it("lists the transitions available from a state", () => {
-    expect(allowedTransitions(FLIGHT, "scheduled").map((t) => t.name)).toEqual([
-      "board",
-      "cancel",
-    ]);
-    expect(allowedTransitions(FLIGHT, "departed")).toEqual([]);
-    // No state falls back to the initial state.
-    expect(allowedTransitions(FLIGHT, undefined).map((t) => t.name)).toEqual([
-      "board",
-      "cancel",
-    ]);
-  });
-
-  it("finds the declared edge covering a jump", () => {
-    expect(findTransition(FLIGHT, "boarding", "departed")?.name).toBe("depart");
-    expect(findTransition(FLIGHT, "scheduled", "departed")).toBeUndefined();
-  });
-
-  it("guards creates: records start at the initial state", () => {
-    expect(transitionGuard(FLIGHT, undefined, {}).ok).toBe(true);
-    expect(transitionGuard(FLIGHT, undefined, { status: "scheduled" }).ok).toBe(true);
-    const rejected = transitionGuard(FLIGHT, undefined, { status: "departed" });
-    expect(rejected).toMatchObject({
-      ok: false,
-      message: expect.stringContaining('start at "scheduled"'),
-    });
-  });
-
-  it("guards updates: a state change must follow a declared edge", () => {
-    const previous = { status: "scheduled" };
-    expect(transitionGuard(FLIGHT, previous, { number: "BA1" }).ok).toBe(true);
-    expect(transitionGuard(FLIGHT, previous, { status: "scheduled" }).ok).toBe(true);
-    expect(transitionGuard(FLIGHT, previous, { status: "boarding" }).ok).toBe(true);
-    expect(transitionGuard(FLIGHT, previous, { status: "departed" })).toMatchObject({
-      ok: false,
-      message: 'status: no transition from "scheduled" to "departed"',
-    });
-  });
-
-  it("carries the matched edge's `set` patches through the guard", () => {
-    const result = transitionGuard(FLIGHT, { status: "boarding" }, { status: "departed" });
-    expect(result).toEqual({ ok: true, patch: { gate: null } });
-  });
-
-  it("fires a named transition into a full write patch", () => {
-    const applied = applyTransition(FLIGHT, "depart", { status: "boarding" });
-    expect(applied).toEqual({
-      ok: true,
-      patch: { status: "departed", gate: null },
-    });
-
-    expect(applyTransition(FLIGHT, "depart", { status: "scheduled" })).toMatchObject({
-      ok: false,
-      message: expect.stringContaining('not available from "scheduled"'),
-    });
-    expect(applyTransition(FLIGHT, "teleport", {})).toMatchObject({
-      ok: false,
-      message: expect.stringContaining("unknown transition"),
-    });
-  });
-
-  it("describes the machine for UI hints", () => {
-    expect(describeTransitions(FLIGHT)).toEqual([
-      "board: scheduled → boarding",
-      "depart: boarding → departed",
-      "cancel: scheduled | boarding → cancelled",
-    ]);
-  });
-});
-
-describe("transitions — the record-level gate in the record machine", () => {
-  const resource = {
-    fields: [
-      { name: "number", type: "string" as const, maxLength: 8 },
-      {
-        name: "status",
-        type: "string" as const,
-        options: FLIGHT.states,
-        default: "scheduled",
-      },
-      { name: "gate", type: "string" as const, null: true },
-    ],
-  };
-  const machine = compileRecordMachine(specsFromResource(resource), FLIGHT);
-
-  it("passes a legal edge with the persisted row in context", () => {
-    const run = runRecordMachine(
-      machine,
-      { number: "BA1", status: "boarding" },
-      { previous: { status: "scheduled" } },
-    );
-    expect(run.state).toBe("valid");
-  });
-
-  it("fails an undeclared jump at the `transition` gate", () => {
-    const run = runRecordMachine(
-      machine,
-      { number: "BA1", status: "departed" },
-      { previous: { status: "scheduled" } },
-    );
-    expect(run.state).toBe("invalid");
-    expect(run.errors).toEqual([
-      expect.objectContaining({
-        field: "status",
-        gate: "transition",
-        message: 'status: no transition from "scheduled" to "departed"',
-      }),
-    ]);
-  });
-
-  it("treats a run without `previous` as a create", () => {
-    const born = runRecordMachine(machine, { number: "BA1", status: "departed" });
-    expect(born.state).toBe("invalid");
-    expect(born.errors[0].gate).toBe("transition");
-
-    const fresh = runRecordMachine(machine, { number: "BA1" });
-    expect(fresh.state).toBe("valid");
-    // The state field's default (the initial state) fills in.
-    expect(fresh.values.status).toBe("scheduled");
-  });
-
-  it("lets the `member` gate explain an undeclared state first", () => {
-    const run = runRecordMachine(machine, { number: "BA1", status: "teleported" });
-    expect(run.state).toBe("invalid");
-    expect(run.errors).toHaveLength(1);
-    expect(run.errors[0].gate).toBe("member");
-  });
-
-  it("rejects import rows born mid-machine (dataset surface)", () => {
-    const report = validateDataset(
-      specsFromResource(resource),
-      {
-        headers: ["number", "status"],
-        rows: [
-          ["BA1", "scheduled"],
-          ["BA2", "departed"],
-          ["BA3", ""],
-        ],
-      },
-      { transitions: FLIGHT },
-    );
-    expect(report.valid).toBe(2);
-    expect(report.issues).toEqual([
-      expect.objectContaining({ row: 1, gate: "transition" }),
-    ]);
-  });
-});
-
-describe("transitions — through the compiler", () => {
-  const workRoot = join(__dirname, "transitions-fixtures");
-  const resourcesDir = join(workRoot, "resources");
-
-  const FLIGHTS_TS = `
-import { resource, s } from "rastack/define";
-
-export const Flight = resource("airports", "flight", {
-  number: s.string({ maxLength: 8 }),
-  status: s.string({ maxLength: 20 }),
-  gate: s.string({ maxLength: 5, null: true }),
-}, {
-  transitions: {
-    field: "status",
-    states: ["scheduled", "boarding", "departed", "cancelled"],
-    initial: "scheduled",
-    on: {
-      board: { from: "scheduled", to: "boarding" },
-      depart: { from: "boarding", to: "departed", set: { gate: null } },
-      cancel: { from: ["scheduled", "boarding"], to: "cancelled" },
-    },
-  },
-});
-`;
-
-  const ORDERS_TS = `
-// A plain data class with a \`static transitions\` block — the class-authored
-// twin of the DSL option. Statics are never columns.
-export class Order {
-  reference!: string;
-  status = "draft";
-
-  static transitions = {
-    field: "status",
-    states: ["draft", "placed", "shipped"],
-    initial: "draft",
-    on: {
-      place: { from: "draft", to: "placed" },
-      ship: { from: "placed", to: "shipped" },
-    },
-  };
-}
-`;
-
-  beforeAll(() => {
-    mkdirSync(resourcesDir, { recursive: true });
-    writeFileSync(join(resourcesDir, "flights.ts"), FLIGHTS_TS);
-    writeFileSync(join(resourcesDir, "orders.ts"), ORDERS_TS);
-  });
-
-  afterAll(() => {
-    rmSync(workRoot, { recursive: true, force: true });
-  });
-
-  it("compiles a DSL transitions block into the manifest, normalised", () => {
-    const resources = analyzeResources(resourcesDir);
-    const flight = resources.find((r) => r.model === "flight")!;
-    expect(flight.transitions).toEqual({
-      field: "status",
-      states: ["scheduled", "boarding", "departed", "cancelled"],
-      initial: "scheduled",
-      on: {
-        board: { from: ["scheduled"], to: "boarding" },
-        depart: { from: ["boarding"], to: "departed", set: { gate: null } },
-        cancel: { from: ["scheduled", "boarding"], to: "cancelled" },
-      },
-    });
-  });
-
-  it("stamps the state field with the states and the initial default", () => {
-    const resources = analyzeResources(resourcesDir);
-    const flight = resources.find((r) => r.model === "flight")!;
-    const status = flight.fields.find((f) => f.name === "status");
-    expect(status).toMatchObject({
-      options: ["scheduled", "boarding", "departed", "cancelled"],
-      default: "scheduled",
-    });
-  });
-
-  it("reads a class's `static transitions` (and keeps it out of the columns)", () => {
-    const resources = analyzeResources(resourcesDir);
-    const order = resources.find((r) => r.model === "order")!;
-    expect(order.transitions).toMatchObject({
-      field: "status",
-      states: ["draft", "placed", "shipped"],
-      on: { place: { from: ["draft"], to: "placed" } },
-    });
-    expect(order.fields.map((f) => f.name)).toEqual(["reference", "status"]);
-    const status = order.fields.find((f) => f.name === "status");
-    expect(status?.options).toEqual(["draft", "placed", "shipped"]);
-  });
-
-  it("emits `enum` and `x-rastack-transitions` into the OpenAPI contract", () => {
-    const resources = analyzeResources(resourcesDir);
-    const flight = resources.find((r) => r.model === "flight")!;
-    const doc = buildOpenApi(resources);
-
-    const status = doc.components.schemas.Flight.properties.status;
-    expect(status.enum).toEqual(["scheduled", "boarding", "departed", "cancelled"]);
-
-    const write = doc.components.schemas.FlightRequest;
-    expect(write["x-rastack-transitions"]).toEqual(flight.transitions);
-    expect(doc.components.schemas.PatchedFlightRequest["x-rastack-transitions"])
-      .toEqual(flight.transitions);
-
-    // The exported `writeSchema` (what `useForm(Entity)` derives at runtime)
-    // is the same schema the document publishes.
-    expect(writeSchema(flight, false)).toEqual(write);
-  });
-
-  it("surfaces authoring mistakes as compile diagnostics", () => {
-    const brokenDir = join(workRoot, "broken");
-    mkdirSync(brokenDir, { recursive: true });
-    writeFileSync(
-      join(brokenDir, "broken.ts"),
-      `
-import { resource, s } from "rastack/define";
-export const Thing = resource("app", "thing", {
-  status: s.string({ maxLength: 10 }),
-}, {
-  transitions: {
-    field: "status",
-    states: ["a", "b"],
-    on: { go: { from: "a", to: "missing" } },
-  },
-});
-`,
-    );
-    const { diagnostics } = analyzeProject(brokenDir);
-    expect(diagnostics).toEqual([
-      expect.objectContaining({
-        severity: "error",
-        message: expect.stringContaining('to-state "missing"'),
-      }),
-    ]);
-  });
-});