rastack 0.0.24 → 0.0.25

package/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [0.0.25](https://github.com/theserverkid/reactapistack/compare/v0.0.24...v0.0.25) (2026-07-10)
+
 ### [0.0.24](https://github.com/theserverkid/reactapistack/compare/v0.0.23...v0.0.24) (2026-07-09)
 
 

package/dist/rastack-design.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * `rastack design` (aka `ras design`) — a live design-system studio.
+ *
+ *   rastack design [input] [--port <n>] [--prefix <p>]
+ *
+ * Boots a tiny, dependency-free HTTP server that serves an interactive page
+ * showcasing the design system — colour swatches, the type ramp, spacing,
+ * radii, shadows, and component previews built from the tokens themselves — and
+ * lets you edit token values in place with a live preview. Editing a `.json`
+ * source and hitting **Save** writes it back and recompiles `tokens.css` /
+ * `tokens.ts`, so the rest of the app picks the change up on reload.
+ *
+ * In keeping with the local-first ethos (the whole API runs in the browser via
+ * WASM), the studio needs no build step and no external dependencies.
+ */
+export {};

package/dist/rastack-design.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * `rastack design` (aka `ras design`) — a live design-system studio.
+ *
+ *   rastack design [input] [--port <n>] [--prefix <p>]
+ *
+ * Boots a tiny, dependency-free HTTP server that serves an interactive page
+ * showcasing the design system — colour swatches, the type ramp, spacing,
+ * radii, shadows, and component previews built from the tokens themselves — and
+ * lets you edit token values in place with a live preview. Editing a `.json`
+ * source and hitting **Save** writes it back and recompiles `tokens.css` /
+ * `tokens.ts`, so the rest of the app picks the change up on reload.
+ *
+ * In keeping with the local-first ethos (the whole API runs in the browser via
+ * WASM), the studio needs no build step and no external dependencies.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const http = __importStar(require("http"));
+const path = __importStar(require("path"));
+const compile_1 = require("./tokens/compile");
+const studio_1 = require("./tokens/studio");
+const DEFAULT_INPUT = "tokens/theme.tokens.json";
+const DEFAULT_OUT = ".rastack";
+function parseArgs(argv) {
+    const positional = [];
+    let port = 4321;
+    let prefix = "";
+    let outDir = DEFAULT_OUT;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--port")
+            port = Number(argv[++i]) || port;
+        else if (a === "--prefix")
+            prefix = argv[++i] ?? "";
+        else if (a === "--out")
+            outDir = argv[++i] ?? outDir;
+        else
+            positional.push(a);
+    }
+    return { input: positional[0] || DEFAULT_INPUT, port, prefix, outDir };
+}
+function main(argv) {
+    const args = parseArgs(argv);
+    const isJson = args.input.endsWith(".json");
+    let themed;
+    try {
+        themed = (0, compile_1.loadTokens)(args.input);
+    }
+    catch (err) {
+        console.error(`  ✗ ${err.message}`);
+        process.exit(1);
+        return;
+    }
+    const server = http.createServer((req, res) => {
+        // Only edits to a JSON source can be written back safely (a module source
+        // is code, not data).
+        if (req.method === "POST" && req.url === "/save") {
+            if (!isJson) {
+                res.writeHead(400).end("Editing is only supported for .json token sources.");
+                return;
+            }
+            let body = "";
+            req.on("data", (c) => (body += c));
+            req.on("end", () => {
+                try {
+                    const next = JSON.parse(body);
+                    require("fs").writeFileSync(path.resolve(args.input), JSON.stringify(next, null, 2) + "\n");
+                    themed = next;
+                    // Recompile so tokens.css / tokens.ts reflect the save immediately.
+                    (0, compile_1.compileTokens)(args.input, args.outDir, { prefix: args.prefix });
+                    res.writeHead(200, { "Content-Type": "application/json" }).end(`{"ok":true}`);
+                    console.log(`  ↳ saved ${args.input} & recompiled`);
+                }
+                catch (err) {
+                    res.writeHead(500).end(err.message);
+                }
+            });
+            return;
+        }
+        if (req.method === "GET" && (req.url === "/" || req.url === "/index.html")) {
+            const html = (0, studio_1.renderStudio)(themed, {
+                prefix: args.prefix,
+                editable: isJson,
+                title: "Design System",
+            });
+            res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" }).end(html);
+            return;
+        }
+        res.writeHead(404).end("Not found");
+    });
+    server.listen(args.port, () => {
+        console.log(`\n  rastack design — studio for ${args.input}\n` +
+            `  ▸ http://localhost:${args.port}\n` +
+            (isJson ? `  Edits Save back to ${args.input}.\n` : `  Read-only (module source).\n`) +
+            `\n  Press Ctrl+C to stop.\n`);
+    });
+}
+if (require.main === module) {
+    main(process.argv.slice(2));
+}

package/dist/rastack-tokens.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * `rastack tokens` — compile a design-token source into shippable artifacts.
+ *
+ *   rastack tokens [input] [outDir] [--prefix <p>]
+ *
+ * `input`  a DTCG `.json` file, or a compiled module that default-exports
+ *          `defineTokens(...)` (default: `tokens/theme.tokens.json`).
+ * `outDir` where to write `tokens.{rastack.json,css,ts}` (default: `.rastack`).
+ *
+ * Mirrors `rastack compile`: TypeScript-authored source → canonical JSON +
+ * ready-to-use outputs, with alias/cycle errors surfaced before anything is
+ * written.
+ */
+export {};

package/dist/rastack-tokens.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * `rastack tokens` — compile a design-token source into shippable artifacts.
+ *
+ *   rastack tokens [input] [outDir] [--prefix <p>]
+ *
+ * `input`  a DTCG `.json` file, or a compiled module that default-exports
+ *          `defineTokens(...)` (default: `tokens/theme.tokens.json`).
+ * `outDir` where to write `tokens.{rastack.json,css,ts}` (default: `.rastack`).
+ *
+ * Mirrors `rastack compile`: TypeScript-authored source → canonical JSON +
+ * ready-to-use outputs, with alias/cycle errors surfaced before anything is
+ * written.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("./tokens/compile");
+const DEFAULT_INPUT = "tokens/theme.tokens.json";
+const DEFAULT_OUT = ".rastack";
+function main(argv) {
+    const positional = [];
+    let prefix = "";
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === "--prefix")
+            prefix = argv[++i] ?? "";
+        else
+            positional.push(argv[i]);
+    }
+    const input = positional[0] || DEFAULT_INPUT;
+    const outDir = positional[1] || DEFAULT_OUT;
+    try {
+        const { themed, files } = (0, compile_1.compileTokens)(input, outDir, { prefix });
+        const modes = Object.keys(themed.modes ?? {});
+        console.log(`✓ compiled design tokens${modes.length ? ` (${modes.length} mode${modes.length > 1 ? "s" : ""}: ${modes.join(", ")})` : ""} → ${files.join(", ")}`);
+    }
+    catch (err) {
+        console.error(`  ✗ ${err.message}`);
+        process.exit(1);
+    }
+}
+if (require.main === module) {
+    main(process.argv.slice(2));
+}

package/dist/rastack.d.ts

@@ -8,6 +8,8 @@
  *   rastack list    [resourcesDir]              Print resources, fields and relations
  *   rastack urls    [resourcesDir]              Print the generated /api/{app}/v1/{model}/ routes
  *   rastack generate [--schema-only]            Generate typed hooks from OpenAPI
+ *   rastack tokens  [input] [outDir]            Compile design tokens → CSS vars + typed theme
+ *   rastack design  [input] [--port n]          Live design-system studio (showcase + edit)
  *   rastack serve   [--warehouse dir]           Run the Rust API over an Iceberg warehouse
  *   rastack admin   [--warehouse dir]           Run the Rust admin (Django-admin-style DB browser)
  *   rastack wasm                                Compile the API to WebAssembly (in-browser local dev)

package/dist/rastack.js

@@ -9,6 +9,8 @@
  *   rastack list    [resourcesDir]              Print resources, fields and relations
  *   rastack urls    [resourcesDir]              Print the generated /api/{app}/v1/{model}/ routes
  *   rastack generate [--schema-only]            Generate typed hooks from OpenAPI
+ *   rastack tokens  [input] [outDir]            Compile design tokens → CSS vars + typed theme
+ *   rastack design  [input] [--port n]          Live design-system studio (showcase + edit)
  *   rastack serve   [--warehouse dir]           Run the Rust API over an Iceberg warehouse
  *   rastack admin   [--warehouse dir]           Run the Rust admin (Django-admin-style DB browser)
  *   rastack wasm                                Compile the API to WebAssembly (in-browser local dev)
@@ -70,6 +72,14 @@ switch (command) {
         // Compile the API to WebAssembly for in-browser local dev.
         run("rastack-wasm-build.js", rest);
         break;
+    case "tokens":
+        // Design tokens → CSS custom properties + typed theme.
+        run("rastack-tokens.js", rest);
+        break;
+    case "design":
+        // Live design-system studio (showcase + inspect + edit).
+        run("rastack-design.js", rest);
+        break;
     case "scan":
         run("scan.js");
         break;
@@ -87,6 +97,8 @@ switch (command) {
             `  rastack compile [resourcesDir] [outDir]\n` +
             `  rastack check | list | urls [resourcesDir]\n` +
             `  rastack generate [--schema-only]\n` +
+            `  rastack tokens  [input] [outDir] [--prefix p]  Compile design tokens → CSS vars + typed theme\n` +
+            `  rastack design  [input] [--port n]             Live design-system studio (showcase + edit)\n` +
             `  rastack serve | admin [--warehouse dir]\n` +
             `  rastack wasm                                Compile the API to WebAssembly (browser local dev)\n` +
             `  rastack scan   [files...] [--fail-on-pii]\n` +

package/dist/tokens/color.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Tiny, dependency-free colour maths — just enough to turn one brand colour into
+ * a full tint/shade scale and to pick a readable on-colour. Used by
+ * {@link defineTheme} so a non-designer specifies a single hex and gets a
+ * complete, sensible palette.
+ */
+interface Rgb {
+    r: number;
+    g: number;
+    b: number;
+}
+/** Parse `#rgb` / `#rrggbb` (with or without `#`) into 0–255 channels. */
+export declare function parseHex(hex: string): Rgb;
+/** Blend two colours; `amount` is how far from `a` toward `b` (0–1). */
+export declare function mix(a: string, b: string, amount: number): string;
+/** Relative luminance (0 dark – 1 light), for contrast decisions. */
+export declare function luminance(hex: string): number;
+/** Black or white — whichever is readable on `hex`. */
+export declare function readableOn(hex: string): string;
+/** Build a `{ 50…950 }` colour scale from a single seed colour. */
+export declare function scale(seed: string): Record<string, string>;
+export {};

package/dist/tokens/color.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Tiny, dependency-free colour maths — just enough to turn one brand colour into
+ * a full tint/shade scale and to pick a readable on-colour. Used by
+ * {@link defineTheme} so a non-designer specifies a single hex and gets a
+ * complete, sensible palette.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHex = parseHex;
+exports.mix = mix;
+exports.luminance = luminance;
+exports.readableOn = readableOn;
+exports.scale = scale;
+/** Parse `#rgb` / `#rrggbb` (with or without `#`) into 0–255 channels. */
+function parseHex(hex) {
+    let h = hex.trim().replace(/^#/, "");
+    if (h.length === 3)
+        h = h.split("").map((c) => c + c).join("");
+    if (!/^[0-9a-fA-F]{6}$/.test(h)) {
+        throw new Error(`Not a hex colour: "${hex}" (use e.g. "#4F6BFF").`);
+    }
+    return {
+        r: parseInt(h.slice(0, 2), 16),
+        g: parseInt(h.slice(2, 4), 16),
+        b: parseInt(h.slice(4, 6), 16),
+    };
+}
+function toHex({ r, g, b }) {
+    const h = (n) => ("0" + Math.round(Math.max(0, Math.min(255, n))).toString(16)).slice(-2);
+    return `#${h(r)}${h(g)}${h(b)}`.toUpperCase();
+}
+/** Blend two colours; `amount` is how far from `a` toward `b` (0–1). */
+function mix(a, b, amount) {
+    const x = parseHex(a);
+    const y = parseHex(b);
+    return toHex({
+        r: x.r + (y.r - x.r) * amount,
+        g: x.g + (y.g - x.g) * amount,
+        b: x.b + (y.b - x.b) * amount,
+    });
+}
+/** Relative luminance (0 dark – 1 light), for contrast decisions. */
+function luminance(hex) {
+    const { r, g, b } = parseHex(hex);
+    const lin = (c) => {
+        const s = c / 255;
+        return s <= 0.03928 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+    };
+    return 0.2126 * lin(r) + 0.7152 * lin(g) + 0.0722 * lin(b);
+}
+/** Black or white — whichever is readable on `hex`. */
+function readableOn(hex) {
+    return luminance(hex) > 0.45 ? "#0B1020" : "#FFFFFF";
+}
+/**
+ * How much to mix a seed toward white (tints) or black (shades) at each step of
+ * a Tailwind-style 50–950 scale. `500` is the seed itself.
+ */
+const TINT = { 50: 0.95, 100: 0.9, 200: 0.78, 300: 0.62, 400: 0.34 };
+const SHADE = { 600: 0.12, 700: 0.28, 800: 0.44, 900: 0.6, 950: 0.74 };
+/** Build a `{ 50…950 }` colour scale from a single seed colour. */
+function scale(seed) {
+    const out = {};
+    for (const [step, amt] of Object.entries(TINT))
+        out[step] = mix(seed, "#FFFFFF", amt);
+    out["500"] = toHex(parseHex(seed));
+    for (const [step, amt] of Object.entries(SHADE))
+        out[step] = mix(seed, "#000000", amt);
+    return out;
+}

package/dist/tokens/compile.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Token compilation with file IO — the engine behind `rastack tokens`.
+ *
+ * Loads a token source (canonical DTCG `.json`, or a `.js`/compiled module that
+ * default-exports a {@link ThemedTokens}), resolves it, and writes three
+ * artifacts:
+ *
+ *   - `tokens.rastack.json` — the canonical, resolved DTCG document (the manifest
+ *     analogue: one file that fully describes the design system).
+ *   - `tokens.css` — CSS custom properties with per-mode selector scopes.
+ *   - `tokens.ts` — the typed theme tree + `TokenPath` union.
+ *
+ * Kept separate from the pure core (`./index.ts`) so the browser runtime never
+ * pulls in `fs`.
+ */
+import { CssOptions } from "./css";
+import { ThemedTokens } from "./types";
+export interface TokenCompileOptions extends CssOptions {
+}
+export interface TokenCompileResult {
+    themed: ThemedTokens;
+    files: string[];
+}
+/**
+ * Load a token source into a normalised {@link ThemedTokens}. `.json` is parsed
+ * as DTCG; any other extension is `require`d and its default export (or the
+ * module itself) is taken — so a `defineTokens(...)` module works once compiled
+ * to JS (or when a `.ts` loader such as ts-node is registered).
+ */
+export declare function loadTokens(file: string): ThemedTokens;
+/** The canonical, resolved DTCG document written to `tokens.rastack.json`. */
+export declare function canonicalDocument(themed: ThemedTokens): unknown;
+/** Compile a token source file to `tokens.{rastack.json,css,ts}` in `outDir`. */
+export declare function compileTokens(file: string, outDir: string, options?: TokenCompileOptions): TokenCompileResult;

package/dist/tokens/compile.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * Token compilation with file IO — the engine behind `rastack tokens`.
+ *
+ * Loads a token source (canonical DTCG `.json`, or a `.js`/compiled module that
+ * default-exports a {@link ThemedTokens}), resolves it, and writes three
+ * artifacts:
+ *
+ *   - `tokens.rastack.json` — the canonical, resolved DTCG document (the manifest
+ *     analogue: one file that fully describes the design system).
+ *   - `tokens.css` — CSS custom properties with per-mode selector scopes.
+ *   - `tokens.ts` — the typed theme tree + `TokenPath` union.
+ *
+ * Kept separate from the pure core (`./index.ts`) so the browser runtime never
+ * pulls in `fs`.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTokens = loadTokens;
+exports.canonicalDocument = canonicalDocument;
+exports.compileTokens = compileTokens;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const define_1 = require("./define");
+const css_1 = require("./css");
+const resolve_1 = require("./resolve");
+const ts_1 = require("./ts");
+/**
+ * Load a token source into a normalised {@link ThemedTokens}. `.json` is parsed
+ * as DTCG; any other extension is `require`d and its default export (or the
+ * module itself) is taken — so a `defineTokens(...)` module works once compiled
+ * to JS (or when a `.ts` loader such as ts-node is registered).
+ */
+function loadTokens(file) {
+    const abs = path.resolve(file);
+    if (!fs.existsSync(abs))
+        throw new Error(`No such tokens file: ${file}`);
+    if (abs.endsWith(".json")) {
+        const raw = JSON.parse(fs.readFileSync(abs, "utf8"));
+        // Accept either the themed shape or a bare DTCG tree.
+        return (0, define_1.defineTokens)(raw);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const mod = require(abs);
+    const exported = mod?.default ?? mod;
+    return (0, define_1.defineTokens)(exported);
+}
+/** The canonical, resolved DTCG document written to `tokens.rastack.json`. */
+function canonicalDocument(themed) {
+    return {
+        $description: "Compiled by `rastack tokens`. The resolved design system.",
+        ...themed.tokens,
+        ...(themed.modes && Object.keys(themed.modes).length
+            ? { $extensions: { "com.rastack.modes": themed.modes, "com.rastack.defaultMode": themed.defaultMode } }
+            : {}),
+    };
+}
+/** Compile a token source file to `tokens.{rastack.json,css,ts}` in `outDir`. */
+function compileTokens(file, outDir, options = {}) {
+    const themed = loadTokens(file);
+    // Resolve eagerly so alias/cycle errors surface here, before writing anything.
+    (0, resolve_1.resolveTheme)(themed);
+    fs.mkdirSync(outDir, { recursive: true });
+    const jsonPath = path.join(outDir, "tokens.rastack.json");
+    const cssPath = path.join(outDir, "tokens.css");
+    const tsPath = path.join(outDir, "tokens.ts");
+    fs.writeFileSync(jsonPath, JSON.stringify(canonicalDocument(themed), null, 2) + "\n");
+    fs.writeFileSync(cssPath, (0, css_1.emitCss)(themed, options));
+    fs.writeFileSync(tsPath, (0, ts_1.emitTs)((0, resolve_1.resolveTheme)(themed).base, options));
+    return { themed, files: [jsonPath, cssPath, tsPath] };
+}

package/dist/tokens/css.d.ts

@@ -0,0 +1,30 @@
+/**
+ * CSS custom-property emitter — the primary, framework-agnostic output.
+ *
+ * Design tokens become CSS variables under `:root`, and each **mode** becomes a
+ * selector scope that overrides only the tokens it changes. A running app then
+ * switches theme by toggling one attribute (`<html data-theme="dark">`), and
+ * every `var(--…)` reference recascades for free. Aliases are preserved as
+ * `var(--target)` rather than inlined, so overriding a base token
+ * automatically flows through everything that references it.
+ */
+import { ResolvedTheme } from "./resolve";
+import { ThemedTokens, ResolvedToken } from "./types";
+export interface CssOptions {
+    /** Prefix every variable: `prefix: "rs"` → `--rs-color-brand-500`. */
+    prefix?: string;
+    /**
+     * How a mode maps to a selector. Given the mode name, return the selector
+     * whose block holds that mode's overrides. Default: `[data-theme="<mode>"]`,
+     * with the default mode also written to `:root`.
+     */
+    modeSelector?: (mode: string) => string;
+    /** Root selector for the base tokens. Default `:root`. */
+    rootSelector?: string;
+}
+/** Format a resolved token's literal value as a CSS declaration value. */
+export declare function formatCssValue(token: ResolvedToken): string;
+/** Emit CSS custom properties for a resolved theme (base + mode scopes). */
+export declare function emitCssFromResolved(resolved: ResolvedTheme, options?: CssOptions): string;
+/** Emit CSS custom properties for a themed token document. */
+export declare function emitCss(themed: ThemedTokens, options?: CssOptions): string;

package/dist/tokens/css.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * CSS custom-property emitter — the primary, framework-agnostic output.
+ *
+ * Design tokens become CSS variables under `:root`, and each **mode** becomes a
+ * selector scope that overrides only the tokens it changes. A running app then
+ * switches theme by toggling one attribute (`<html data-theme="dark">`), and
+ * every `var(--…)` reference recascades for free. Aliases are preserved as
+ * `var(--target)` rather than inlined, so overriding a base token
+ * automatically flows through everything that references it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCssValue = formatCssValue;
+exports.emitCssFromResolved = emitCssFromResolved;
+exports.emitCss = emitCss;
+const resolve_1 = require("./resolve");
+/** Render one CSS number/length; bare numbers stay unitless. */
+function dim(v) {
+    return typeof v === "number" ? `${v}px` : v;
+}
+/** Quote a font-family entry only when it contains whitespace. */
+function fontEntry(name) {
+    return /\s/.test(name) && !/^["']/.test(name) ? `"${name}"` : name;
+}
+function shadow(s) {
+    const parts = [
+        s.inset ? "inset" : "",
+        dim(s.offsetX),
+        dim(s.offsetY),
+        s.blur != null ? dim(s.blur) : "",
+        s.spread != null ? dim(s.spread) : "",
+        s.color,
+    ];
+    return parts.filter(Boolean).join(" ");
+}
+/** Format a resolved token's literal value as a CSS declaration value. */
+function formatCssValue(token) {
+    const { type, value } = token;
+    switch (type) {
+        case "fontFamily":
+            return (Array.isArray(value) ? value : [value])
+                .map(fontEntry)
+                .join(", ");
+        case "cubicBezier":
+            return `cubic-bezier(${value.join(", ")})`;
+        case "shadow":
+            return (Array.isArray(value) ? value : [value])
+                .map(shadow)
+                .join(", ");
+        case "dimension":
+            return dim(value);
+        case "number":
+        case "fontWeight":
+        case "color":
+        case "duration":
+            return String(value);
+        default:
+            return typeof value === "object" ? JSON.stringify(value) : String(value);
+    }
+}
+/** The right-hand side of a token's CSS declaration: `var(--alias)` or a literal. */
+function declValue(token, prefix) {
+    if (token.aliasOf)
+        return `var(${(0, resolve_1.cssVarName)(token.aliasOf, prefix)})`;
+    return formatCssValue(token);
+}
+function block(selector, tokens, prefix, indent = "  ") {
+    const lines = tokens.map((tok) => `${indent}${(0, resolve_1.cssVarName)(tok.path, prefix)}: ${declValue(tok, prefix)};`);
+    return `${selector} {\n${lines.join("\n")}\n}`;
+}
+/** Only the tokens whose emitted declaration differs from the base. */
+function changed(base, mode, prefix) {
+    const baseDecl = new Map(base.map((t) => [t.path, declValue(t, prefix)]));
+    return mode.filter((t) => baseDecl.get(t.path) !== declValue(t, prefix));
+}
+/** Emit CSS custom properties for a resolved theme (base + mode scopes). */
+function emitCssFromResolved(resolved, options = {}) {
+    const prefix = options.prefix ?? "";
+    const root = options.rootSelector ?? ":root";
+    const modeSelector = options.modeSelector ?? ((m) => `[data-theme="${m}"]`);
+    const blocks = [
+        `/* Generated by \`rastack tokens\` — do not edit by hand. */`,
+    ];
+    // Base + the default mode both live on :root, so an app with no attribute set
+    // still gets a complete, sensible theme.
+    const defaultMode = resolved.defaultMode;
+    const rootTokens = defaultMode && resolved.modes[defaultMode]
+        ? resolved.modes[defaultMode]
+        : resolved.base;
+    blocks.push(block(root, rootTokens, prefix));
+    for (const [name, tokens] of Object.entries(resolved.modes)) {
+        const diff = changed(resolved.base, tokens, prefix);
+        if (!diff.length)
+            continue;
+        blocks.push(block(modeSelector(name), diff, prefix));
+    }
+    return blocks.join("\n\n") + "\n";
+}
+/** Emit CSS custom properties for a themed token document. */
+function emitCss(themed, options = {}) {
+    return emitCssFromResolved((0, resolve_1.resolveTheme)(themed), options);
+}