@xtyle/core 0.5.0

package/README.md

@@ -0,0 +1,212 @@
+# @xtyle/core
+
+[![npm](https://img.shields.io/npm/v/@xtyle/core?label=npm)](https://www.npmjs.com/package/@xtyle/core)
+[![docs](https://img.shields.io/badge/docs-xtyle.dev-blue)](https://xtyle.dev)
+[![license](https://img.shields.io/badge/license-MIT-green)](https://opensource.org/license/mit)
+
+A themable-derivation engine. Hand it an **algorithm** and a few pinned colors, and it
+derives a full **register** of CSS-ready tokens across seven dimensions: color, a literal
+12-hue palette, type, geometry, motion, elevation, and space.
+
+The *algorithm* carries the rules, the math, the taste. A *theme* is a materialization of
+one, quick or hard-won, both first-class. This package is the pure derivation engine plus
+the built-in `xtyle-default` algorithm.
+
+## Install
+
+```sh
+npm install @xtyle/core
+```
+
+## Quick start
+
+```ts
+import { derive, emit } from "@xtyle/core";
+import { xtyleDefault } from "@xtyle/core/algorithms";
+
+const register = derive(xtyleDefault, {
+	constraints: { "--bg-0": "#0f1115", "--accent": "#5b8cff" },
+});
+
+console.log(emit(register, "css"));
+// :root {
+//   --accent: #5b8cff;
+//   --bg-0: ...;
+//   --fg-0: ...;
+//   ...
+// }
+```
+
+The engine (`derive`, `emit`) is on `@xtyle/core`; the blessed algorithms (`xtyleDefault`,
+`getAlgorithm`, the full set) are on `@xtyle/core/algorithms`, which also re-exports the
+engine, so `import { derive, getAlgorithm, emitCss } from "@xtyle/core/algorithms"` reaches
+the whole pure-derive path in one import.
+
+Constraints are pinned token values. They land in the output verbatim and feed back in as
+derivation inputs, so pinning `--bg-0` re-derives `--fg-0` to hold contrast. Tune posture
+with `knobs` (below).
+
+## Dual entry
+
+The package is environment-split by design:
+
+- **`@xtyle/core`**: the neutral, importable engine (`derive`, `emit`, `coverage`, `gauntlet`,
+  `makeXtyleAlgorithm`, color and graph helpers); no `node:*`, no DOM globals, safe in any runtime.
+- **`@xtyle/core/algorithms`**: the blessed algorithm set (`xtyleDefault`, `getAlgorithm`, the
+  registry) plus a re-export of the engine, so the whole pure-derive path is one import.
+- **`@xtyle/core/dom`**: browser helpers (`apply`, `clear`, `persist`, `restore`,
+  `toStyleSheet`) that write tokens to a live `:root`.
+- **`xtyle` bin**: a Node CLI for one-shot derivation, coverage, and the gauntlet.
+
+```ts
+import { apply } from "@xtyle/core/dom";
+apply(register, { persistKey: "theme" });
+```
+
+```sh
+xtyle derive --bg "#0f1115" --accent "#5b8cff" --format css
+xtyle coverage --consumed "--bg-0,--fg-0,--accent" --bg "#0f1115"
+xtyle gauntlet --runs 200
+```
+
+`--bg` / `--fg` / `--accent` are shorthands for the three headline anchors; `--set <token>=<value>`
+(repeatable, alias `--constraint`) pins *any* token, so a full multi-anchor recipe bakes straight
+from the CLI without dropping to the importable API. The leading `--` on the token is optional.
+
+```sh
+xtyle derive --accent "#2d5a9e" \
+  --set --accent-2=#7c3aed \
+  --set font-sans="Inter, system-ui, sans-serif" \
+  --set radius-md=10px \
+  --format css
+```
+
+## The seven-dimension contract
+
+`xtyle-default` produces 276 tokens. A representative tour follows; see
+[xtyle.dev](https://xtyle.dev) for the authoritative full register.
+
+### color
+
+- **surfaces**: `--body-bg`, `--bg-0..3`, `--scrim`, `--surface-overlay`, `--surface-overlay-border`
+- **content**: `--fg-0..3`, `--fg-disabled`, `--placeholder`
+- **lines / rings**: `--line`, `--line-2`, `--ring`, `--ring-bg`
+- **accent**: `--accent`, `--accent-hover`, `--accent-active`, `--accent-2..4`, `--accent-bg`, `--accent-fg`, `--accent-text`
+- **fields**: `--field-bg`, `--field-border`
+- **state**: `--state-hover`, `--state-press`, `--state-selected`, `--state-disabled`, `--state-drag` (translucent)
+- **links**: `--link`, `--link-hover`
+- **tones**: each of the 21 tones (the semantic roles, `--accent-2/3/4`, and the twelve named hues) derives a uniform `--{tone}` / `--{tone}-bg` / `--{tone}-fg` / `--{tone}-text` / `--{tone}-vivid` family, so any component renders any tone through one code path
+- **code**: a `--code-*` syntax family (`--code-keyword`, `--code-function`, `--code-comment`, ...) for highlighted blocks
+
+### palette (literal, name-honest, decoupled from roles)
+
+Twelve hues (`red orange yellow green blue purple brown pink cyan gray white black`), each
+a bare alias `--color-<hue>` plus a 5-stop ramp
+`--color-<hue>-{subtle,muted,base,strong,contrast}`. Scheme-aware in OKLCH; the hue stays
+true to its name in every theme (lightness and chroma flex, hue holds). `--color-red`
+stays red even if `--danger` is yellow.
+
+### type
+
+`--font-{sans,mono,display}`, scale `--text-{xs,sm,body,lg,xl,2xl,3xl,4xl,5xl}` (rem, from
+the `typeScale` ratio), `--leading-{tight,normal,loose}`, `--weight-{normal,medium,semibold,bold}`.
+
+### geometry
+
+`--radius-{none,sm,md,lg,full}` (scaled by `radiusScale`), `--border-{thin,normal,thick}`.
+
+### motion
+
+`--duration-{fast,base,slow}` (ms), `--ease-{standard,emphasized}` (`cubic-bezier()`).
+
+### elevation
+
+`--elevation-0..5`, scheme-aware box-shadow strings; 0 is none, 1..5 progressively stronger.
+
+### space
+
+`--space-0..8`, a numeric rem ramp scaled by the `density` knob (compact / normal / comfortable).
+
+## Knobs
+
+`scheme` · `vibrancy` (`0..1`) · `contrastBand` (`'aa'|'aaa'|number`) · `accentSplit` ·
+`accentShiftStep` · `typeScale` · `radiusScale` · `density` · `cues` ·
+`fonts {sans,mono,display}` · `anchors {bg,fg}` (the base-color seed). Every knob has a
+sensible default. Specific colors like the accent are set as constraints, not knobs.
+
+## Derivation rules (`xtyle-default`)
+
+- **Scheme** auto-derives from `--bg-0` lightness in OKLCH (`< 0.5` is dark, else light).
+- **Surfaces** step lightness from `--bg-0` in OKLCH, monotonically: lightening for dark
+  schemes, darkening for light.
+- **Content** `--fg-0..3` reduce contrast toward the surface; `--fg-0` holds above the WCAG
+  AA floor (`>= 4.5`, or AAA / a custom band via `contrastBand`) against `--bg-0`.
+- **On-fill / on-tint text** (`--*-fg`, `--*-text`, `--color-*-contrast`) is swept to clear
+  AA against its pairing; fills get nudged out of the contrast dead-zone.
+- **Accent family** `--accent-2/3` flank the accent as a split-complement at ∓`accentSplit`;
+  `--accent-4` takes its 180° complement. `vibrancy` scales accent, status, and palette chroma.
+- **Status hues** track the named palette (success green, warn amber, danger red, info blue)
+  and follow a pin to those palette colors.
+- **State overlays** are scheme-aware neutral colors with alpha ~0.06 to 0.16.
+
+## Coverage
+
+Components declare what they consume; algorithms declare what they produce; the engine
+verifies the produced set covers the consumed set.
+
+```ts
+import { coverage } from "@xtyle/core";
+coverage(["--bg-0", "--fg-0", "--accent"], register);
+// { covered: true, missing: [] }
+```
+
+## The gauntlet
+
+Fires N extreme and random knob and constraint sets at a chosen algorithm and asserts
+*that algorithm's declared invariants*. Invariants are **dimension-aware**: each token
+carries a category (`color`, `length`, `number`, `font`, `shadow`, `duration`, `easing`),
+so the OKLCH parse only runs on color tokens while `--font-sans`, `--duration-fast`,
+`--text-lg`, and `--elevation-2` get the right format check for their kind. Asserts AA
+contrast floors, monotonic surfaces and palette ramps, hue fidelity, translucent overlays,
+and the structural ladders (type scale, weights, radius, borders, durations, elevation
+strength, space).
+
+```ts
+import { gauntlet } from "@xtyle/core";
+import { xtyleDefault } from "@xtyle/core/algorithms";
+const report = gauntlet(xtyleDefault, { runs: 200 });
+// { ok: true, passed: 200, runs: 200, failures: [] }
+```
+
+## Emitters
+
+`emit(register, format)` ships with `css` and `json`. The set is open;
+`registerEmitter(name, fn)` adds your own.
+
+## Algorithms are xript mods
+
+The `Algorithm` contract (`id`, `produces`, `knobs`, `categories`, `derive`, `invariants`)
+maps onto a xript mod: knobs as declared inputs, sandboxed by xript's capability model. The
+blessed set ships as real mods, a `mod-manifest.json` plus an esbuild-bundled `mod.js` run
+through `@xriptjs/runtime`, and `resolveAlgorithm` runs the sandboxed mod as the canonical
+derive path, held byte-identical to the baked TypeScript that serves as the test oracle.
+Author your own with `defineXtyleAlgorithm` / `defineAlgorithm` from `@xtyle/core/authoring`.
+
+## The MCP server
+
+`xtyle mcp` starts a Model Context Protocol server over stdio that hands an agent the same
+engine the CLI hands a human. Point an MCP client at `xtyle mcp` (or `npx -y @xtyle/core xtyle
+mcp`).
+
+- **Tools**: `xtyle_derive`, `xtyle_coverage`, `xtyle_components` (list every component or
+  describe one's full manifest), `xtyle_gauntlet`, `xtyle_list_algorithms`, and
+  `xtyle_server_info`; each runs the same code as its CLI counterpart, so the two can't drift.
+- **Resources**: `xtyle://concept/{id}` for the concept docs and `xtyle://component/{id}` for
+  every component manifest, so an agent answers from what ships rather than from memory.
+
+An agent building against xtyle reads token names and prop shapes from the manifest instead
+of guessing.
+
+## License
+
+MIT

package/algorithms.d.ts

@@ -0,0 +1,25 @@
+import type { Algorithm } from "@xtyle/core";
+
+export declare const xtyleDefault: Algorithm;
+export declare const xtyleHc: Algorithm;
+export declare const xtyleQuiet: Algorithm;
+export declare const xtyleLoud: Algorithm;
+export declare const nxiNite: Algorithm;
+export declare const algorithms: Record<string, Algorithm>;
+export declare function getAlgorithm(id: string): Algorithm;
+
+// The canonical (sandboxed, byte-identical) resolver on the importable surface. `resolveAlgorithm`
+// loads the shipped mod through the zero-authority sandbox; `snapshotAlgorithm` reads the resolved
+// mod synchronously once `resolveAlgorithm(id)` has settled, else `null`. `getAlgorithm` stays the
+// synchronous baked oracle and first-paint fallback.
+export declare function resolveAlgorithm(id: string): Promise<Algorithm>;
+export declare function snapshotAlgorithm(id: string): Algorithm | null;
+
+// The snapshot/cache bridge: returns the resolved sandboxed mod once `resolveAlgorithm(id)` has
+// warmed, and the synchronous baked oracle in the meantime, so a caller gets a usable algorithm
+// on the first paint and the byte-identical hosted mod thereafter.
+export declare function hostedAlgorithm(id: string): Algorithm;
+
+// The pure-derive path, re-exported so the whole thing is reachable from this one entry:
+// `import { derive, getAlgorithm, emitCss } from "@xtyle/core/algorithms"`.
+export { derive, deriveTraced, emit, emitCss, emitJson } from "@xtyle/core";

package/concepts/algorithms.md

@@ -0,0 +1,28 @@
+# Algorithms are xript plugins
+
+A xtyle algorithm is literally an xript plugin: a manifest plus xript code, with
+its knobs as declared inputs, run in xript's zero-authority sandbox. Because of
+that, xript's toolchain (validate, typegen, docgen, init) and its capability
+model come free; xtyle builds none of it.
+
+An algorithm lives under the top-level `algorithms/` directory as a real mod: a
+`mod-manifest.json` and a bundled `mod.js`. It is authored against an ergonomic
+surface (`@xtyle/core/authoring`) and imports the core engine by name. The host
+exposes color primitives to the sandbox as a gated binding, so an algorithm does
+OKLCH color math without being handed broad authority.
+
+## The blessed set
+
+xtyle ships a small built-in set, each its own xript plugin:
+
+- **xtyle-default**: the neutral default.
+- **xtyle-hc**: a high-contrast posture.
+- **xtyle-quiet**: muted, low-chroma.
+- **xtyle-loud**: saturated and high-energy.
+- **nxi-nite**: a multi-pass day/night algorithm whose register re-derives across
+  the hours.
+
+Each algorithm carries its own invariants and proves them with a gauntlet
+parameterized by that algorithm. A blessed algorithm derives byte-identical
+whether run baked or hosted through the sandbox, so the sandboxed mod is the
+canonical engine and the baked path is a fast, verified fallback.

package/concepts/consuming.md

@@ -0,0 +1,45 @@
+# Consuming a theme
+
+A derived theme is a flat set of CSS custom properties. You apply it once, at a
+scope, and the cascade does the rest. Every xtyle component reads those properties,
+so theming the tokens themes the whole component set at once.
+
+## The bindings
+
+One component contract, three bindings, all honoring the same derived tokens:
+
+- **`@xtyle/core/elements`**: the raw custom elements. Framework-agnostic; works
+  anywhere HTML does.
+- **`@xtyle/svelte`**: a thin Svelte wrapper over the same elements.
+- **`@xtyle/astro`**: Astro components, the binding this site is built from.
+
+A component renders one of two ways from a single fragment fill. Over
+Astro-rendered structure it adopts the existing markup as light DOM (zero-JS, no
+flash of unstyled content). Mounted bare, it attaches a shadow root and projects
+framework-owned children through native slots. The presence of server-rendered
+structure is the mode signal; it is auto-detected, never configured.
+
+## The CLI
+
+`@xtyle/core` ships a Node bin, `xtyle`, for build-time derivation and proofs:
+
+- `xtyle derive --bg <color> --accent <color> --format css` derives a theme and
+  emits it as CSS or JSON.
+- `xtyle gauntlet -a all --depth quick` spot-checks invariants across algorithms;
+  `--mode hosted --depth full` runs the full battery against the sandboxed mods.
+- `xtyle coverage --consumed a,b,c` checks a component's consumed tokens against a
+  produced register.
+
+The same engine runs in the browser through the QuickJS the xript runtime embeds,
+so live derivation in the generator and build-time derivation in the CLI are one
+codebase.
+
+## The MCP server
+
+`xtyle mcp` starts a Model Context Protocol server over stdio, handing an agent the
+same engine the CLI hands a human. The tools cover `xtyle_derive`,
+`xtyle_coverage`, `xtyle_components` (list a component or describe its full
+manifest), `xtyle_gauntlet`, and `xtyle_list_algorithms`; resources serve the
+concept docs and every component manifest. Point a client at `xtyle mcp` (or `npx
+-y @xtyle/core xtyle mcp`) and an agent building against xtyle reads token names and
+prop shapes from the manifest instead of guessing.

package/concepts/open-register.md

@@ -0,0 +1,28 @@
+# The open register and the coverage contract
+
+xtyle's token set is not a fixed schema. Authors declare new tokens and rewire any
+derivation; the register is open. That openness is held by exactly one hard
+contract: a **coverage check** between what components consume and what an
+algorithm produces.
+
+## How coverage works
+
+Every component declares the theme tokens it reads in its manifest
+(`consumedTokens`). Every algorithm produces a register of tokens. Coverage is
+the check that the second covers the first: for a given component set and a given
+algorithm, every consumed token must be produced. A gap is a contract violation,
+caught before anything renders.
+
+The line between a consumed theme token and a component-internal custom property
+matters. A custom property a component's own CSS defines and reads is not a
+consumed theme token; it never enters the coverage check. The lint and the
+coverage check agree on that line, so the contract never lies about what a theme
+must supply.
+
+## Why this is the only hard rule
+
+Because the register is open, there is no global schema to validate against. The
+coverage contract is what makes "any valid theme renders well out of the box"
+checkable rather than aspirational. It is the single seam every algorithm and
+every component meets at, and it is the only thing the engine enforces across the
+two.

package/concepts/overview.md

@@ -0,0 +1,43 @@
+# What xtyle is
+
+xtyle is a themable-derivation engine and component contract. A named, swappable
+**algorithm** maps a small set of overridable anchors plus a handful of knobs into
+a full, internally-consistent design-token set, co-designed against a component
+library so any valid theme renders well out of the box.
+
+The split that runs through everything: the algorithm is the durable, reusable
+asset; a **theme** is a materialized invocation of one. An algorithm is a named,
+composable engine you can share and reuse. A theme is the print it produces,
+anywhere from a quick three-color pick to a design dialed in over days. Both are
+first-class; the architecture just keeps the reusable machinery separate from any
+one materialized result.
+
+## The three input tiers
+
+Every derivation takes input at one of three levels, in increasing power:
+
+1. **Algorithm knobs.** Declared inputs an algorithm exposes (a split angle, a
+   contrast posture, a warmth bias). This is the whole casual UX: pick an
+   algorithm, turn its knobs, get a coherent theme.
+2. **Anchors (constraints).** A small set of seed colors the algorithm derives
+   from. `--bg-0`, `--fg-0`, and `--accent` are the common ones. They are
+   constraints fed back into derivation, not a privileged tier of their own.
+3. **Token overrides.** The universal escape hatch: pin any token in the register
+   directly. A well-built algorithm re-threads the rest of the ramp around a
+   pinned token rather than leaving an incoherent gap.
+
+## What stays in the engine, what lives in an algorithm
+
+The engine (`@xtyle/core`) is mechanism, never policy. It owns the open register,
+the dependency graph and lineage, the coverage contract, and emit. It has no
+opinion about how a ramp should look or what "pleasant" means. The **algorithm**
+is the opinion: how this one works. There is no engine-level "can't look bad"
+gospel; invariants are per-algorithm policy, proven by a gauntlet parameterized
+by algorithm.
+
+## The runtime is optional
+
+Once derived, a theme is just CSS custom properties plus the browser cascade. No
+engine needs to be running to use it. The engine can run live for the generator
+or for novel-at-runtime inputs, but nothing about consuming a finished theme
+depends on it.

package/dist/algorithms/factory.d.ts

@@ -0,0 +1,102 @@
+import { type OklchColor } from "../color.js";
+import { type TokenNode } from "../graph.js";
+import type { Algorithm, DeriveOptions, Invariant, Knobs, Pass, PassContext, Scheme, TokenCategories, TokenRegister, TraceSnapshot } from "../types.js";
+export declare const SURFACE_SEPARATION = 1.5;
+export declare const BORDER_SEPARATION = 1.5;
+export declare const DIVIDER_SEPARATION = 1.8;
+/**
+ * The posture an algorithm bakes in. The factory threads these through the same
+ * derivation math so the four shipped algorithms differ in taste (vibrancy,
+ * contrast strictness, elevation punch, accent / palette saturation) while sharing
+ * a single tested core. `contrastFloor` is the WCAG ratio the algorithm clamps
+ * derived text to; `declaredTextOnFillFloor` is the floor its gauntlet asserts.
+ */
+export type PresetAnchors = {
+    bg: string;
+    fg: string;
+    accent?: string;
+};
+export interface PresetDefaults {
+    id: string;
+    knobs: string[];
+    defaultAnchors: PresetAnchors;
+    contrastFloor: number;
+    declaredTextOnFillFloor: number;
+    defaultVibrancy: number;
+    accentChromaMul: number;
+    statusChromaMul: number;
+    paletteChromaMul: number;
+    neutralChroma: number;
+    elevationStrengthMul: number;
+    elevationAlphaBoost: number;
+    accentTintChromaMul: number;
+    extreme?: boolean;
+}
+/**
+ * Legal value sets for `keyword` (intent) tokens. A keyword token names a
+ * rendering *intent* a component branches on, so its values are a closed
+ * vocabulary, not free text; the format invariant rejects any algorithm that
+ * emits a value outside its token's domain.
+ */
+export declare const KEYWORD_DOMAINS: Record<string, readonly string[]>;
+export declare function enforceContrastFloor(fg: OklchColor, bg: OklchColor, scheme: Scheme, floor?: number): OklchColor;
+/**
+ * Floor a divider/border against the surface it delineates. A fixed lightness shift off the
+ * surface reads as a hairline in a mid-range theme, but collapses below perceptibility when the bg
+ * anchor nears a pole — a border on near-black goes invisible, so a bordered card on a near-black
+ * page loses its only separation channel. Push the border toward the readable pole until it clears
+ * `minContrast`.
+ */
+export declare function borderForContrast(seed: OklchColor, surface: OklchColor, minContrast: number): OklchColor;
+export declare function buildGraph(preset: PresetDefaults, opts: DeriveOptions): TokenNode[];
+/**
+ * The resolved base inputs a derivation reads, factored so both `buildGraph` and the
+ * pipeline's per-pass {@link PassContext} agree on anchors / scheme / pins for an
+ * identical request. Mirrors the head of {@link buildGraph}.
+ */
+export declare function resolveBaseInputs(preset: PresetDefaults, opts: DeriveOptions): {
+    knobs: Knobs;
+    scheme: Scheme;
+    pinned: TokenRegister;
+};
+export declare function buildPassContext(preset: PresetDefaults, opts: DeriveOptions, passIndex: number): PassContext;
+/**
+ * The shared pipeline runner every construction path uses, so baked and hosted forms
+ * run the identical pass code. The first pass receives an empty register and produces
+ * the base; each later pass transforms the register it is handed. Returns the final
+ * register and a snapshot after every pass (snapshot count === pass count).
+ */
+export declare function runPipeline(passes: Pass[], makeCtx: (passIndex: number) => PassContext): {
+    register: TokenRegister;
+    trace: TraceSnapshot[];
+};
+/**
+ * The base pass for the xtyle family: the whole current graph derivation expressed as
+ * pass one. It ignores the incoming register and rebuilds from `opts` so the pin
+ * re-entry and tail constraint sweep in {@link buildGraph} stay intact — making the
+ * four shipped algorithms strictly single-pass and byte-identical to today.
+ */
+export declare function settlePass(preset: PresetDefaults, opts: DeriveOptions): Pass;
+/**
+ * Re-emits a resolved register as value-only {@link TokenNode}s in key order. For a
+ * multi-pass algorithm this is the honest graph-as-data: each token carries its final
+ * composed value (refs collapse to literals, the truthful statement that the value is
+ * the pipeline's result). `resolveGraph(registerToNodes(r))` reproduces `r`.
+ */
+export declare function registerToNodes(register: TokenRegister): TokenNode[];
+export declare function makeInvariants(preset: PresetDefaults): Invariant[];
+export declare const PRODUCED_TOKENS: string[];
+export declare const TOKEN_CATEGORIES: TokenCategories;
+/**
+ * Builds an `Algorithm` from a preset and a pipeline factory. `buildPasses(preset, opts)`
+ * returns the ordered passes for one derivation; `derive` runs them and returns the final
+ * register, `deriveTraced` keeps every snapshot, and `passes` exposes a stable single-derive
+ * pass list for introspection. For a single-pass family algorithm `lineage` is the honest
+ * graph from {@link buildGraph}; for a multi-pass one it re-emits the final register as
+ * value-only nodes so `resolveGraph(lineage(opts)) === derive(opts)` holds either way.
+ */
+export declare function makeXtylePipelineAlgorithm(preset: PresetDefaults, buildPasses: (preset: PresetDefaults, opts: DeriveOptions) => Pass[]): Algorithm;
+export declare function makeXtyleAlgorithm(preset: PresetDefaults): Algorithm;
+export declare const SHARED_KNOBS: string[];
+export declare const DEFAULT_ANCHORS: PresetAnchors;
+//# sourceMappingURL=factory.d.ts.map

package/dist/algorithms/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/algorithms/factory.ts"],"names":[],"mappings":"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"}