@getvitops/generator 8.1.0 → 8.2.0-alpha.0

package/dist/schema-Dmq1J7S3.d.mts

@@ -0,0 +1,292 @@
+import * as z from "@zod/mini";
+//#region src/schema.d.ts
+declare const DesignSystemSchema: z.ZodMiniObject<{
+  $schema: z.ZodMiniOptional<z.ZodMiniString<string>>;
+  meta: z.ZodMiniOptional<z.ZodMiniObject<{
+    name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+  }, z.core.$strict>>;
+  colors: z.ZodMiniObject<{
+    palette: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+      seed: z.ZodMiniString<string>;
+      anchors: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+    }, z.core.$strict>, z.ZodMiniObject<{
+      tones: z.ZodMiniUnion<readonly [z.ZodMiniArray<z.ZodMiniString<string>>, z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>]>;
+    }, z.core.$strict>]>>;
+    roles: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
+      hue: z.ZodMiniString<string>;
+      kind: z.ZodMiniOptional<z.ZodMiniEnum<{
+        surface: "surface";
+        chromatic: "chromatic";
+      }>>;
+    }, z.core.$strict>]>>;
+    utilities: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniEnum<{
+      fill: "fill";
+      bg: "bg";
+      text: "text";
+      icon: "icon";
+      border: "border";
+      outline: "outline";
+      stroke: "stroke";
+    }>>>;
+  }, z.core.$strict>;
+  shadows: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+  fonts: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+  typeScale: z.ZodMiniOptional<z.ZodMiniObject<{
+    base: z.ZodMiniString<string>;
+    ratio: z.ZodMiniNumber<number>;
+    steps: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    names: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+    baseStep: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    baseline: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    fluid: z.ZodMiniOptional<z.ZodMiniObject<{
+      minVw: z.ZodMiniString<string>;
+      maxVw: z.ZodMiniString<string>;
+      minRatio: z.ZodMiniNumber<number>;
+    }, z.core.$strict>>;
+  }, z.core.$strict>>;
+  spaceScale: z.ZodMiniOptional<z.ZodMiniObject<{
+    base: z.ZodMiniString<string>;
+    ratio: z.ZodMiniNumber<number>;
+    steps: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    names: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+    baseStep: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    baseline: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    fluid: z.ZodMiniOptional<z.ZodMiniObject<{
+      minVw: z.ZodMiniString<string>;
+      maxVw: z.ZodMiniString<string>;
+      minRatio: z.ZodMiniNumber<number>;
+    }, z.core.$strict>>;
+  }, z.core.$strict>>;
+  patterns: z.ZodMiniOptional<z.ZodMiniObject<{
+    defaults: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+    radii: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+    groups: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>>;
+    z: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniNumber<number>>>;
+    items: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
+      group: z.ZodMiniOptional<z.ZodMiniString<string>>;
+      overrides: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+      element: z.ZodMiniOptional<z.ZodMiniString<string>>;
+      class: z.ZodMiniOptional<z.ZodMiniString<string>>;
+      fill: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+      default_role: z.ZodMiniOptional<z.ZodMiniString<string>>;
+      base: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+      states: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>>>;
+      roles: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+    }, z.core.$strict>>>;
+  }, z.core.$strict>>;
+  typography: z.ZodMiniOptional<z.ZodMiniObject<{
+    families: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+    roles: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>]>>>>;
+    headings: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+  }, z.core.$strict>>;
+  animations: z.ZodMiniOptional<z.ZodMiniObject<{
+    effects: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
+      kf: z.ZodMiniString<string>;
+      css: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>]>>>;
+      vars: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>]>>>;
+    }, z.core.$strict>>>;
+    journeys: z.ZodMiniOptional<z.ZodMiniObject<{
+      base: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>]>>>>;
+      compose: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniArray<z.ZodMiniString<string>>>>;
+    }, z.core.$strict>>;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+type DesignSystem = z.infer<typeof DesignSystemSchema>;
+/**
+ * Stable URL of the published JSON Schema. Resolves once `@getvitops/generator` is on
+ * npm (unpkg serves the packaged `schema.json`); `vitops init` stamps this into a
+ * scaffolded config's `$schema` so editors light up autocomplete + validation.
+ */
+declare const SCHEMA_URL = "https://unpkg.com/@getvitops/generator/schema.json";
+/**
+ * What `vitops init` actually stamps into a scaffolded config's `$schema`.
+ *
+ * A **local** path, following wrangler's `node_modules/wrangler/config-schema.json`.
+ * `SCHEMA_URL` has no version in it, so unpkg resolves it to whatever is newest
+ * — an editor validating a project pinned to generator 2.x silently checks it
+ * against the 3.x schema, reporting errors for valid config and accepting
+ * fields that do not exist yet. The installed copy is by definition the one
+ * that matches the toolchain doing the building.
+ *
+ * `SCHEMA_URL` remains the schema's `$id`, which is what it is for.
+ */
+declare const SCHEMA_LOCAL_PATH = "./node_modules/@getvitops/generator/schema.json";
+/** The published JSON Schema (draft-2020-12), derived from the zod schema. */
+declare const jsonSchema: {
+  "~standard": z.core.ZodStandardSchemaWithJSON<z.ZodMiniObject<{
+    $schema: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    meta: z.ZodMiniOptional<z.ZodMiniObject<{
+      name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+      description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$strict>>;
+    colors: z.ZodMiniObject<{
+      palette: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+        seed: z.ZodMiniString<string>;
+        anchors: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+      }, z.core.$strict>, z.ZodMiniObject<{
+        tones: z.ZodMiniUnion<readonly [z.ZodMiniArray<z.ZodMiniString<string>>, z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>]>;
+      }, z.core.$strict>]>>;
+      roles: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniObject<{
+        hue: z.ZodMiniString<string>;
+        kind: z.ZodMiniOptional<z.ZodMiniEnum<{
+          surface: "surface";
+          chromatic: "chromatic";
+        }>>;
+      }, z.core.$strict>]>>;
+      utilities: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniEnum<{
+        fill: "fill";
+        bg: "bg";
+        text: "text";
+        icon: "icon";
+        border: "border";
+        outline: "outline";
+        stroke: "stroke";
+      }>>>;
+    }, z.core.$strict>;
+    shadows: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+    fonts: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+    typeScale: z.ZodMiniOptional<z.ZodMiniObject<{
+      base: z.ZodMiniString<string>;
+      ratio: z.ZodMiniNumber<number>;
+      steps: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+      names: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+      baseStep: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+      baseline: z.ZodMiniOptional<z.ZodMiniString<string>>;
+      fluid: z.ZodMiniOptional<z.ZodMiniObject<{
+        minVw: z.ZodMiniString<string>;
+        maxVw: z.ZodMiniString<string>;
+        minRatio: z.ZodMiniNumber<number>;
+      }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    spaceScale: z.ZodMiniOptional<z.ZodMiniObject<{
+      base: z.ZodMiniString<string>;
+      ratio: z.ZodMiniNumber<number>;
+      steps: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+      names: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+      baseStep: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+      baseline: z.ZodMiniOptional<z.ZodMiniString<string>>;
+      fluid: z.ZodMiniOptional<z.ZodMiniObject<{
+        minVw: z.ZodMiniString<string>;
+        maxVw: z.ZodMiniString<string>;
+        minRatio: z.ZodMiniNumber<number>;
+      }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    patterns: z.ZodMiniOptional<z.ZodMiniObject<{
+      defaults: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+      radii: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+      groups: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>>;
+      z: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniNumber<number>>>;
+      items: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
+        group: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        overrides: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+        element: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        class: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        fill: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+        default_role: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        base: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+        states: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>>>;
+        roles: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+      }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    typography: z.ZodMiniOptional<z.ZodMiniObject<{
+      families: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+      roles: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>]>>>>;
+      headings: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+    }, z.core.$strict>>;
+    animations: z.ZodMiniOptional<z.ZodMiniObject<{
+      effects: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
+        kf: z.ZodMiniString<string>;
+        css: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>]>>>;
+        vars: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>]>>>;
+      }, z.core.$strict>>>;
+      journeys: z.ZodMiniOptional<z.ZodMiniObject<{
+        base: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>]>>>>;
+        compose: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniArray<z.ZodMiniString<string>>>>;
+      }, z.core.$strict>>;
+    }, z.core.$strict>>;
+  }, z.core.$strict>>;
+  $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#" | "http://json-schema.org/draft-04/schema#";
+  $id: string;
+  $anchor?: string;
+  $ref?: string;
+  $dynamicRef?: string;
+  $dynamicAnchor?: string;
+  $vocabulary?: Record<string, boolean>;
+  $comment?: string;
+  $defs?: Record<string, z.core.JSONSchema.JSONSchema>;
+  type?: z.core.JSONSchema.SchemaType | z.core.JSONSchema.SchemaType[];
+  additionalItems?: z.core.JSONSchema._JSONSchema;
+  unevaluatedItems?: z.core.JSONSchema._JSONSchema;
+  prefixItems?: z.core.JSONSchema._JSONSchema[];
+  items?: z.core.JSONSchema._JSONSchema | z.core.JSONSchema._JSONSchema[];
+  contains?: z.core.JSONSchema._JSONSchema;
+  additionalProperties?: z.core.JSONSchema._JSONSchema;
+  unevaluatedProperties?: z.core.JSONSchema._JSONSchema;
+  properties?: Record<string, z.core.JSONSchema._JSONSchema>;
+  patternProperties?: Record<string, z.core.JSONSchema._JSONSchema>;
+  dependentSchemas?: Record<string, z.core.JSONSchema._JSONSchema>;
+  propertyNames?: z.core.JSONSchema._JSONSchema;
+  if?: z.core.JSONSchema._JSONSchema;
+  then?: z.core.JSONSchema._JSONSchema;
+  else?: z.core.JSONSchema._JSONSchema;
+  allOf?: z.core.JSONSchema.JSONSchema[];
+  anyOf?: z.core.JSONSchema.JSONSchema[];
+  oneOf?: z.core.JSONSchema.JSONSchema[];
+  not?: z.core.JSONSchema._JSONSchema;
+  multipleOf?: number;
+  maximum?: number;
+  exclusiveMaximum?: number | boolean;
+  minimum?: number;
+  exclusiveMinimum?: number | boolean;
+  maxLength?: number;
+  minLength?: number;
+  pattern?: string;
+  maxItems?: number;
+  minItems?: number;
+  uniqueItems?: boolean;
+  maxContains?: number;
+  minContains?: number;
+  maxProperties?: number;
+  minProperties?: number;
+  required?: string[];
+  dependentRequired?: Record<string, string[]>;
+  enum?: Array<string | number | boolean | null>;
+  const?: string | number | boolean | null;
+  id?: string;
+  title?: string;
+  description?: string;
+  default?: unknown;
+  deprecated?: boolean;
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  nullable?: boolean;
+  examples?: unknown[];
+  format?: string;
+  contentMediaType?: string;
+  contentEncoding?: string;
+  contentSchema?: z.core.JSONSchema.JSONSchema;
+  _prefault?: unknown;
+};
+type ValidationResult = {
+  ok: true;
+  data: DesignSystem;
+  errors: [];
+  warnings: string[];
+} | {
+  ok: false;
+  data: undefined;
+  errors: z.core.$ZodIssue[];
+  warnings: string[];
+};
+/**
+ * Validate an unknown value against the design-system schema.
+ *
+ * `warnings` are configurations that parse and generate, but produce output that
+ * won't behave as authored — currently only the token-namespace collisions the
+ * flat `--<prop>-<name>` grammar makes possible.
+ */
+declare function validate(input: unknown): ValidationResult;
+//#endregion
+export { ValidationResult as a, SCHEMA_URL as i, DesignSystemSchema as n, jsonSchema as o, SCHEMA_LOCAL_PATH as r, validate as s, DesignSystem as t };
+//# sourceMappingURL=schema-Dmq1J7S3.d.mts.map

package/dist/schema-Dmq1J7S3.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-Dmq1J7S3.d.mts","names":[],"sources":["../src/schema.ts"],"mappings":";;cAsQa,oBAAkB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwC7B,EAAA,KAAA;KAEU,eAAe,EAAE,aAAa;;;;;;cA0B7B;;;;;;;;;;;;;cAcA;;cAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkDD;EACN;EAAU,MAAM;EAAc;EAAY;;EAC1C;EAAW;EAAiB,QAAQ,EAAE,KAAK;EAAa;;;;;;;;;iBAsD9C,SAAS,iBAAiB"}

package/dist/tokens-8SXMDAd1.d.mts

@@ -0,0 +1,229 @@
+import { t as DesignSystem } from "./schema-Dmq1J7S3.mjs";
+//#region src/shared.d.ts
+/**
+ * Data shared between the generator (`generate.ts`) and the docs bundle
+ * (`docs.ts`). Lives in its own module because `generate.ts` imports `docs.ts` —
+ * importing back the other way would be a cycle.
+ */
+/**
+ * Selector the dark functional-token flip hangs off.
+ *
+ * `data-brx-theme` is Bricks' own attribute — Bricks sets it, so it's what the
+ * WordPress target needs. Nothing sets it anywhere else, which meant the dark
+ * flip was unreachable outside Bricks: the shipped `<wc-color-scheme-toggle>` web
+ * component writes `documentElement.dataset.theme` (i.e. `data-theme`), so
+ * clicking "Dark" changed an attribute no rule matched. Matching both makes the
+ * component work on every target without changing what Bricks already does.
+ *
+ * This covers the EXPLICIT choice. The OS preference is a second, opt-in block —
+ * see `SYSTEM_DARK_SEL` — because turning it on flips a site dark for dark-OS
+ * users, which is the site's decision rather than the design system's.
+ *
+ * Shared so the docs quote the selector the generator actually emits.
+ */
+declare const DARK_SEL = ":root[data-brx-theme=\"dark\"], :root[data-theme=\"dark\"]";
+/**
+ * Roles the shipped CSS partials reference with NO fallback, so a config that
+ * omits one leaves those rules resolving to nothing — an invalid declaration,
+ * not a graceful degrade.
+ *
+ * `colors.roles` is an open record: any name works and generates a full token
+ * set, utilities and dark flip. But the framework's own component CSS is
+ * written against these six, so "roles are arbitrary" is only half true — they
+ * are *extensible*, over a required core. `validate()` warns when one is
+ * missing; `required-roles.test.ts` re-derives this list from the partials so
+ * it cannot drift as components are added.
+ *
+ * Kept as a constant rather than scanned at call time because `validate()` is
+ * a pure function — the CLI, the Vite plugin and `toJSONSchema` all import it,
+ * and none of them should touch the filesystem to answer "is this config ok?".
+ */
+declare const REQUIRED_ROLES: readonly string[];
+/**
+ * Every token key a role can resolve to, across both role kinds. Shared so the
+ * required-roles drift test greps for exactly what the generator emits.
+ *
+ * These are *keys*, not var names: the role sits in the middle of the property
+ * (`--color-bg-danger-muted`), so compose them with `tokenVar()` from `tokens.ts`
+ * rather than concatenating by hand.
+ */
+declare const ROLE_TOKEN_KEYS: readonly string[];
+/** How a role is authored in `colors.roles`: a bare hue, or a hue plus its kind. */
+type RoleSpec = string | {
+  hue: string;
+  kind?: 'surface' | 'chromatic' | undefined;
+};
+/** The palette hue a role points at, through either authoring form. */
+declare const roleHue: (spec: RoleSpec) => string;
+/**
+ * A role's kind. The bare-string shorthand means `chromatic`, because signal
+ * colours are the common case and surfaces are the two or three you name once.
+ */
+declare const roleKind: (spec: RoleSpec) => "surface" | "chromatic";
+/**
+ * Pattern base geometry props → per-pattern override-hook shorthand. Each hook
+ * wraps the authored value (`padding: var(--p-btn, 0.4em 0.8em)`) so a
+ * consumer restyles one pattern by setting one variable. The hook is named after
+ * the pattern's key, not its class.
+ */
+declare const BASE_HOOK: Record<string, string>;
+/**
+ * A typography role's declared key → [CSS property, var-name suffix]. The
+ * recognised key set is CLOSED (an unrecognised key is a config error, see
+ * `generate.ts`'s `ALSO_MEANT`) — shared here (rather than living only in
+ * `generate.ts`) because `tokens.ts`'s `buildReverseIndex` needs the exact
+ * same key → suffix mapping to stay in step with what `generate()` itself
+ * builds, and `tokens.ts` can't import from `generate.ts` (the CSS-bundling
+ * half, which needs lightningcss/node:fs) without losing its own
+ * Worker-safety.
+ */
+declare const TYPO_KEYMAP: Record<string, [string, string]>;
+/**
+ * Framework utility classes whose names collide with Tailwind's own defaults.
+ * The `tailwind` format strips any rule targeting these — Tailwind provides
+ * them, so consumers use Tailwind's utilities for these names instead.
+ */
+declare const TW_CLASH: ReadonlySet<string>;
+//#endregion
+//#region src/tokens.d.ts
+declare const NUMERIC_STEPS: readonly ["50", "100", "200", "300", "400", "500", "600", "700", "800", "900", "950"];
+type NumStep = (typeof NUMERIC_STEPS)[number];
+interface ExpandedHue {
+  /** Numeric steps (sparse for fixed-tone kits). */
+  numeric: Partial<Record<NumStep, string>>;
+  /** True when only authored tones + endpoints exist (no interpolation). */
+  sparse?: boolean;
+  /**
+   * Steps the author pinned, and how far each sits from the ladder's lightness.
+   * A pinned colour is reproduced exactly, so a large value here is legal — but
+   * it means this hue reads heavier or lighter than its siblings at that step,
+   * which the generator surfaces as a warning.
+   */
+  deviations?: Partial<Record<NumStep, number>>;
+}
+/** Expand every palette hue into its numeric scale. */
+declare function expandPalette(raw: Record<string, unknown>): Record<string, ExpandedHue>;
+declare function ladderWarnings(palette: Record<string, ExpandedHue>): string[];
+/**
+ * Ramps whose lightness does not fall monotonically from 50 to 950.
+ *
+ * A ramp built from the ladder alone cannot invert — only pinned colours (a seed,
+ * an `anchor`, a `tones` entry) can, because they are the one thing allowed off
+ * it. `ladderWarnings` will not catch it: it compares each pinned step against
+ * *its own* ladder rung, never against its neighbours, so it reports the wrong
+ * defect ("reads darker than others at 600") while the real problem is that 600
+ * is darker than 700. And since `LADDER_TOLERANCE` is 0.03 — the same size as the
+ * ladder's own 50→100 gap — two anchors can each sit within tolerance and still
+ * invert, with no warning at all.
+ *
+ * This is an error rather than a warning because the rest of the system assumes
+ * the order: `snap` picks the nearest step by ladder lightness, the mode-stable
+ * solid family hard-codes 600/700/800 as increasingly dark, and both dark tables
+ * re-point steps on the same assumption. An inverted ramp therefore runs hover
+ * states backwards — the failure the fixed ladder was introduced to eliminate.
+ */
+declare function monotonicityErrors(palette: Record<string, ExpandedHue>): string[];
+/** Which shape of token set a role gets. */
+type RoleKind = 'surface' | 'chromatic';
+/**
+ * Map a token key to its CSS custom property for a given role.
+ *
+ * `on` is the one irregular case: the foreground for a filled surface reads
+ * `--color-text-on-<role>`, with the role *after* `on`, because it names what it
+ * sits on rather than what it is.
+ *
+ * The utility class name is this minus the `--color-` prefix, which is why the
+ * emitter and the linter can both derive their vocabulary from one function.
+ */
+declare function tokenVar(role: string, key: string): string;
+/** The class name a token key produces for a role (`bg-danger-solid`, …). */
+declare const tokenClass: (role: string, key: string) => string;
+interface FunctionalRole {
+  role: string;
+  hue: string;
+  kind: RoleKind;
+  /** token key → CSS value, per appearance. */
+  light: Record<string, string>;
+  dark: Record<string, string>;
+}
+/** Resolve the token set for one role over its hue. */
+declare function functionalRole(role: string, hueName: string, hue: ExpandedHue, kind?: RoleKind): FunctionalRole;
+/**
+ * APCA targets. `TEXT` is the body-text bar; `SECONDARY` covers text on a
+ * non-primary surface and de-emphasised text. `NON_TEXT` is the icon/boundary
+ * tier — the APCA analogue of WCAG's 3:1, where a glyph may run more vivid than
+ * text because shape carries meaning alongside contrast.
+ */
+declare const CONTRAST: {
+  readonly TEXT: 75;
+  readonly SECONDARY: 60;
+  readonly NON_TEXT: 45;
+};
+/**
+ * Verify a role's contrast targets. Returns human-readable failures.
+ *
+ * Chromatic roles are checked against the surface planes they actually sit on
+ * (`surfaceBg`) as well as their own tints — coloured text almost never appears
+ * over its own solid, it appears over the page. Checking only within the role
+ * would have missed the pairing that matters most.
+ */
+declare function checkContrast(fr: FunctionalRole, numericOf: (hueName: string) => Partial<Record<NumStep, string>>, surfaceBg?: {
+  light: string[];
+  dark: string[];
+}): string[];
+/**
+ * Runs the same monotonicity + contrast contract `generate()`'s `build()`
+ * enforces at build time (by throwing), standalone and non-throwing — for a
+ * caller that needs to validate a `colors` subtree *before* handing it to
+ * `generate()`, most notably the EmDash design-system-editor's save route
+ * (see AGENTS.md's "live theme editor" section): a client's edit gets the
+ * exact same accessibility gate a real build would apply, synchronously, at
+ * save time, rather than only discovering a violation at the next deploy.
+ *
+ * Deliberately re-derives `expandPalette`/`functionalRole` independently
+ * rather than sharing state with `build()` — both are cheap, pure
+ * computations, and keeping this standalone means it has no dependency on
+ * `generate.ts`'s CSS-bundling half (which needs lightningcss/node:fs) and so
+ * stays reachable from a Worker.
+ */
+declare function validateColorContract(colors: {
+  palette: Record<string, unknown>;
+  roles: Record<string, RoleSpec>;
+}): string[];
+/**
+ * The `reverseIndex` half of `generate()`'s `design-manifest.json` (css
+ * format), standalone — a CSS var name → the config path that produced it
+ * (e.g. `--color-navy-500` → `colors.palette.navy.anchors.500`). Kept in exact
+ * step with the block inside `generate.ts`'s `build()` that builds the same
+ * map (both read `TYPO_KEYMAP`/`BASE_HOOK` from `shared.ts`, never duplicated
+ * inline) — this is the standalone half for a caller that has a
+ * `DesignSystem` but no built `design-manifest.json` to fetch, most notably
+ * the EmDash design-system-editor plugin route: a deployed Worker has no
+ * filesystem to read a manifest asset from over HTTP without adding a
+ * `network:request` capability + a hostname declared in `allowedHosts` for
+ * *the site's own, deployment-specific* origin — recomputing this from the
+ * `DesignSystem` the site's own build already bundles avoids that entirely.
+ */
+declare function buildReverseIndex(ds: Pick<DesignSystem, 'colors' | 'typography' | 'patterns'>): Record<string, string>;
+/**
+ * Turns a design-system PATCH (paths matching `manifest.reverseIndex`'s own
+ * config-path values, e.g. `colors.palette.navy.anchors.500`) into the runtime
+ * `:root` override `<wc-theme-editor>` already injects client-side for its own
+ * live preview — server-rendered instead, for the EmDash design-system-editor
+ * plugin route to serve site-wide via a `page:fragments` `html` contribution
+ * (see AGENTS.md's "live theme editor" + "EmDash plugin as the design-system
+ * editing surface" sections). `''` (no matching var, or an empty patch) means
+ * "nothing to override" — the caller should serve no fragment at all rather
+ * than an empty `<style>` tag.
+ *
+ * Inverts `reverseIndex` (`cssVar → configPath`) once into `configPath →
+ * cssVar`, so it costs one pass regardless of how deep the patch nests. A
+ * patched leaf with no matching var (a `reverseIndex` miss — the same case
+ * `<wc-theme-editor>`'s own `buildPatch()` calls "skipped") is silently
+ * omitted here too, for the same reason: a value with nothing to preview is
+ * not an error, just nothing to show yet.
+ */
+declare function patchToOverrideCss(patch: Record<string, unknown>, reverseIndex: Record<string, string>): string;
+//#endregion
+export { roleHue as C, TYPO_KEYMAP as S, DARK_SEL as _, RoleKind as a, RoleSpec as b, expandPalette as c, monotonicityErrors as d, patchToOverrideCss as f, BASE_HOOK as g, validateColorContract as h, NUMERIC_STEPS as i, functionalRole as l, tokenVar as m, ExpandedHue as n, buildReverseIndex as o, tokenClass as p, FunctionalRole as r, checkContrast as s, CONTRAST as t, ladderWarnings as u, REQUIRED_ROLES as v, roleKind as w, TW_CLASH as x, ROLE_TOKEN_KEYS as y };
+//# sourceMappingURL=tokens-8SXMDAd1.d.mts.map

package/dist/tokens-8SXMDAd1.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens-8SXMDAd1.d.mts","names":[],"sources":["../src/shared.ts","../src/tokens.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;cAsBa;;;;;;;;;;;;;;;;;cAmCA;;;;;;;;;cAiBA;;KA+BD;EAAsB;EAAa;;;cAGlC,UAAW,MAAM;;;;;cAMjB,WAAY,MAAM;;;;;;;cASlB,WAAW;;;;;;;;;;;cAuBX,aAAa;;;;;;cAkBb,UAAU;;;cCtHV;KAaR,kBAAkB;UAWN;;EAEf,SAAS,QAAQ,OAAO;;EAExB;;;;;;;EAOA,aAAa,QAAQ,OAAO;;;iBAwHd,cAAc,KAAK,0BAA0B,eAAe;iBAmB5D,eAAe,SAAS,eAAe;;;;;;;;;;;;;;;;;;;iBAyCvC,mBAAmB,SAAS,eAAe;;KA0C/C;;;;;;;;;;;iBA8FI,SAAS,cAAc;;cAU1B,aAAc,cAAc;UAGxB;EACf;EACA;EACA,MAAM;;EAEN,OAAO;EACP,MAAM;;;iBAIQ,eACd,cACA,iBACA,KAAK,aACL,OAAM,WACL;;;;;;;cAqCU;;;;;;;;;;;;;iBAiBG,cACd,IAAI,gBACJ,YAAY,oBAAoB,QAAQ,OAAO,mBAC/C;EAAc;EAAiB;;;;;;;;;;;;;;;;;iBA0FjB,sBAAsB;EACpC,SAAS;EACT,OAAO,eAAe;;;;;;;;;;;;;;;;iBAgDR,kBAAkB,IAAI,KAAK,sDAAmD;;;;;;;;;;;;;;;;;;;iBAyD9E,mBACd,OAAO,yBACP,cAAc"}