@opencode/theme 0.0.0-dev-19795 → 0.0.0-dev-19812

package/dist/tui/schema.js

@@ -32,21 +32,8 @@ const HueDefinition = Schema.Struct({
     interactive: HueValueDefinition,
     neutral: HueValueDefinition,
 });
-const HueOverrideDefinition = Schema.Struct({
-    gray: Schema.optional(HueValueDefinition),
-    red: Schema.optional(HueValueDefinition),
-    orange: Schema.optional(HueValueDefinition),
-    yellow: Schema.optional(HueValueDefinition),
-    green: Schema.optional(HueValueDefinition),
-    cyan: Schema.optional(HueValueDefinition),
-    blue: Schema.optional(HueValueDefinition),
-    purple: Schema.optional(HueValueDefinition),
-    accent: Schema.optional(HueValueDefinition),
-    interactive: Schema.optional(HueValueDefinition),
-    neutral: Schema.optional(HueValueDefinition),
-});
 const StatefulColorDefinition = Schema.Struct({
-    default: Schema.optional(ColorValue),
+    base: Schema.optional(ColorValue),
     $hovered: Schema.optional(ColorValue),
     $focused: Schema.optional(ColorValue),
     $pressed: Schema.optional(ColorValue),
@@ -59,23 +46,17 @@ const ActionColorDefinition = Schema.Struct({
     destructive: Schema.optional(StatefulColorDefinition),
 });
 const TextFeedbackDefinition = Schema.Struct({
-    default: Schema.optional(ColorValue),
-    subdued: Schema.optional(ColorValue),
+    base: Schema.optional(ColorValue),
+    muted: Schema.optional(ColorValue),
 });
 const BackgroundFeedbackDefinition = Schema.Struct({
-    default: Schema.optional(ColorValue),
+    base: Schema.optional(ColorValue),
 });
 const TextDefinition = Schema.Struct({
-    default: Schema.optional(ColorValue),
-    subdued: Schema.optional(ColorValue),
+    base: Schema.optional(ColorValue),
+    muted: Schema.optional(ColorValue),
     action: Schema.optional(ActionColorDefinition),
     formfield: Schema.optional(StatefulColorDefinition),
-    status: Schema.optional(Schema.Struct({
-        running: Schema.optional(ColorValue),
-        question: Schema.optional(ColorValue),
-        permission: Schema.optional(ColorValue),
-        unread: Schema.optional(ColorValue),
-    })),
     feedback: Schema.optional(Schema.Struct({
         error: Schema.optional(TextFeedbackDefinition),
         warning: Schema.optional(TextFeedbackDefinition),
@@ -84,7 +65,7 @@ const TextDefinition = Schema.Struct({
     })),
 });
 const BackgroundDefinition = Schema.Struct({
-    default: Schema.optional(ColorValue),
+    base: Schema.optional(ColorValue),
     raised: Schema.optional(Schema.Struct({
         base: Schema.optional(ColorValue),
         high: Schema.optional(ColorValue),
@@ -149,39 +130,98 @@ const DiffDefinition = Schema.Struct({
 const ThemeTokensDefinition = Schema.Struct({
     text: Schema.optional(TextDefinition),
     background: Schema.optional(BackgroundDefinition),
-    border: Schema.optional(Schema.Struct({ default: Schema.optional(ColorValue) })),
-    scrollbar: Schema.optional(Schema.Struct({ default: Schema.optional(ColorValue) })),
+    border: Schema.optional(Schema.Struct({ base: Schema.optional(ColorValue) })),
+    scrollbar: Schema.optional(Schema.Struct({ base: Schema.optional(ColorValue) })),
     diff: Schema.optional(DiffDefinition),
     syntax: Schema.optional(SyntaxDefinition),
     markdown: Schema.optional(MarkdownDefinition),
 });
+const CompleteStatefulColorDefinition = Schema.Struct({
+    base: ColorValue,
+    $hovered: Schema.optional(ColorValue),
+    $focused: Schema.optional(ColorValue),
+    $pressed: Schema.optional(ColorValue),
+    $selected: Schema.optional(ColorValue),
+    $disabled: Schema.optional(ColorValue),
+});
+const CompleteActionColorDefinition = Schema.Struct({
+    primary: CompleteStatefulColorDefinition,
+    secondary: CompleteStatefulColorDefinition,
+    destructive: CompleteStatefulColorDefinition,
+});
+const CompleteTextFeedbackDefinition = Schema.Struct({ base: ColorValue, muted: Schema.optional(ColorValue) });
+const CompleteBackgroundFeedbackDefinition = Schema.Struct({ base: ColorValue });
+const CompleteThemeTokensDefinition = Schema.Struct({
+    text: Schema.Struct({
+        base: ColorValue,
+        muted: ColorValue,
+        action: CompleteActionColorDefinition,
+        formfield: CompleteStatefulColorDefinition,
+        feedback: Schema.Struct({
+            error: CompleteTextFeedbackDefinition,
+            warning: CompleteTextFeedbackDefinition,
+            success: CompleteTextFeedbackDefinition,
+            info: CompleteTextFeedbackDefinition,
+        }),
+    }),
+    background: Schema.Struct({
+        base: ColorValue,
+        raised: Schema.Struct({ base: ColorValue, high: ColorValue, max: ColorValue }),
+        action: CompleteActionColorDefinition,
+        formfield: CompleteStatefulColorDefinition,
+        feedback: Schema.Struct({
+            error: CompleteBackgroundFeedbackDefinition,
+            warning: CompleteBackgroundFeedbackDefinition,
+            success: CompleteBackgroundFeedbackDefinition,
+            info: CompleteBackgroundFeedbackDefinition,
+        }),
+    }),
+    border: Schema.Struct({ base: ColorValue }),
+    scrollbar: Schema.Struct({ base: ColorValue }),
+    diff: Schema.Struct({
+        text: Schema.Struct({ added: ColorValue, removed: ColorValue, context: ColorValue, hunkHeader: ColorValue }),
+        background: Schema.Struct({ added: ColorValue, removed: ColorValue, context: ColorValue }),
+        highlight: Schema.Struct({ added: ColorValue, removed: ColorValue }),
+        lineNumber: Schema.Struct({
+            text: ColorValue,
+            background: Schema.Struct({ added: ColorValue, removed: ColorValue }),
+        }),
+    }),
+    syntax: Schema.Record(SyntaxToken, HueColorValue),
+    markdown: Schema.Record(MarkdownToken, HueColorValue),
+});
 const ThemeDefinitionFields = Schema.Struct({
     hue: HueDefinition,
-    categorical: Schema.optional(CategoricalDefinition),
-    ...ThemeTokensDefinition.fields,
+    categorical: CategoricalDefinition,
+    ...CompleteThemeTokensDefinition.fields,
     "@dialog": Schema.optional(ThemeTokensDefinition),
 });
 export const ThemeDefinition = ThemeDefinitionFields;
-const FileThemeDefinition = Schema.Struct({
-    hue: Schema.optional(HueOverrideDefinition),
-    categorical: Schema.optional(CategoricalDefinition),
-    ...ThemeTokensDefinition.fields,
+export const BaseThemeDefinition = Schema.Struct({
+    categorical: CategoricalDefinition,
+    ...CompleteThemeTokensDefinition.fields,
     "@dialog": Schema.optional(ThemeTokensDefinition),
 });
-const MergeModeDefinition = Schema.Struct({
-    mergeMode: Schema.Literal(true),
-    hue: Schema.optional(HueOverrideDefinition),
+export const ModeDefinition = Schema.Struct({
+    hue: HueDefinition,
     categorical: Schema.optional(CategoricalDefinition),
     ...ThemeTokensDefinition.fields,
     "@dialog": Schema.optional(ThemeTokensDefinition),
 });
-export const ModeDefinition = Schema.Union([MergeModeDefinition, FileThemeDefinition]);
 const FileMetadata = {
     $schema: Schema.optional(Schema.String),
-    version: Schema.Literal(2),
-    standalone: Schema.optional(Schema.Boolean),
 };
 export const ThemeDocument = Schema.Union([
-    Schema.Struct({ ...FileMetadata, light: ModeDefinition, dark: Schema.optional(ModeDefinition) }),
-    Schema.Struct({ ...FileMetadata, light: Schema.optional(ModeDefinition), dark: ModeDefinition }),
+    Schema.Struct({
+        ...FileMetadata,
+        base: BaseThemeDefinition,
+        light: ModeDefinition,
+        dark: Schema.optional(ModeDefinition),
+    }),
+    Schema.Struct({
+        ...FileMetadata,
+        base: BaseThemeDefinition,
+        light: Schema.optional(ModeDefinition),
+        dark: ModeDefinition,
+    }),
 ]);

package/dist/tui/select.d.ts

@@ -1,13 +1,8 @@
-import type { FileThemeDefinition, Mode, ThemeDefinition, ThemeDocument } from "./index.js";
-export declare function selectTheme(document: ThemeDocument & {
-    light: ThemeDefinition;
-    dark: ThemeDefinition;
-}, mode?: Mode): ThemeDefinition;
-export declare function selectTheme(document: ThemeDocument, mode?: Mode): FileThemeDefinition;
+import type { Mode, ThemeDefinition, ThemeDocument } from "./index.js";
+export declare function selectTheme(document: ThemeDocument, mode?: Mode): ThemeDefinition;
 export declare function selectThemeMode(document: ThemeDocument, mode?: Mode): {
-    theme: FileThemeDefinition;
+    theme: ThemeDefinition;
     mode: Mode;
-    expanded: boolean;
 };
 export declare function themeModes(document: ThemeDocument): readonly Mode[];
 export declare function supportsThemeMode(document: ThemeDocument, mode: Mode): boolean;

package/dist/tui/select.js

@@ -1,4 +1,4 @@
-import { expandTheme, mergeTheme } from "./expand.js";
+import { mergeTheme } from "./expand.js";
 export function selectTheme(document, mode) {
     return selectThemeMode(document, mode).theme;
 }
@@ -8,29 +8,11 @@ export function selectThemeMode(document, mode = "light") {
     const selected = document[selectedMode];
     if (!selected)
         throw new Error("Theme must provide at least one mode");
-    if (merges(document.light) && merges(document.dark))
-        throw new Error("Light and dark themes cannot both merge modes");
-    if (!merges(selected))
-        return { theme: selected, mode: selectedMode, expanded: false };
-    const otherMode = selectedMode === "light" ? "dark" : "light";
-    const other = document[otherMode];
-    if (!other)
-        throw new Error(`The ${selectedMode} theme cannot merge without a ${otherMode} theme`);
-    const merged = mergeTheme(expandTheme(other), expandTheme(selected));
-    if (!merged["hue"])
-        throw new Error(`The ${otherMode} theme must provide hues when ${selectedMode} merges modes`);
-    return { theme: merged, mode: selectedMode, expanded: true };
+    return { theme: mergeTheme(document.base, selected), mode: selectedMode };
 }
 export function themeModes(document) {
-    if (merges(document.light) && !document.dark)
-        throw new Error("The light theme cannot merge without a dark theme");
-    if (merges(document.dark) && !document.light)
-        throw new Error("The dark theme cannot merge without a light theme");
     return ["light", "dark"].filter((mode) => document[mode] !== undefined);
 }
 export function supportsThemeMode(document, mode) {
     return themeModes(document).includes(mode);
 }
-function merges(definition) {
-    return definition !== undefined && "mergeMode" in definition && definition.mergeMode === true;
-}

package/dist/tui/syntax.js

@@ -5,14 +5,14 @@ export function generateSyntax(theme) {
     const markdown = theme.markdown;
     const feedback = theme.text.feedback;
     return SyntaxStyle.fromTheme([
-        rule(["default"], theme.text.default),
+        rule(["default"], theme.text.base),
         rule(["prompt"], theme.hue.accent[step]),
-        rule(["extmark.file"], feedback.warning.default, { bold: true }),
+        rule(["extmark.file"], feedback.warning.base, { bold: true }),
         rule(["extmark.agent"], theme.categorical[0][step], { bold: true }),
         rule(["extmark.skill"], (theme.categorical[1] ?? theme.categorical[0])[step], { bold: true }),
         // V1 migration preserves its selected/inverse foreground in this action state.
         rule(["extmark.paste"], theme.text.action.primary.focused, {
-            background: feedback.warning.default,
+            background: feedback.warning.base,
             bold: true,
         }),
         rule(["comment", "comment.documentation"], syntax.comment, { italic: true }),
@@ -31,7 +31,7 @@ export function generateSyntax(theme) {
         rule(["type", "module", "class", "namespace"], syntax.type),
         rule(["type.definition"], syntax.type, { bold: true }),
         rule(["punctuation", "punctuation.bracket"], syntax.punctuation),
-        rule(["variable.builtin", "type.builtin", "function.builtin", "module.builtin", "constant.builtin", "variable.super"], feedback.error.default),
+        rule(["variable.builtin", "type.builtin", "function.builtin", "module.builtin", "constant.builtin", "variable.super"], feedback.error.base),
         rule(["keyword.directive", "keyword.modifier", "keyword.exception"], syntax.keyword, { italic: true }),
         rule(["punctuation.special", "tag.delimiter"], syntax.operator),
         rule([
@@ -48,27 +48,27 @@ export function generateSyntax(theme) {
         rule(["markup.list"], markdown.listItem),
         rule(["markup.quote"], markdown.blockQuote, { italic: true }),
         rule(["markup.raw", "markup.raw.block"], markdown.code),
-        rule(["markup.raw.inline"], markdown.code, { background: theme.background.default }),
+        rule(["markup.raw.inline"], markdown.code, { background: theme.background.base }),
         rule(["markup.link", "markup.link.url", "string.special", "string.special.url"], markdown.link, {
             underline: true,
         }),
         rule(["markup.link.label"], markdown.linkText, { underline: true }),
         rule(["label"], markdown.linkText),
-        rule(["spell", "nospell"], theme.text.default),
-        rule(["markup.underline"], theme.text.default, { underline: true }),
-        rule(["comment.error"], feedback.error.default, { italic: true, bold: true }),
-        rule(["comment.warning"], feedback.warning.default, { italic: true, bold: true }),
-        rule(["comment.todo", "comment.note"], feedback.info.default, { italic: true, bold: true }),
-        rule(["attribute", "annotation"], feedback.warning.default),
-        rule(["tag"], feedback.error.default),
-        rule(["markup.strikethrough", "markup.list.unchecked", "debug"], theme.text.subdued),
-        rule(["markup.list.checked"], feedback.success.default),
+        rule(["spell", "nospell"], theme.text.base),
+        rule(["markup.underline"], theme.text.base, { underline: true }),
+        rule(["comment.error"], feedback.error.base, { italic: true, bold: true }),
+        rule(["comment.warning"], feedback.warning.base, { italic: true, bold: true }),
+        rule(["comment.todo", "comment.note"], feedback.info.base, { italic: true, bold: true }),
+        rule(["attribute", "annotation"], feedback.warning.base),
+        rule(["tag"], feedback.error.base),
+        rule(["markup.strikethrough", "markup.list.unchecked", "debug"], theme.text.muted),
+        rule(["markup.list.checked"], feedback.success.base),
         rule(["diff.plus"], theme.diff.text.added, { background: theme.diff.background.added }),
         rule(["diff.minus"], theme.diff.text.removed, { background: theme.diff.background.removed }),
         rule(["diff.delta"], theme.diff.text.context, { background: theme.diff.background.context }),
-        rule(["error"], feedback.error.default, { bold: true }),
-        rule(["warning"], feedback.warning.default, { bold: true }),
-        rule(["info"], feedback.info.default),
+        rule(["error"], feedback.error.base, { bold: true }),
+        rule(["warning"], feedback.warning.base, { bold: true }),
+        rule(["info"], feedback.info.base),
     ]);
 }
 function rule(scope, foreground, style = {}) {

package/dist/tui/types.d.ts

@@ -1,6 +1,6 @@
 import type { RGBA } from "@opentui/core";
 import type { ActionState, ActionVariant, BaseHue, FeedbackKind, HueAlias, HueStep, MarkdownToken, SurfaceName, SyntaxToken } from "./schema.js";
-export type ResolvedActionState = "default" | ActionState;
+export type ResolvedActionState = "base" | ActionState;
 export type ResolvedFormfieldState = ResolvedActionState;
 export type HueScale = Readonly<Record<HueStep, RGBA>>;
 export type Hue = Readonly<Record<BaseHue | HueAlias, HueScale>>;
@@ -21,23 +21,17 @@ export type ResolvedThemeTokens = {
     readonly increase: (color: RGBA, amount?: number) => RGBA;
     readonly decrease: (color: RGBA, amount?: number) => RGBA;
     readonly text: {
-        readonly default: RGBA;
-        readonly subdued: RGBA;
+        readonly base: RGBA;
+        readonly muted: RGBA;
         readonly action: Readonly<Record<ActionVariant, StatefulColor>>;
         readonly formfield: FormfieldColor;
-        readonly status: {
-            readonly running: RGBA;
-            readonly question: RGBA;
-            readonly permission: RGBA;
-            readonly unread: RGBA;
-        };
         readonly feedback: Readonly<Record<FeedbackKind, {
-            readonly default: RGBA;
-            readonly subdued: RGBA;
+            readonly base: RGBA;
+            readonly muted: RGBA;
         }>>;
     };
     readonly background: {
-        readonly default: RGBA;
+        readonly base: RGBA;
         readonly raised: {
             readonly base: RGBA;
             readonly high: RGBA;
@@ -46,14 +40,14 @@ export type ResolvedThemeTokens = {
         readonly action: Readonly<Record<ActionVariant, StatefulColor>>;
         readonly formfield: FormfieldColor;
         readonly feedback: Readonly<Record<FeedbackKind, {
-            readonly default: RGBA;
+            readonly base: RGBA;
         }>>;
     };
     readonly border: {
-        readonly default: RGBA;
+        readonly base: RGBA;
     };
     readonly scrollbar: {
-        readonly default: RGBA;
+        readonly base: RGBA;
     };
     readonly diff: {
         readonly text: {

package/dist/tui/v1-migrate.js

@@ -1,11 +1,36 @@
 import { RGBA } from "@opentui/core";
 import { oklchToHex, rgbToOklch } from "./color.js";
-import { DEFAULT_CATEGORICAL, DEFAULT_THEME } from "./defaults.js";
+import { DEFAULT_CATEGORICAL } from "./categorical.js";
 import { HueStep } from "./schema.js";
 const chromaticHues = ["red", "orange", "yellow", "green", "cyan", "blue", "purple"];
 const categoricalTokens = ["secondary", "accent", "success", "warning", "primary", "error"];
 const minimumChroma = 0.03;
 const lightThreshold = 0.6;
+// Canonical swatches copied from the original default-theme classifier keep V1 migration self-contained.
+const hueReferences = {
+    light: {
+        red: "#fca5a5",
+        orange: "#fdba74",
+        yellow: "#fde047",
+        green: "#86efac",
+        cyan: "#67e8f9",
+        blue: "#93c5fd",
+        purple: "#d8b4fe",
+    },
+    dark: {
+        red: "#b91c1c",
+        orange: "#c2410c",
+        yellow: "#a16207",
+        green: "#15803d",
+        cyan: "#0e7490",
+        blue: "#1d4ed8",
+        purple: "#7e22ce",
+    },
+};
+const hueAngles = Object.fromEntries(Object.entries(hueReferences).map(([level, colors]) => [
+    level,
+    Object.fromEntries(Object.entries(colors).map(([name, color]) => [name, toOklch(RGBA.fromHex(color)).h])),
+]));
 export function migrateV1(theme) {
     const light = resolveV1(theme, "light");
     const dark = resolveV1(theme, "dark");
@@ -13,18 +38,24 @@ export function migrateV1(theme) {
         const lightMode = detectMode(light);
         const darkMode = detectMode(dark);
         if (lightMode === darkMode) {
+            const definition = migrateMode(lightMode === "light" ? light : dark, lightMode);
             if (lightMode === "light")
-                return { version: 2, standalone: true, light: migrateMode(light, "light") };
-            return { version: 2, standalone: true, dark: migrateMode(dark, "dark") };
+                return { base: base(definition), light: { hue: definition.hue } };
+            return { base: base(definition), dark: { hue: definition.hue } };
         }
     }
+    const lightDefinition = migrateMode(light, "light");
+    const darkDefinition = migrateMode(dark, "dark");
     return {
-        version: 2,
-        standalone: true,
-        light: migrateMode(light, "light"),
-        dark: migrateMode(dark, "dark"),
+        base: base(lightDefinition),
+        light: { hue: lightDefinition.hue },
+        dark: darkDefinition,
     };
 }
+function base(definition) {
+    const { hue: _, ...base } = definition;
+    return base;
+}
 function detectMode(theme) {
     return luminance(theme.text) > luminance(theme.background) ? "dark" : "light";
 }
@@ -35,7 +66,7 @@ function migrateMode(theme, mode) {
     const color = (key) => hex(theme[key]);
     const selected = hex(selectedForeground(theme, theme.primary));
     const destructive = hex(selectedForeground(theme, theme.error));
-    const hues = inferHues(theme, mode);
+    const hues = inferHues(theme);
     const categorical = categoricalTokens.flatMap((token) => {
         const hue = hues.byToken[token];
         return hue ? [hue] : [];
@@ -61,20 +92,20 @@ function migrateMode(theme, mode) {
         },
         categorical: uniqueCategorical.length ? uniqueCategorical : DEFAULT_CATEGORICAL,
         text: {
-            default: text,
-            subdued: textMuted,
+            base: text,
+            muted: textMuted,
             action: {
                 primary: {
-                    default: "$text.default",
+                    base: "$text.base",
                     $disabled: textMuted,
                     $focused: selected,
                     $selected: primary,
                 },
-                secondary: { default: "$text.subdued", $hovered: "$text.default" },
-                destructive: { default: destructive, $disabled: textMuted },
+                secondary: { base: "$text.muted", $hovered: "$text.base" },
+                destructive: { base: destructive, $disabled: textMuted },
             },
             formfield: {
-                default: text,
+                base: text,
                 $hovered: primary,
                 $focused: primary,
                 $pressed: primary,
@@ -82,36 +113,36 @@ function migrateMode(theme, mode) {
                 $selected: primary,
             },
             feedback: {
-                error: { default: color("error") },
-                warning: { default: color("warning") },
-                success: { default: color("success") },
-                info: { default: color("info") },
+                error: { base: color("error") },
+                warning: { base: color("warning") },
+                success: { base: color("success") },
+                info: { base: color("info") },
             },
         },
         background: {
-            default: background,
+            base: background,
             raised: {
                 base: backgroundPanel,
                 high: backgroundMenu,
                 max: backgroundRaisedMax,
             },
             action: {
-                primary: { default: "transparent", $hovered: backgroundPanel, $focused: primary, $selected: "transparent" },
-                secondary: { default: "transparent" },
-                destructive: { default: color("error") },
+                primary: { base: "transparent", $hovered: backgroundPanel, $focused: primary, $selected: "transparent" },
+                secondary: { base: "transparent" },
+                destructive: { base: color("error") },
             },
             formfield: {
-                default: "$background.default",
+                base: "$background.base",
             },
             feedback: {
-                error: { default: "$background.default" },
-                warning: { default: "$background.default" },
-                success: { default: "$background.default" },
-                info: { default: "$background.default" },
+                error: { base: "$background.base" },
+                warning: { base: "$background.base" },
+                success: { base: "$background.base" },
+                info: { base: "$background.base" },
             },
         },
-        border: { default: color("border") },
-        scrollbar: { default: color("borderActive") },
+        border: { base: color("border") },
+        scrollbar: { base: color("borderActive") },
         diff: {
             text: {
                 added: color("diffAdded"),
@@ -162,7 +193,7 @@ function migrateMode(theme, mode) {
         },
         "@dialog": {
             background: {
-                default: "$background.raised.base",
+                base: "$background.raised.base",
                 action: { primary: { $hovered: "$background.raised.high" } },
             },
         },
@@ -220,7 +251,7 @@ function referenceHues(theme) {
     }
     return Object.fromEntries(Object.entries(theme).map(([key, value]) => [key, key === "hue" || key === "categorical" ? value : replace(value)]));
 }
-function inferHues(theme, mode) {
+function inferHues(theme) {
     const colors = [
         ["accent", theme.accent],
         ["success", theme.success],
@@ -231,7 +262,7 @@ function inferHues(theme, mode) {
         ["secondary", theme.secondary],
     ];
     const inferred = colors.reduce((result, [token, color]) => {
-        const nearest = inferHue(color, mode);
+        const nearest = inferHue(color);
         if (!nearest)
             return result;
         const current = result.byHue[nearest.name];
@@ -246,7 +277,7 @@ function inferHues(theme, mode) {
         ["accent", theme.accent],
         ["primary", theme.primary],
     ].reduce((result, [token, color]) => {
-        const nearest = inferHue(color, mode);
+        const nearest = inferHue(color);
         if (!nearest)
             return result;
         return {
@@ -255,23 +286,18 @@ function inferHues(theme, mode) {
         };
     }, inferred);
 }
-function inferHue(color, mode) {
+function inferHue(color) {
     const value = toOklch(color);
     if (ambiguous(color, value.c))
         return;
-    const anchor = inferenceAnchor(value.l, mode);
+    const reference = value.l >= lightThreshold ? hueAngles.light : hueAngles.dark;
     return chromaticHues
         .map((name) => ({
         name,
-        distance: hueDistance(value.h, toOklch(RGBA.fromHex(DEFAULT_THEME[mode].hue[name][anchor])).h),
+        distance: hueDistance(value.h, reference[name]),
     }))
         .sort((first, second) => first.distance - second.distance)[0];
 }
-function inferenceAnchor(lightness, mode) {
-    if (mode === "light")
-        return lightness >= lightThreshold ? 700 : 300;
-    return lightness >= lightThreshold ? 300 : 700;
-}
 function hueDistance(first, second) {
     const difference = Math.abs(first - second);
     return Math.min(difference, 360 - difference);

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/theme",
-  "version": "0.0.0-dev-19795",
+  "version": "0.0.0-dev-19812",
   "type": "module",
   "license": "MIT",
   "repository": {