@clhaas/palette-kit 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+<!-- markdownlint-disable MD024 -->
+
+## v0.4.0
+
+### Breaking changes
+
+- Replaces the previous experimental `createTheme` API with `createPaletteKit`.
+- Publishes only the package root export. CLI commands, token exporters, and
+  serializer subpaths are not part of v0.4.
+- Resolver options are modeled as explicit axes: `usage`, `intent`, `level`,
+  relation, `state`, `context`, and `output`.
+
+### Features
+
+- Public `createPaletteKit` factory and `palette.resolve`.
+- Public resolver presets: `soft`, `neutral`, and `strong`.
+- Explicit `resolverConfig` overrides for level curves, state deltas, relation
+  parameters, and chroma limits.
+- APCA contrast enforcement for `on` relations with a default Lc 60 target.
+- Functional `over` and `under` overlay relations with configured alpha and
+  depth behavior.
+- Supported outputs: `oklch`, `oklab`, `srgb`, `p3`, `hex`, and `rgba`.
+- Strict public TypeScript option types for invalid usage/level/relation/state
+  combinations where possible.
+
 ## v0.3.0
 
 ### Breaking changes

package/README.md

@@ -1,127 +1,120 @@
 # Palette Kit
 
-Palette Kit is a **runtime-first color engine** for generating OKLCH-based palettes from semantic queries, with optional build-time tooling (serializer, exporters, CLI, codegen).
+Palette Kit v0.4 is a deterministic OKLCH color resolution engine. It resolves
+semantic color requests from explicit axes and serializes the result only after
+resolution.
 
 ## Install
 
-```bash
+```sh
 npm install @clhaas/palette-kit
 ```
 
-## Runtime quick start
+## Quick Start
 
 ```ts
-import { createTheme } from "@clhaas/palette-kit";
+import { createPaletteKit } from "@clhaas/palette-kit";
 
-const theme = createTheme({
-  seeds: {
-    light: { neutral: "#111827", accent: "#3d63dd" },
-    dark: { neutral: "#111827", accent: "#3d63dd" },
+const palette = createPaletteKit({
+  context: "light",
+  output: "oklch",
+  preset: "neutral",
+  intents: {
+    brand: { hue: 260, chroma: 0.14 },
+    neutral: { hue: 0, chroma: 0 },
   },
-  preset: "modern",
 });
 
-const bg = theme.resolve({
-  role: "bg.app",
-  usage: "bg",
-  surface: "app",
-  context: "light",
+const surface = palette.resolve({
+  usage: "fill",
+  intent: "neutral",
+  level: 2,
 });
 
-const onSolidText = theme.onSolid({
-  bgRole: "bg.app",
-  usage: "text",
-  context: "light",
-  contrast: { model: "apca", targetLc: 75 },
+const text = palette.resolve({
+  usage: "visualVocabulary",
+  intent: "brand",
+  on: surface,
 });
 ```
 
-## Serializer (public)
+## Public Runtime API
 
-Use the serializer to turn resolved OKLCH into CSS/RN-ready strings:
-
-```ts
-import { createTheme } from "@clhaas/palette-kit";
-import { serializeResolved } from "@clhaas/palette-kit/serialize";
+The package root exports:
 
-const theme = createTheme({
-  seeds: {
-    light: { neutral: "#111827", accent: "#3d63dd" },
-    dark: { neutral: "#111827", accent: "#3d63dd" },
-  },
-});
+- `createPaletteKit`
+- `softResolverConfig`
+- `neutralResolverConfig`
+- `strongResolverConfig`
+- `defaultResolverConfig`
 
-const resolved = theme.resolve({ role: "bg.app", usage: "bg", surface: "app" });
-const color = serializeResolved(resolved, { preferSpace: "srgb", srgbFormat: "hex" });
+Public TypeScript types are also exported from the package root.
 
-console.log(color.value);
-```
+There are no public subpath exports, CLI commands, token exporters, or codegen
+APIs in v0.4.
 
-## Exporters (public, build-time)
+## Resolver Rules
 
-Export deterministic CSS variables and JSON tokens:
+| Usage | Level | Relations |
+| --- | --- | --- |
+| `fill` | Required | `on` optional |
+| `visualVocabulary` | Forbidden | `on` required |
+| `lines` | Required | `on` optional |
+| `overlays` | Required | `over` or `under` optional |
 
-```ts
-import { createTheme } from "@clhaas/palette-kit";
-import { exportThemeCss, exportThemeJson } from "@clhaas/palette-kit/export";
+`state` defaults to `"default"`. Non-default states require explicit
+`stateDirection`; Palette Kit never infers whether state should increase or
+decrease lightness.
 
-const theme = createTheme({
-  seeds: {
-    light: { neutral: "#111827", accent: "#3d63dd" },
-    dark: { neutral: "#111827", accent: "#3d63dd" },
-  },
-});
+Context is explicit. Provide palette-level `context`, resolver-level `context`,
+or host-injected `systemDefaultContext`. Context affects default level curves;
+for example, dark context inverts the structural lightness scale while
+preserving intent hue and chroma.
 
-const tokens = {
-  "bg.app": { usage: "bg", surface: "app" },
-  "text.primary": { usage: "text", surface: "surface" },
-};
+## Output
 
-const { css } = exportThemeCss(theme, tokens, { includeSpaces: ["oklch", "p3"] });
-const json = exportThemeJson(theme, tokens, { includeSpaces: ["srgb"] });
-```
+Supported outputs:
 
-## CLI
+- `oklch`: normalized OKLCH object
+- `oklab`: OKLab object
+- `srgb`: `{ r, g, b, alpha }`
+- `p3`: Display-P3 `{ r, g, b, alpha }`
+- `hex`: `#rrggbb`
+- `rgba`: `{ r, g, b, a }`
 
-- `palette-kit init` creates `palette.config.ts`
-- `palette-kit build` writes `dist/palette/` artifacts (`tokens.css`, `tokens.json`, `tokens.ts`, `tokens.d.ts`)
+RGB-like outputs use clipped 8-bit channels. Output never changes semantic
+resolution.
 
-See `docs/CLI.md` for flags and config details.
+Output precedence is resolver-level `output`, then palette-level `output`, then
+host-injected `systemDefaultOutput`, then the explicit `oklch` default.
 
-## Docs
+## Configuration
 
-- `docs/README.md`
-- `docs/_api-surface.md`
-- `docs/Exporters.md`
-- `docs/CLI.md`
-- `docs/Migration.md`
+`createPaletteKit` accepts `preset` and explicit `resolverConfig` overrides.
 
-## Compatibility
+```ts
+const palette = createPaletteKit({
+  context: "light",
+  preset: "soft",
+  intents,
+  resolverConfig: {
+    relationParams: {
+      on: { contrastTarget: 75 },
+    },
+  },
+});
+```
 
-- ESM package (`"type": "module"`).
-- CJS is not supported in v0.3; use ESM or dynamic `import()` in CJS environments.
-- Subpath imports:
-  - `@clhaas/palette-kit/serialize`
-  - `@clhaas/palette-kit/export`
-  - `@clhaas/palette-kit/cli`
-- Tree-shaking: runtime imports (`@clhaas/palette-kit`) do not bundle build-time tools (exporters/CLI).
+The default preset is `neutral`.
 
-### CommonJS note
+## Documentation
 
-```js
-// CJS workaround (dynamic import)
-(async () => {
-  const { createTheme } = await import("@clhaas/palette-kit");
-  const theme = createTheme({
-    seeds: {
-      light: { neutral: "#111827", accent: "#3d63dd" },
-      dark: { neutral: "#111827", accent: "#3d63dd" },
-    },
-  });
-  console.log(theme);
-})();
-```
+- [Docs index](docs/README.md)
+- [API](docs/API.md)
+- [Configuration](docs/Config.md)
+- [Specification summary](docs/spec.md)
+- [Migration](docs/Migration.md)
 
-## License
+## Module Format
 
-MIT — see `LICENSE`.
+Palette Kit is ESM-only.

package/dist/contrast/contrast.d.ts

@@ -0,0 +1,16 @@
+import { type OklchColor } from '../core/oklch.js';
+import type { Context } from '../engine/context/context.js';
+import type { ChromaConfig, RelationParamsConfig } from '../presets/presets.js';
+export type ContrastResolutionConfig = Readonly<{
+    on: RelationParamsConfig['on'];
+    chromaLimits: ChromaConfig;
+}>;
+export type ContrastResolutionInput = Readonly<{
+    color: OklchColor;
+    target: OklchColor;
+    context: Context;
+    config: ContrastResolutionConfig;
+}>;
+export declare function measureApcaContrast(foreground: OklchColor, background: OklchColor): number;
+export declare function measureWcagContrast(foreground: OklchColor, background: OklchColor): number;
+export declare function resolveOnContrast({ color, config, context, target, }: ContrastResolutionInput): OklchColor;

package/dist/contrast/contrast.js

@@ -0,0 +1,102 @@
+import { APCAcontrast, sRGBtoY } from 'apca-w3';
+import { normalizeOklch } from '../core/oklch.js';
+import { serializeOklchToSrgb } from '../export/serialize.js';
+import { createContrastUnsatisfiableError } from '../utils/errors/errors.js';
+const LIGHTNESS_STEP = 0.5;
+const CONTRAST_PRECISION = 2;
+const clampLightness = (value) => Math.min(100, Math.max(0, value));
+const roundContrast = (contrast) => Number(contrast.toFixed(CONTRAST_PRECISION));
+export function measureApcaContrast(foreground, background) {
+    const foregroundRgb = serializeOklchToSrgb(foreground);
+    const backgroundRgb = serializeOklchToSrgb(background);
+    const contrast = APCAcontrast(sRGBtoY([foregroundRgb.r, foregroundRgb.g, foregroundRgb.b]), sRGBtoY([backgroundRgb.r, backgroundRgb.g, backgroundRgb.b]));
+    const numericContrast = typeof contrast === 'number' ? contrast : Number(contrast);
+    if (Number.isFinite(numericContrast)) {
+        return numericContrast;
+    }
+    const wcagContrast = measureWcagContrast(foreground, background);
+    const polarity = foreground.l <= background.l ? 1 : -1;
+    return polarity * wcagContrast * 10;
+}
+const channelToLinear = (channel) => {
+    const normalized = channel / 255;
+    return normalized <= 0.03928
+        ? normalized / 12.92
+        : ((normalized + 0.055) / 1.055) ** 2.4;
+};
+const relativeLuminance = (color) => {
+    const rgb = serializeOklchToSrgb(color);
+    return (0.2126 * channelToLinear(rgb.r) +
+        0.7152 * channelToLinear(rgb.g) +
+        0.0722 * channelToLinear(rgb.b));
+};
+export function measureWcagContrast(foreground, background) {
+    const foregroundLuminance = relativeLuminance(foreground);
+    const backgroundLuminance = relativeLuminance(background);
+    const lighter = Math.max(foregroundLuminance, backgroundLuminance);
+    const darker = Math.min(foregroundLuminance, backgroundLuminance);
+    return (lighter + 0.05) / (darker + 0.05);
+}
+const hasTargetContrast = (contrast, target) => Math.abs(contrast) >= target;
+const createCandidate = (color, lightness, chroma) => normalizeOklch({
+    alpha: color.alpha,
+    c: Math.max(0, chroma),
+    h: color.h,
+    l: clampLightness(lightness),
+});
+const selectContrastDirections = (target, context) => {
+    if (target.l < 45) {
+        return ['increase', 'decrease'];
+    }
+    if (target.l > 55) {
+        return ['decrease', 'increase'];
+    }
+    return context === 'dark'
+        ? ['increase', 'decrease']
+        : ['decrease', 'increase'];
+};
+const scanLightness = (color, target, chroma, direction, maxLuminanceShift, contrastTarget) => {
+    const signedStep = direction === 'increase' ? LIGHTNESS_STEP : -LIGHTNESS_STEP;
+    const iterations = Math.ceil(maxLuminanceShift / LIGHTNESS_STEP);
+    let bestColor = createCandidate(color, color.l, chroma);
+    let bestContrast = measureApcaContrast(bestColor, target);
+    for (let index = 0; index <= iterations; index += 1) {
+        const lightness = color.l + signedStep * index;
+        const shift = Math.abs(lightness - color.l);
+        if (shift > maxLuminanceShift) {
+            break;
+        }
+        const candidate = createCandidate(color, lightness, chroma);
+        const contrast = measureApcaContrast(candidate, target);
+        if (Math.abs(contrast) > Math.abs(bestContrast)) {
+            bestColor = candidate;
+            bestContrast = contrast;
+        }
+        if (hasTargetContrast(contrast, contrastTarget)) {
+            break;
+        }
+    }
+    return { bestColor, bestContrast };
+};
+export function resolveOnContrast({ color, config, context, target, }) {
+    const contrastTarget = config.on.contrastTarget;
+    const maxReduction = Math.min(color.c, color.c * config.chromaLimits.maxReduction);
+    const chromaStep = config.chromaLimits.reductionStep;
+    let bestContrast = measureApcaContrast(color, target);
+    if (hasTargetContrast(bestContrast, contrastTarget)) {
+        return Object.freeze(color);
+    }
+    for (let reduction = 0; reduction <= maxReduction + chromaStep / 2; reduction += chromaStep) {
+        const chroma = Math.max(0, color.c - reduction);
+        for (const direction of selectContrastDirections(target, context)) {
+            const result = scanLightness(color, target, chroma, direction, config.on.maxLuminanceShift, contrastTarget);
+            if (Math.abs(result.bestContrast) > Math.abs(bestContrast)) {
+                bestContrast = result.bestContrast;
+            }
+            if (hasTargetContrast(result.bestContrast, contrastTarget)) {
+                return Object.freeze(result.bestColor);
+            }
+        }
+    }
+    throw createContrastUnsatisfiableError(roundContrast(Math.abs(bestContrast)), contrastTarget);
+}

package/dist/core/intent-registry.d.ts

@@ -0,0 +1,11 @@
+export type IntentName = string;
+export type IntentDefinition = {
+    hue: number;
+    chroma: number;
+};
+export type IntentRegistry<I extends string = string> = Readonly<{
+    intents: Readonly<Record<I, Readonly<IntentDefinition>>>;
+}>;
+export declare function createIntentRegistry<const I extends string>(intents: Record<I, IntentDefinition>): IntentRegistry<I>;
+export declare function hasIntent<I extends string>(registry: IntentRegistry<I>, intent: IntentName): intent is I;
+export declare function getIntent<I extends string>(registry: IntentRegistry<I>, intent: IntentName): Readonly<IntentDefinition>;

package/dist/core/intent-registry.js

@@ -0,0 +1,70 @@
+import { createUnknownIntentError } from '../utils/errors/errors.js';
+const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
+const normalizeHue = (hue) => {
+    const normalized = ((hue % 360) + 360) % 360;
+    return Object.is(normalized, -0) ? 0 : normalized;
+};
+const forbiddenIntentTokens = Object.freeze({
+    level: new Set(['strong', 'subtle', 'weak', 'muted', 'heavy']),
+    relation: new Set(['on', 'over', 'under', 'overlay']),
+    state: new Set(['hover', 'active', 'focus', 'selected', 'disabled']),
+    usage: new Set(['text', 'border', 'icon', 'fill', 'line', 'lines']),
+    visual: new Set(['green', 'red', 'blue', 'dark', 'light']),
+});
+const splitIntentName = (name) => name
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .split(/[-_]+|\s+/)
+    .map((part) => part.toLowerCase())
+    .filter((part) => part.length > 0);
+const validateIntentName = (name) => {
+    if (name.length === 0) {
+        throw new Error('Intent name must not be empty.');
+    }
+    if (/\s/.test(name)) {
+        throw new Error(`Intent name "${name}" must not contain whitespace.`);
+    }
+    if (name.includes('.')) {
+        throw new Error(`Intent name "${name}" must use a flat namespace.`);
+    }
+    const tokens = splitIntentName(name);
+    for (const [category, forbiddenTokens] of Object.entries(forbiddenIntentTokens)) {
+        if (tokens.some((token) => forbiddenTokens.has(token))) {
+            throw new Error(`Intent name "${name}" must describe meaning only and must not encode ${category}.`);
+        }
+    }
+};
+const normalizeIntentDefinition = (name, definition) => {
+    if (!isFiniteNumber(definition.hue)) {
+        throw new Error(`Intent "${name}" hue must be a finite number.`);
+    }
+    if (!isFiniteNumber(definition.chroma)) {
+        throw new Error(`Intent "${name}" chroma must be a finite number.`);
+    }
+    if (definition.chroma < 0) {
+        throw new Error(`Intent "${name}" chroma must be greater than or equal to 0.`);
+    }
+    return Object.freeze({
+        chroma: definition.chroma,
+        hue: normalizeHue(definition.hue),
+    });
+};
+export function createIntentRegistry(intents) {
+    const entries = Object.entries(intents);
+    const normalized = {};
+    for (const [name, definition] of entries) {
+        validateIntentName(name);
+        normalized[name] = normalizeIntentDefinition(name, definition);
+    }
+    return Object.freeze({
+        intents: Object.freeze(normalized),
+    });
+}
+export function hasIntent(registry, intent) {
+    return Object.hasOwn(registry.intents, intent);
+}
+export function getIntent(registry, intent) {
+    if (!hasIntent(registry, intent)) {
+        throw createUnknownIntentError(intent);
+    }
+    return registry.intents[intent];
+}

package/dist/core/oklch.d.ts

@@ -0,0 +1,16 @@
+export type OklchColor = {
+    space: 'oklch';
+    l: number;
+    c: number;
+    h: number;
+    alpha: number;
+};
+export type OklchInput = {
+    l: number;
+    c: number;
+    h: number;
+    alpha?: number;
+};
+export declare function normalizeOklch(input: OklchInput): OklchColor;
+export declare function isOklchColor(value: unknown): value is OklchColor;
+export declare function assertOklchColor(value: unknown): asserts value is OklchColor;

package/dist/core/oklch.js

@@ -0,0 +1,56 @@
+const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
+const normalizeHue = (hue) => {
+    const normalized = ((hue % 360) + 360) % 360;
+    return Object.is(normalized, -0) ? 0 : normalized;
+};
+const validateFiniteChannel = (name, value) => {
+    if (!isFiniteNumber(value)) {
+        throw new Error(`OKLCH ${name} must be a finite number.`);
+    }
+};
+export function normalizeOklch(input) {
+    validateFiniteChannel('l', input.l);
+    validateFiniteChannel('c', input.c);
+    validateFiniteChannel('h', input.h);
+    if (input.l < 0 || input.l > 100) {
+        throw new Error('OKLCH l must be between 0 and 100.');
+    }
+    if (input.c < 0) {
+        throw new Error('OKLCH c must be greater than or equal to 0.');
+    }
+    const alpha = input.alpha ?? 1;
+    validateFiniteChannel('alpha', alpha);
+    if (alpha < 0 || alpha > 1) {
+        throw new Error('OKLCH alpha must be between 0 and 1.');
+    }
+    return {
+        alpha,
+        c: input.c,
+        h: normalizeHue(input.h),
+        l: input.l,
+        space: 'oklch',
+    };
+}
+export function isOklchColor(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return (candidate.space === 'oklch' &&
+        isFiniteNumber(candidate.l) &&
+        candidate.l >= 0 &&
+        candidate.l <= 100 &&
+        isFiniteNumber(candidate.c) &&
+        candidate.c >= 0 &&
+        isFiniteNumber(candidate.h) &&
+        candidate.h >= 0 &&
+        candidate.h < 360 &&
+        isFiniteNumber(candidate.alpha) &&
+        candidate.alpha >= 0 &&
+        candidate.alpha <= 1);
+}
+export function assertOklchColor(value) {
+    if (!isOklchColor(value)) {
+        throw new Error('Expected a normalized OKLCH color.');
+    }
+}

package/dist/create-palette-kit.d.ts

@@ -0,0 +1,9 @@
+import { type ColorOutput } from './export/types.js';
+import type { PaletteDefaultOutput, PaletteKit, PaletteKitConfig } from './types/index.js';
+/**
+ * Creates an immutable Palette Kit resolver instance.
+ *
+ * The factory normalizes the provided intent registry once, keeps context and
+ * output defaults explicit, and never reads ambient platform state.
+ */
+export declare function createPaletteKit<const I extends string, const PaletteOutput extends ColorOutput | undefined = undefined, const SystemDefaultOutput extends ColorOutput | undefined = undefined>(config: PaletteKitConfig<I, PaletteOutput, SystemDefaultOutput>): PaletteKit<I, PaletteDefaultOutput<PaletteOutput, SystemDefaultOutput>>;

package/dist/create-palette-kit.js

@@ -0,0 +1,67 @@
+import { createIntentRegistry, } from './core/intent-registry.js';
+import { assertContext } from './engine/context/context.js';
+import { resolveColor } from './engine/resolve/resolve.js';
+import { serializeColor } from './export/serialize.js';
+import { assertColorOutput, resolveOutput, } from './export/types.js';
+import { defaultResolverConfig, getResolverPresetConfig, mergeResolverConfig, } from './presets/presets.js';
+function resolveSerializedOutput(color, output) {
+    if (output === 'oklch') {
+        return color;
+    }
+    return serializeColor(color, output);
+}
+function validateOptionalContext(context) {
+    if (context !== undefined) {
+        assertContext(context);
+    }
+}
+function validateOptionalOutput(output) {
+    if (output !== undefined) {
+        assertColorOutput(output);
+    }
+}
+function createResolveFunction(intentRegistry, paletteContext, systemDefaultContext, paletteOutput, systemDefaultOutput, resolverConfig) {
+    return (options) => {
+        const output = resolveOutput({
+            paletteOutput,
+            resolverOutput: options.output,
+            systemDefaultOutput,
+        });
+        const resolved = resolveColor({
+            intent: options.intent,
+            intentRegistry,
+            level: options.level,
+            on: options.on,
+            over: options.over,
+            paletteContext,
+            resolverConfig,
+            resolverContext: options.context,
+            state: options.state,
+            stateDirection: options.stateDirection,
+            systemDefaultContext,
+            under: options.under,
+            usage: options.usage,
+        });
+        return resolveSerializedOutput(resolved.color, output);
+    };
+}
+/**
+ * Creates an immutable Palette Kit resolver instance.
+ *
+ * The factory normalizes the provided intent registry once, keeps context and
+ * output defaults explicit, and never reads ambient platform state.
+ */
+export function createPaletteKit(config) {
+    validateOptionalContext(config.context);
+    validateOptionalContext(config.systemDefaultContext);
+    validateOptionalOutput(config.output);
+    validateOptionalOutput(config.systemDefaultOutput);
+    const presetConfig = config.preset === undefined
+        ? defaultResolverConfig
+        : getResolverPresetConfig(config.preset);
+    const resolverConfig = mergeResolverConfig(presetConfig, config.resolverConfig);
+    const intentRegistry = createIntentRegistry(config.intents);
+    return Object.freeze({
+        resolve: createResolveFunction(intentRegistry, config.context, config.systemDefaultContext, config.output, config.systemDefaultOutput, resolverConfig),
+    });
+}

package/dist/engine/context/context.d.ts

@@ -0,0 +1,13 @@
+export declare const CONTEXTS: readonly ["light", "dark"];
+export type Context = (typeof CONTEXTS)[number];
+export type ContextResolutionInput = Readonly<{
+    resolverContext?: unknown;
+    paletteContext?: unknown;
+    systemDefaultContext?: unknown;
+}>;
+export type ContextCurveValues<T> = Readonly<Record<Context, T>>;
+export type ContextCurveHook<T> = (context: Context) => T;
+export declare function isContext(value: unknown): value is Context;
+export declare function assertContext(value: unknown): asserts value is Context;
+export declare function resolveContext({ resolverContext, paletteContext, systemDefaultContext, }: ContextResolutionInput): Context;
+export declare function createContextCurveHook<T>(values: ContextCurveValues<T>): ContextCurveHook<T>;

package/dist/engine/context/context.js

@@ -0,0 +1,37 @@
+import { createUnresolvedContextError } from '../../utils/errors/errors.js';
+export const CONTEXTS = Object.freeze(['light', 'dark']);
+const contextList = CONTEXTS.join(', ');
+const formatInvalidContextError = (value) => `Invalid context "${String(value)}". Expected one of: ${contextList}.`;
+export function isContext(value) {
+    return (typeof value === 'string' && CONTEXTS.includes(value));
+}
+export function assertContext(value) {
+    if (!isContext(value)) {
+        throw new Error(formatInvalidContextError(value));
+    }
+}
+export function resolveContext({ resolverContext, paletteContext, systemDefaultContext, }) {
+    if (resolverContext !== undefined) {
+        assertContext(resolverContext);
+        return resolverContext;
+    }
+    if (paletteContext !== undefined) {
+        assertContext(paletteContext);
+        return paletteContext;
+    }
+    if (systemDefaultContext !== undefined) {
+        assertContext(systemDefaultContext);
+        return systemDefaultContext;
+    }
+    throw createUnresolvedContextError();
+}
+export function createContextCurveHook(values) {
+    const frozenValues = Object.freeze({
+        dark: values.dark,
+        light: values.light,
+    });
+    return Object.freeze((context) => {
+        assertContext(context);
+        return frozenValues[context];
+    });
+}

package/dist/engine/level/curves.d.ts

@@ -0,0 +1,17 @@
+import type { Context } from '../context/context.js';
+import type { Usage } from '../usage/strategy.js';
+import { type Level } from './level.js';
+export type LevelDrivenUsage = Exclude<Usage, 'visualVocabulary'>;
+export type LevelCurve<T> = (level: Level, context: Context) => T;
+export type FillLevelCurve = LevelCurve<number>;
+export type LinesLevelCurve = LevelCurve<number>;
+export type OverlayLevelResult = Readonly<{
+    luminanceDelta: number;
+}>;
+export type OverlaysLevelCurve = LevelCurve<OverlayLevelResult>;
+export type LevelCurveConfig = Readonly<{
+    fill: FillLevelCurve;
+    lines: LinesLevelCurve;
+    overlays: OverlaysLevelCurve;
+}>;
+export declare const defaultLevelCurves: LevelCurveConfig;