@adea-ai/ui 0.124.0 → 0.127.0

package/dist/lib/font-zoom.js

@@ -0,0 +1,45 @@
+import { normalizeAppearanceEditorFontSettings } from "./appearance-font-settings.js";
+//#region src/lib/font-zoom.ts
+/**
+* Classify the platform zoom chord: Cmd (macOS) or Ctrl (other platforms)
+* with `=`/`+` zooming in, `-` zooming out, and `0` resetting to the System
+* defaults. Unmodified keys, Alt-modified chords, and IME composition never
+* count, so typing and text editing are untouched.
+*/
+function fontZoomShortcut(event) {
+	if (event.isComposing || event.altKey) return void 0;
+	if (!(event.metaKey || event.ctrlKey)) return void 0;
+	if (event.key === "=" || event.key === "+") return "in";
+	if (event.key === "-") return "out";
+	if (event.key === "0") return "reset";
+}
+/** Clamp a pixel size to the shared range the appearance editor enforces. */
+function clampFontSize(size) {
+	return Math.min(32, Math.max(10, size));
+}
+/**
+* Step every text tier by `delta` pixels, clamped to that range. The axes move
+* together — that is what makes the chord read as zoom — and each keeps its
+* own family choice.
+*/
+function stepAppearanceFontSizes(fonts, delta) {
+	const current = normalizeAppearanceEditorFontSettings(fonts).settings;
+	return {
+		ui: {
+			...current.ui,
+			size: clampFontSize(current.ui.size + delta)
+		},
+		content: {
+			...current.content,
+			size: clampFontSize(current.content.size + delta)
+		},
+		code: {
+			...current.code,
+			size: clampFontSize(current.code.size + delta)
+		}
+	};
+}
+//#endregion
+export { fontZoomShortcut, stepAppearanceFontSizes };
+
+//# sourceMappingURL=font-zoom.js.map

package/dist/lib/font-zoom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"font-zoom.js","names":[],"sources":["../../src/lib/font-zoom.ts"],"sourcesContent":["/*\n * Copyright (c) 2026 Wing\n * Licensed under the MIT License.\n *\n * The platform zoom chords, mapped onto Adea's three text roles.\n *\n * macOS (and Windows/Linux) zoom shortcuts — Cmd/Ctrl with `=`, `+`, `-`, or\n * `0` — normally scale the browser's page zoom. In Adea every text element is\n * already tied to one of the three appearance font tiers (the UI tier drives\n * the whole `text-*` scale through `--font-ui-scale`; content and code roles\n * scale through their own tokens), so stepping those tiers reproduces zoom\n * while keeping the app inside its tokenized, persisted type system: the page\n * layout, menus, sheets, and terminals reflow live from the same projection\n * the appearance editor writes.\n *\n * Translated from Adea's accepted port (`packages/ui/src/components/font-zoom.ts`) so\n * the shared provider and Adea run one implementation. See NOTICE.\n */\nimport {\n  APPEARANCE_EDITOR_FONT_AXES,\n  APPEARANCE_EDITOR_FONT_SIZE_MAX,\n  APPEARANCE_EDITOR_FONT_SIZE_MIN,\n  normalizeAppearanceEditorFontSettings,\n  type AppearanceEditorFontSettings,\n} from '#lib/appearance-font-settings'\n\n/** What the user's zoom chord asked for. */\nexport type FontZoomIntent = 'in' | 'out' | 'reset'\n\n/**\n * Classify the platform zoom chord: Cmd (macOS) or Ctrl (other platforms)\n * with `=`/`+` zooming in, `-` zooming out, and `0` resetting to the System\n * defaults. Unmodified keys, Alt-modified chords, and IME composition never\n * count, so typing and text editing are untouched.\n */\nexport function fontZoomShortcut(event: {\n  key: string\n  metaKey: boolean\n  ctrlKey: boolean\n  altKey: boolean\n  isComposing?: boolean\n}): FontZoomIntent | undefined {\n  if (event.isComposing || event.altKey) return undefined\n  if (!(event.metaKey || event.ctrlKey)) return undefined\n  if (event.key === '=' || event.key === '+') return 'in'\n  if (event.key === '-') return 'out'\n  if (event.key === '0') return 'reset'\n  return undefined\n}\n\n/** Clamp a pixel size to the shared range the appearance editor enforces. */\nfunction clampFontSize(size: number): number {\n  return Math.min(APPEARANCE_EDITOR_FONT_SIZE_MAX, Math.max(APPEARANCE_EDITOR_FONT_SIZE_MIN, size))\n}\n\n/**\n * Step every text tier by `delta` pixels, clamped to that range. The axes move\n * together — that is what makes the chord read as zoom — and each keeps its\n * own family choice.\n */\nexport function stepAppearanceFontSizes(\n  fonts: unknown,\n  delta: 1 | -1\n): AppearanceEditorFontSettings {\n  const current = normalizeAppearanceEditorFontSettings(fonts).settings\n  return {\n    ui: { ...current.ui, size: clampFontSize(current.ui.size + delta) },\n    content: { ...current.content, size: clampFontSize(current.content.size + delta) },\n    code: { ...current.code, size: clampFontSize(current.code.size + delta) },\n  }\n}\n\n/** Every axis name, for callers that want to report or test the stepping. */\nexport const FONT_ZOOM_AXES = APPEARANCE_EDITOR_FONT_AXES\n"],"mappings":";;;;;;;;AAmCA,SAAgB,iBAAiB,OAMF;CAC7B,IAAI,MAAM,eAAe,MAAM,QAAQ,OAAO,KAAA;CAC9C,IAAI,EAAE,MAAM,WAAW,MAAM,UAAU,OAAO,KAAA;CAC9C,IAAI,MAAM,QAAQ,OAAO,MAAM,QAAQ,KAAK,OAAO;CACnD,IAAI,MAAM,QAAQ,KAAK,OAAO;CAC9B,IAAI,MAAM,QAAQ,KAAK,OAAO;AAEhC;;AAGA,SAAS,cAAc,MAAsB;CAC3C,OAAO,KAAK,IAAA,IAAqC,KAAK,IAAA,IAAqC,IAAI,CAAC;AAClG;;;;;;AAOA,SAAgB,wBACd,OACA,OAC8B;CAC9B,MAAM,UAAU,sCAAsC,KAAK,CAAC,CAAC;CAC7D,OAAO;EACL,IAAI;GAAE,GAAG,QAAQ;GAAI,MAAM,cAAc,QAAQ,GAAG,OAAO,KAAK;EAAE;EAClE,SAAS;GAAE,GAAG,QAAQ;GAAS,MAAM,cAAc,QAAQ,QAAQ,OAAO,KAAK;EAAE;EACjF,MAAM;GAAE,GAAG,QAAQ;GAAM,MAAM,cAAc,QAAQ,KAAK,OAAO,KAAK;EAAE;CAC1E;AACF"}

package/dist/lib/preference-store.d.ts

@@ -0,0 +1,126 @@
+/**
+ * A versioned preference store: read one JSON document, refuse to guess about what
+ * it cannot read, and keep what it refused.
+ *
+ * Nothing here knows what a preference *is*. A host hands the engine a key, a
+ * version and (through `createVersionedPersistence`) a codec; the engine owns only
+ * the part every versioned store gets wrong the same way, which is what happens to
+ * a document that is not the one the code expects:
+ *
+ *   - A document that is not JSON, or not a record, or carries a version the code
+ *     does not know (usually a newer build's) is **quarantined, byte for byte, into a
+ *     recovery key** before anything else happens. The store then answers as if
+ *     nothing were stored. Because the quarantine runs at read time, ahead of any
+ *     write, saving valid preferences later cannot destroy the unread original.
+ *   - A legacy key is consulted only when the main key is *absent*, never when it is
+ *     unreadable: a corrupt main document is not "no preference", and falling back to
+ *     an older, staler key would quietly restore a choice the user has since changed.
+ *     The legacy key is never deleted.
+ *   - Blocked storage (a sandboxed iframe, a privacy mode) throws on the mere access
+ *     of the `localStorage` global. Every path here treats that as "nothing stored".
+ *
+ * The reads and writes are against a {@link PreferenceStorage}, so the rules run in a
+ * test without a DOM.
+ */
+/** The part of `Storage` the engine uses. */
+export type PreferenceStorage = Pick<Storage, 'getItem' | 'setItem'>;
+/** Why an unread document was quarantined. */
+export type RecoveryReason = 'corrupt_json' | 'unsupported_record';
+/**
+ * What is written to the recovery key.
+ *
+ * The shape is a compatibility surface: Adea's stored envelopes already have it, and
+ * a tool that inspects a user's storage reads it. Do not rename a field.
+ */
+export type RecoveryEnvelope = Readonly<{
+    schemaVersion: 1;
+    reason: RecoveryReason;
+    /** An ISO-8601 timestamp of the capture; refreshed by each read of the same bytes. */
+    capturedAt: string;
+    /** The document exactly as it was stored. */
+    raw: string;
+}>;
+/**
+ * The preference store, or nothing.
+ *
+ * The `typeof` guard sits inside the `try` for a reason: where storage is blocked,
+ * merely *reading* the `localStorage` global throws, so a guard in front of the `try`
+ * is itself the crash.
+ */
+export declare function defaultPreferenceStorage(): PreferenceStorage | undefined;
+/** The envelope for a document, stamped with `now`. */
+export declare function recoveryEnvelope(raw: string, reason: RecoveryReason, now?: Date): RecoveryEnvelope;
+/**
+ * Quarantine an unread document into `recoveryKey`.
+ *
+ * Idempotent, so re-reading the same unread value refreshes the capture without
+ * losing it. Best effort: a store that cannot be written leaves the caller to fail
+ * closed on the defaults, which is the same outcome as not having a recovery key at
+ * all. Never throws.
+ *
+ * Exported so a host quarantines its *other* documents (a theme library, say) with
+ * the same envelope. Give each document its own `recoveryKey`: two documents that
+ * share one overwrite each other's capture.
+ */
+export declare function quarantineRecord(storage: PreferenceStorage, recoveryKey: string, raw: string, reason: RecoveryReason, now?: () => Date): void;
+/** Where a versioned document lives and which version the code understands. */
+export type VersionedRecordSchema = {
+    /** The storage key of the document. */
+    key: string;
+    /**
+     * The only `version` the code reads. Absent, the document is unversioned and any
+     * JSON object is accepted; present, a record whose top-level `version` is not
+     * exactly this number is unsupported (newer or older), not "close enough".
+     */
+    version?: number;
+    /** Where an unread document is kept. Default `${key}.recovery`. */
+    recoveryKey?: string;
+};
+/**
+ * What reading the document found.
+ *
+ *   - `absent`: nothing is stored under the key.
+ *   - `record`: a JSON object this code can read; `raw` is the stored text.
+ *   - `quarantined`: something was stored and cannot be read. It has already been
+ *     written to the recovery key.
+ *   - `unavailable`: the store itself could not be read.
+ */
+export type VersionedRead = {
+    status: 'absent';
+} | {
+    status: 'record';
+    record: Readonly<Record<string, unknown>>;
+    raw: string;
+} | {
+    status: 'quarantined';
+    reason: RecoveryReason;
+    raw: string;
+} | {
+    status: 'unavailable';
+};
+/** The default recovery key for a document key. */
+export declare function recoveryKeyFor(schema: VersionedRecordSchema): string;
+/**
+ * Read the document under `schema.key`.
+ *
+ * The classification is the contract: a value that is not valid JSON, or is JSON but
+ * not an object (`null`, a number, a string), is `corrupt_json`; an object (or array)
+ * that is not a record of the supported version is `unsupported_record`. Both are
+ * quarantined before this returns. An empty string is a stored value, so it is
+ * corrupt rather than absent.
+ */
+export declare function readVersionedRecord(storage: PreferenceStorage, schema: VersionedRecordSchema, now?: () => Date): VersionedRead;
+/**
+ * The legacy single-key value, or `null`.
+ *
+ * Only the caller decides whether to look: the engine's rule is to ask when the main
+ * key is `absent`, not when it was quarantined.
+ */
+export declare function readLegacyValue(storage: PreferenceStorage, legacyKey: string): string | null;
+/**
+ * Write `document` to `key` as JSON. Returns whether it was stored; a full or blocked
+ * store returns `false` and never throws, because losing a preference must not break
+ * the switch that tried to save it.
+ */
+export declare function writeVersionedRecord(storage: PreferenceStorage, key: string, document: unknown): boolean;
+//# sourceMappingURL=preference-store.d.ts.map

package/dist/lib/preference-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preference-store.d.ts","sourceRoot":"","sources":["../../src/lib/preference-store.ts"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,6CAA6C;AAC7C,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,OAAO,EAAE,SAAS,GAAG,SAAS,CAAC,CAAA;AAEpE,8CAA8C;AAC9C,MAAM,MAAM,cAAc,GAAG,cAAc,GAAG,oBAAoB,CAAA;AAElE;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IACtC,aAAa,EAAE,CAAC,CAAA;IAChB,MAAM,EAAE,cAAc,CAAA;IACtB,sFAAsF;IACtF,UAAU,EAAE,MAAM,CAAA;IAClB,6CAA6C;IAC7C,GAAG,EAAE,MAAM,CAAA;CACZ,CAAC,CAAA;AAEF;;;;;;GAMG;AACH,wBAAgB,wBAAwB,IAAI,iBAAiB,GAAG,SAAS,CAMxE;AAED,uDAAuD;AACvD,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,cAAc,EACtB,GAAG,GAAE,IAAiB,GACrB,gBAAgB,CAElB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,iBAAiB,EAC1B,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,cAAc,EACtB,GAAG,GAAE,MAAM,IAAuB,GACjC,IAAI,CAMN;AAED,+EAA+E;AAC/E,MAAM,MAAM,qBAAqB,GAAG;IAClC,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAA;IACX;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,mEAAmE;IACnE,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,MAAM,EAAE,QAAQ,CAAA;CAAE,GACpB;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC5E;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,cAAc,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC9D;IAAE,MAAM,EAAE,aAAa,CAAA;CAAE,CAAA;AAE7B,mDAAmD;AACnD,wBAAgB,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,MAAM,CAEpE;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,iBAAiB,EAC1B,MAAM,EAAE,qBAAqB,EAC7B,GAAG,CAAC,EAAE,MAAM,IAAI,GACf,aAAa,CA6Bf;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAM5F;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,iBAAiB,EAC1B,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,OAAO,GAChB,OAAO,CAOT"}

package/dist/lib/preference-store.js

@@ -0,0 +1,126 @@
+//#region src/lib/preference-store.ts
+/**
+* The preference store, or nothing.
+*
+* The `typeof` guard sits inside the `try` for a reason: where storage is blocked,
+* merely *reading* the `localStorage` global throws, so a guard in front of the `try`
+* is itself the crash.
+*/
+function defaultPreferenceStorage() {
+	try {
+		return typeof localStorage === "undefined" ? void 0 : localStorage;
+	} catch {
+		return;
+	}
+}
+/** The envelope for a document, stamped with `now`. */
+function recoveryEnvelope(raw, reason, now = /* @__PURE__ */ new Date()) {
+	return {
+		schemaVersion: 1,
+		reason,
+		capturedAt: now.toISOString(),
+		raw
+	};
+}
+/**
+* Quarantine an unread document into `recoveryKey`.
+*
+* Idempotent, so re-reading the same unread value refreshes the capture without
+* losing it. Best effort: a store that cannot be written leaves the caller to fail
+* closed on the defaults, which is the same outcome as not having a recovery key at
+* all. Never throws.
+*
+* Exported so a host quarantines its *other* documents (a theme library, say) with
+* the same envelope. Give each document its own `recoveryKey`: two documents that
+* share one overwrite each other's capture.
+*/
+function quarantineRecord(storage, recoveryKey, raw, reason, now = () => /* @__PURE__ */ new Date()) {
+	try {
+		storage.setItem(recoveryKey, JSON.stringify(recoveryEnvelope(raw, reason, now())));
+	} catch {}
+}
+/** The default recovery key for a document key. */
+function recoveryKeyFor(schema) {
+	return schema.recoveryKey ?? `${schema.key}.recovery`;
+}
+/**
+* Read the document under `schema.key`.
+*
+* The classification is the contract: a value that is not valid JSON, or is JSON but
+* not an object (`null`, a number, a string), is `corrupt_json`; an object (or array)
+* that is not a record of the supported version is `unsupported_record`. Both are
+* quarantined before this returns. An empty string is a stored value, so it is
+* corrupt rather than absent.
+*/
+function readVersionedRecord(storage, schema, now) {
+	let raw;
+	try {
+		raw = storage.getItem(schema.key);
+	} catch {
+		return { status: "unavailable" };
+	}
+	if (raw === null) return { status: "absent" };
+	const recoveryKey = recoveryKeyFor(schema);
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		quarantineRecord(storage, recoveryKey, raw, "corrupt_json", now);
+		return {
+			status: "quarantined",
+			reason: "corrupt_json",
+			raw
+		};
+	}
+	if (typeof parsed !== "object" || parsed === null) {
+		quarantineRecord(storage, recoveryKey, raw, "corrupt_json", now);
+		return {
+			status: "quarantined",
+			reason: "corrupt_json",
+			raw
+		};
+	}
+	if (Array.isArray(parsed) || schema.version !== void 0 && parsed.version !== schema.version) {
+		quarantineRecord(storage, recoveryKey, raw, "unsupported_record", now);
+		return {
+			status: "quarantined",
+			reason: "unsupported_record",
+			raw
+		};
+	}
+	return {
+		status: "record",
+		record: parsed,
+		raw
+	};
+}
+/**
+* The legacy single-key value, or `null`.
+*
+* Only the caller decides whether to look: the engine's rule is to ask when the main
+* key is `absent`, not when it was quarantined.
+*/
+function readLegacyValue(storage, legacyKey) {
+	try {
+		return storage.getItem(legacyKey);
+	} catch {
+		return null;
+	}
+}
+/**
+* Write `document` to `key` as JSON. Returns whether it was stored; a full or blocked
+* store returns `false` and never throws, because losing a preference must not break
+* the switch that tried to save it.
+*/
+function writeVersionedRecord(storage, key, document) {
+	try {
+		storage.setItem(key, JSON.stringify(document));
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { defaultPreferenceStorage, quarantineRecord, readLegacyValue, readVersionedRecord, recoveryEnvelope, recoveryKeyFor, writeVersionedRecord };
+
+//# sourceMappingURL=preference-store.js.map

package/dist/lib/preference-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"preference-store.js","names":[],"sources":["../../src/lib/preference-store.ts"],"sourcesContent":["/*\n * Copyright (c) 2026 Wing\n * Licensed under the MIT License.\n *\n * The recovery behaviour here (quarantine before any write, the envelope shape, the\n * legacy key that is read once and never deleted) is Adea's accepted port of Zeron's\n * preference store (https://github.com/zeronsh/zeron),\n * `packages/ui/src/components/appearance.ts`, moved here so the shared provider and\n * Adea run one implementation. See NOTICE.\n */\n\n/**\n * A versioned preference store: read one JSON document, refuse to guess about what\n * it cannot read, and keep what it refused.\n *\n * Nothing here knows what a preference *is*. A host hands the engine a key, a\n * version and (through `createVersionedPersistence`) a codec; the engine owns only\n * the part every versioned store gets wrong the same way, which is what happens to\n * a document that is not the one the code expects:\n *\n *   - A document that is not JSON, or not a record, or carries a version the code\n *     does not know (usually a newer build's) is **quarantined, byte for byte, into a\n *     recovery key** before anything else happens. The store then answers as if\n *     nothing were stored. Because the quarantine runs at read time, ahead of any\n *     write, saving valid preferences later cannot destroy the unread original.\n *   - A legacy key is consulted only when the main key is *absent*, never when it is\n *     unreadable: a corrupt main document is not \"no preference\", and falling back to\n *     an older, staler key would quietly restore a choice the user has since changed.\n *     The legacy key is never deleted.\n *   - Blocked storage (a sandboxed iframe, a privacy mode) throws on the mere access\n *     of the `localStorage` global. Every path here treats that as \"nothing stored\".\n *\n * The reads and writes are against a {@link PreferenceStorage}, so the rules run in a\n * test without a DOM.\n */\n\n/** The part of `Storage` the engine uses. */\nexport type PreferenceStorage = Pick<Storage, 'getItem' | 'setItem'>\n\n/** Why an unread document was quarantined. */\nexport type RecoveryReason = 'corrupt_json' | 'unsupported_record'\n\n/**\n * What is written to the recovery key.\n *\n * The shape is a compatibility surface: Adea's stored envelopes already have it, and\n * a tool that inspects a user's storage reads it. Do not rename a field.\n */\nexport type RecoveryEnvelope = Readonly<{\n  schemaVersion: 1\n  reason: RecoveryReason\n  /** An ISO-8601 timestamp of the capture; refreshed by each read of the same bytes. */\n  capturedAt: string\n  /** The document exactly as it was stored. */\n  raw: string\n}>\n\n/**\n * The preference store, or nothing.\n *\n * The `typeof` guard sits inside the `try` for a reason: where storage is blocked,\n * merely *reading* the `localStorage` global throws, so a guard in front of the `try`\n * is itself the crash.\n */\nexport function defaultPreferenceStorage(): PreferenceStorage | undefined {\n  try {\n    return typeof localStorage === 'undefined' ? undefined : localStorage\n  } catch {\n    return undefined\n  }\n}\n\n/** The envelope for a document, stamped with `now`. */\nexport function recoveryEnvelope(\n  raw: string,\n  reason: RecoveryReason,\n  now: Date = new Date()\n): RecoveryEnvelope {\n  return { schemaVersion: 1, reason, capturedAt: now.toISOString(), raw }\n}\n\n/**\n * Quarantine an unread document into `recoveryKey`.\n *\n * Idempotent, so re-reading the same unread value refreshes the capture without\n * losing it. Best effort: a store that cannot be written leaves the caller to fail\n * closed on the defaults, which is the same outcome as not having a recovery key at\n * all. Never throws.\n *\n * Exported so a host quarantines its *other* documents (a theme library, say) with\n * the same envelope. Give each document its own `recoveryKey`: two documents that\n * share one overwrite each other's capture.\n */\nexport function quarantineRecord(\n  storage: PreferenceStorage,\n  recoveryKey: string,\n  raw: string,\n  reason: RecoveryReason,\n  now: () => Date = () => new Date()\n): void {\n  try {\n    storage.setItem(recoveryKey, JSON.stringify(recoveryEnvelope(raw, reason, now())))\n  } catch {\n    // Quarantine is best effort; the active preference still fails closed.\n  }\n}\n\n/** Where a versioned document lives and which version the code understands. */\nexport type VersionedRecordSchema = {\n  /** The storage key of the document. */\n  key: string\n  /**\n   * The only `version` the code reads. Absent, the document is unversioned and any\n   * JSON object is accepted; present, a record whose top-level `version` is not\n   * exactly this number is unsupported (newer or older), not \"close enough\".\n   */\n  version?: number\n  /** Where an unread document is kept. Default `${key}.recovery`. */\n  recoveryKey?: string\n}\n\n/**\n * What reading the document found.\n *\n *   - `absent`: nothing is stored under the key.\n *   - `record`: a JSON object this code can read; `raw` is the stored text.\n *   - `quarantined`: something was stored and cannot be read. It has already been\n *     written to the recovery key.\n *   - `unavailable`: the store itself could not be read.\n */\nexport type VersionedRead =\n  | { status: 'absent' }\n  | { status: 'record'; record: Readonly<Record<string, unknown>>; raw: string }\n  | { status: 'quarantined'; reason: RecoveryReason; raw: string }\n  | { status: 'unavailable' }\n\n/** The default recovery key for a document key. */\nexport function recoveryKeyFor(schema: VersionedRecordSchema): string {\n  return schema.recoveryKey ?? `${schema.key}.recovery`\n}\n\n/**\n * Read the document under `schema.key`.\n *\n * The classification is the contract: a value that is not valid JSON, or is JSON but\n * not an object (`null`, a number, a string), is `corrupt_json`; an object (or array)\n * that is not a record of the supported version is `unsupported_record`. Both are\n * quarantined before this returns. An empty string is a stored value, so it is\n * corrupt rather than absent.\n */\nexport function readVersionedRecord(\n  storage: PreferenceStorage,\n  schema: VersionedRecordSchema,\n  now?: () => Date\n): VersionedRead {\n  let raw: string | null\n  try {\n    raw = storage.getItem(schema.key)\n  } catch {\n    return { status: 'unavailable' }\n  }\n  if (raw === null) return { status: 'absent' }\n\n  const recoveryKey = recoveryKeyFor(schema)\n  let parsed: unknown\n  try {\n    parsed = JSON.parse(raw)\n  } catch {\n    quarantineRecord(storage, recoveryKey, raw, 'corrupt_json', now)\n    return { status: 'quarantined', reason: 'corrupt_json', raw }\n  }\n  if (typeof parsed !== 'object' || parsed === null) {\n    quarantineRecord(storage, recoveryKey, raw, 'corrupt_json', now)\n    return { status: 'quarantined', reason: 'corrupt_json', raw }\n  }\n  if (\n    Array.isArray(parsed) ||\n    (schema.version !== undefined && (parsed as { version?: unknown }).version !== schema.version)\n  ) {\n    quarantineRecord(storage, recoveryKey, raw, 'unsupported_record', now)\n    return { status: 'quarantined', reason: 'unsupported_record', raw }\n  }\n  return { status: 'record', record: parsed as Record<string, unknown>, raw }\n}\n\n/**\n * The legacy single-key value, or `null`.\n *\n * Only the caller decides whether to look: the engine's rule is to ask when the main\n * key is `absent`, not when it was quarantined.\n */\nexport function readLegacyValue(storage: PreferenceStorage, legacyKey: string): string | null {\n  try {\n    return storage.getItem(legacyKey)\n  } catch {\n    return null\n  }\n}\n\n/**\n * Write `document` to `key` as JSON. Returns whether it was stored; a full or blocked\n * store returns `false` and never throws, because losing a preference must not break\n * the switch that tried to save it.\n */\nexport function writeVersionedRecord(\n  storage: PreferenceStorage,\n  key: string,\n  document: unknown\n): boolean {\n  try {\n    storage.setItem(key, JSON.stringify(document))\n    return true\n  } catch {\n    return false\n  }\n}\n"],"mappings":";;;;;;;;AAgEA,SAAgB,2BAA0D;CACxE,IAAI;EACF,OAAO,OAAO,iBAAiB,cAAc,KAAA,IAAY;CAC3D,QAAQ;EACN;CACF;AACF;;AAGA,SAAgB,iBACd,KACA,QACA,sBAAY,IAAI,KAAK,GACH;CAClB,OAAO;EAAE,eAAe;EAAG;EAAQ,YAAY,IAAI,YAAY;EAAG;CAAI;AACxE;;;;;;;;;;;;;AAcA,SAAgB,iBACd,SACA,aACA,KACA,QACA,4BAAwB,IAAI,KAAK,GAC3B;CACN,IAAI;EACF,QAAQ,QAAQ,aAAa,KAAK,UAAU,iBAAiB,KAAK,QAAQ,IAAI,CAAC,CAAC,CAAC;CACnF,QAAQ,CAER;AACF;;AAgCA,SAAgB,eAAe,QAAuC;CACpE,OAAO,OAAO,eAAe,GAAG,OAAO,IAAI;AAC7C;;;;;;;;;;AAWA,SAAgB,oBACd,SACA,QACA,KACe;CACf,IAAI;CACJ,IAAI;EACF,MAAM,QAAQ,QAAQ,OAAO,GAAG;CAClC,QAAQ;EACN,OAAO,EAAE,QAAQ,cAAc;CACjC;CACA,IAAI,QAAQ,MAAM,OAAO,EAAE,QAAQ,SAAS;CAE5C,MAAM,cAAc,eAAe,MAAM;CACzC,IAAI;CACJ,IAAI;EACF,SAAS,KAAK,MAAM,GAAG;CACzB,QAAQ;EACN,iBAAiB,SAAS,aAAa,KAAK,gBAAgB,GAAG;EAC/D,OAAO;GAAE,QAAQ;GAAe,QAAQ;GAAgB;EAAI;CAC9D;CACA,IAAI,OAAO,WAAW,YAAY,WAAW,MAAM;EACjD,iBAAiB,SAAS,aAAa,KAAK,gBAAgB,GAAG;EAC/D,OAAO;GAAE,QAAQ;GAAe,QAAQ;GAAgB;EAAI;CAC9D;CACA,IACE,MAAM,QAAQ,MAAM,KACnB,OAAO,YAAY,KAAA,KAAc,OAAiC,YAAY,OAAO,SACtF;EACA,iBAAiB,SAAS,aAAa,KAAK,sBAAsB,GAAG;EACrE,OAAO;GAAE,QAAQ;GAAe,QAAQ;GAAsB;EAAI;CACpE;CACA,OAAO;EAAE,QAAQ;EAAU,QAAQ;EAAmC;CAAI;AAC5E;;;;;;;AAQA,SAAgB,gBAAgB,SAA4B,WAAkC;CAC5F,IAAI;EACF,OAAO,QAAQ,QAAQ,SAAS;CAClC,QAAQ;EACN,OAAO;CACT;AACF;;;;;;AAOA,SAAgB,qBACd,SACA,KACA,UACS;CACT,IAAI;EACF,QAAQ,QAAQ,KAAK,KAAK,UAAU,QAAQ,CAAC;EAC7C,OAAO;CACT,QAAQ;EACN,OAAO;CACT;AACF"}

package/dist/lib/theme-surface.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The surface axis, and the policy that decides what it paints.
+ *
+ * A surface is how opaque the window's elevated panels are: `opaque` is the plain
+ * canvas, `frosted` is a tokenized translucent fill over a blur (works everywhere,
+ * in CSS alone), and `translucent` asks for the host window's own vibrancy, which only
+ * a desktop shell can honour.
+ *
+ * Nothing here touches the document or a signal. The provider reads the operating
+ * system and the host's capability, calls {@link resolveSurface}, and
+ * `theme-document.ts` writes the answer; the rule itself is a function of its four
+ * inputs, which is what makes it testable.
+ */
+export type ThemeSurface = 'opaque' | 'frosted' | 'translucent';
+/** Every surface, in the order a picker offers them. */
+export declare const themeSurfaces: readonly ThemeSurface[];
+/** The media query the operating system's Reduce Transparency setting answers. */
+export declare const REDUCED_TRANSPARENCY_QUERY = "(prefers-reduced-transparency: reduce)";
+/**
+ * What the world says about transparency, as opposed to what the user prefers.
+ */
+export type SurfaceEnvironment = Readonly<{
+    /** The operating system asks for less transparency. */
+    osReducedTransparency: boolean;
+    /** The user turned reduced transparency on inside the application. */
+    userReducedTransparency: boolean;
+    /** The host window can render OS translucency (vibrancy, acrylic). */
+    nativeTranslucency: boolean;
+}>;
+/**
+ * A stored value as a surface, or nothing.
+ *
+ * `undefined` rather than `opaque` for an unreadable value: the selection field is
+ * optional, and an absent field is how a store that never chose a surface stays
+ * byte-identical to what it was before the axis existed.
+ */
+export declare function normalizeSurface(value: unknown): ThemeSurface | undefined;
+/**
+ * The surface to paint: the preference, after the accessibility override and the
+ * host's capability.
+ *
+ * The OS setting or the user's own flag forces an accessible opaque fallback. A
+ * translucent request on a host without native translucency renders the tokenized
+ * frosted surface instead of pretending to OS vibrancy.
+ */
+export declare function resolveSurface(preference: ThemeSurface, environment: SurfaceEnvironment): ThemeSurface;
+/**
+ * The fill opacity each surface paints, written as `--surface-alpha`.
+ *
+ * These are the values `--surface-frost` and `--surface-translucent` declare in
+ * `theme.css` (the stylesheet is the readable copy; `tests/theme-surface.test.ts`
+ * fails when the two disagree). They are numbers rather than `var()` references so
+ * the property reads the same to a script, a test and the stylesheet, whichever
+ * wrote it.
+ */
+export declare const surfaceAlpha: Readonly<Record<ThemeSurface, string>>;
+/** What a selection paints for the surface axis. */
+export type SurfaceState = Readonly<{
+    /** The surface after the accessibility override and capability gate. */
+    surface: ThemeSurface;
+    /** True while the OS or the user forces opaque surfaces. */
+    reduceTransparencyActive: boolean;
+}>;
+/**
+ * The surface state for a preference and an environment.
+ *
+ * A preference of `undefined` is `opaque`: the axis is optional on a selection, and
+ * a host that never set it gets the plain canvas.
+ */
+export declare function resolveSurfaceState(preference: ThemeSurface | undefined, environment: SurfaceEnvironment): SurfaceState;
+//# sourceMappingURL=theme-surface.d.ts.map

package/dist/lib/theme-surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-surface.d.ts","sourceRoot":"","sources":["../../src/lib/theme-surface.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,SAAS,GAAG,aAAa,CAAA;AAE/D,wDAAwD;AACxD,eAAO,MAAM,aAAa,EAAE,SAAS,YAAY,EAAyC,CAAA;AAE1F,kFAAkF;AAClF,eAAO,MAAM,0BAA0B,2CAA2C,CAAA;AAElF;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC;IACxC,uDAAuD;IACvD,qBAAqB,EAAE,OAAO,CAAA;IAC9B,sEAAsE;IACtE,uBAAuB,EAAE,OAAO,CAAA;IAChC,sEAAsE;IACtE,kBAAkB,EAAE,OAAO,CAAA;CAC5B,CAAC,CAAA;AAEF;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,GAAG,SAAS,CAEzE;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,YAAY,EACxB,WAAW,EAAE,kBAAkB,GAC9B,YAAY,CAId;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAI/D,CAAA;AAED,oDAAoD;AACpD,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC;IAClC,wEAAwE;IACxE,OAAO,EAAE,YAAY,CAAA;IACrB,4DAA4D;IAC5D,wBAAwB,EAAE,OAAO,CAAA;CAClC,CAAC,CAAA;AAEF;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,YAAY,GAAG,SAAS,EACpC,WAAW,EAAE,kBAAkB,GAC9B,YAAY,CAMd"}

package/dist/lib/theme-surface.js

@@ -0,0 +1,62 @@
+//#region src/lib/theme-surface.ts
+/** Every surface, in the order a picker offers them. */
+var themeSurfaces = [
+	"opaque",
+	"frosted",
+	"translucent"
+];
+/** The media query the operating system's Reduce Transparency setting answers. */
+var REDUCED_TRANSPARENCY_QUERY = "(prefers-reduced-transparency: reduce)";
+/**
+* A stored value as a surface, or nothing.
+*
+* `undefined` rather than `opaque` for an unreadable value: the selection field is
+* optional, and an absent field is how a store that never chose a surface stays
+* byte-identical to what it was before the axis existed.
+*/
+function normalizeSurface(value) {
+	return value === "opaque" || value === "frosted" || value === "translucent" ? value : void 0;
+}
+/**
+* The surface to paint: the preference, after the accessibility override and the
+* host's capability.
+*
+* The OS setting or the user's own flag forces an accessible opaque fallback. A
+* translucent request on a host without native translucency renders the tokenized
+* frosted surface instead of pretending to OS vibrancy.
+*/
+function resolveSurface(preference, environment) {
+	if (environment.osReducedTransparency || environment.userReducedTransparency) return "opaque";
+	if (preference === "translucent" && !environment.nativeTranslucency) return "frosted";
+	return preference;
+}
+/**
+* The fill opacity each surface paints, written as `--surface-alpha`.
+*
+* These are the values `--surface-frost` and `--surface-translucent` declare in
+* `theme.css` (the stylesheet is the readable copy; `tests/theme-surface.test.ts`
+* fails when the two disagree). They are numbers rather than `var()` references so
+* the property reads the same to a script, a test and the stylesheet, whichever
+* wrote it.
+*/
+var surfaceAlpha = {
+	opaque: "1",
+	frosted: "0.92",
+	translucent: "0.8"
+};
+/**
+* The surface state for a preference and an environment.
+*
+* A preference of `undefined` is `opaque`: the axis is optional on a selection, and
+* a host that never set it gets the plain canvas.
+*/
+function resolveSurfaceState(preference, environment) {
+	return {
+		surface: resolveSurface(preference ?? "opaque", environment),
+		reduceTransparencyActive: environment.osReducedTransparency || environment.userReducedTransparency
+	};
+}
+//#endregion
+export { REDUCED_TRANSPARENCY_QUERY, normalizeSurface, resolveSurface, resolveSurfaceState, surfaceAlpha, themeSurfaces };
+
+//# sourceMappingURL=theme-surface.js.map

package/dist/lib/theme-surface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-surface.js","names":[],"sources":["../../src/lib/theme-surface.ts"],"sourcesContent":["/*\n * Copyright (c) 2026 Wing\n * Licensed under the MIT License.\n *\n * `resolveSurface` is Zeron's `SurfacePreference.resolve` (https://github.com/zeronsh/zeron),\n * extended by Adea's accepted port of it (`packages/ui/src/components/appearance.ts`)\n * with the translucent capability gate and the reduced-transparency policy. Moved\n * here so the shared provider and Adea run one implementation. See NOTICE.\n */\n\n/**\n * The surface axis, and the policy that decides what it paints.\n *\n * A surface is how opaque the window's elevated panels are: `opaque` is the plain\n * canvas, `frosted` is a tokenized translucent fill over a blur (works everywhere,\n * in CSS alone), and `translucent` asks for the host window's own vibrancy, which only\n * a desktop shell can honour.\n *\n * Nothing here touches the document or a signal. The provider reads the operating\n * system and the host's capability, calls {@link resolveSurface}, and\n * `theme-document.ts` writes the answer; the rule itself is a function of its four\n * inputs, which is what makes it testable.\n */\nexport type ThemeSurface = 'opaque' | 'frosted' | 'translucent'\n\n/** Every surface, in the order a picker offers them. */\nexport const themeSurfaces: readonly ThemeSurface[] = ['opaque', 'frosted', 'translucent']\n\n/** The media query the operating system's Reduce Transparency setting answers. */\nexport const REDUCED_TRANSPARENCY_QUERY = '(prefers-reduced-transparency: reduce)'\n\n/**\n * What the world says about transparency, as opposed to what the user prefers.\n */\nexport type SurfaceEnvironment = Readonly<{\n  /** The operating system asks for less transparency. */\n  osReducedTransparency: boolean\n  /** The user turned reduced transparency on inside the application. */\n  userReducedTransparency: boolean\n  /** The host window can render OS translucency (vibrancy, acrylic). */\n  nativeTranslucency: boolean\n}>\n\n/**\n * A stored value as a surface, or nothing.\n *\n * `undefined` rather than `opaque` for an unreadable value: the selection field is\n * optional, and an absent field is how a store that never chose a surface stays\n * byte-identical to what it was before the axis existed.\n */\nexport function normalizeSurface(value: unknown): ThemeSurface | undefined {\n  return value === 'opaque' || value === 'frosted' || value === 'translucent' ? value : undefined\n}\n\n/**\n * The surface to paint: the preference, after the accessibility override and the\n * host's capability.\n *\n * The OS setting or the user's own flag forces an accessible opaque fallback. A\n * translucent request on a host without native translucency renders the tokenized\n * frosted surface instead of pretending to OS vibrancy.\n */\nexport function resolveSurface(\n  preference: ThemeSurface,\n  environment: SurfaceEnvironment\n): ThemeSurface {\n  if (environment.osReducedTransparency || environment.userReducedTransparency) return 'opaque'\n  if (preference === 'translucent' && !environment.nativeTranslucency) return 'frosted'\n  return preference\n}\n\n/**\n * The fill opacity each surface paints, written as `--surface-alpha`.\n *\n * These are the values `--surface-frost` and `--surface-translucent` declare in\n * `theme.css` (the stylesheet is the readable copy; `tests/theme-surface.test.ts`\n * fails when the two disagree). They are numbers rather than `var()` references so\n * the property reads the same to a script, a test and the stylesheet, whichever\n * wrote it.\n */\nexport const surfaceAlpha: Readonly<Record<ThemeSurface, string>> = {\n  opaque: '1',\n  frosted: '0.92',\n  translucent: '0.8',\n}\n\n/** What a selection paints for the surface axis. */\nexport type SurfaceState = Readonly<{\n  /** The surface after the accessibility override and capability gate. */\n  surface: ThemeSurface\n  /** True while the OS or the user forces opaque surfaces. */\n  reduceTransparencyActive: boolean\n}>\n\n/**\n * The surface state for a preference and an environment.\n *\n * A preference of `undefined` is `opaque`: the axis is optional on a selection, and\n * a host that never set it gets the plain canvas.\n */\nexport function resolveSurfaceState(\n  preference: ThemeSurface | undefined,\n  environment: SurfaceEnvironment\n): SurfaceState {\n  return {\n    surface: resolveSurface(preference ?? 'opaque', environment),\n    reduceTransparencyActive:\n      environment.osReducedTransparency || environment.userReducedTransparency,\n  }\n}\n"],"mappings":";;AA0BA,IAAa,gBAAyC;CAAC;CAAU;CAAW;AAAa;;AAGzF,IAAa,6BAA6B;;;;;;;;AAqB1C,SAAgB,iBAAiB,OAA0C;CACzE,OAAO,UAAU,YAAY,UAAU,aAAa,UAAU,gBAAgB,QAAQ,KAAA;AACxF;;;;;;;;;AAUA,SAAgB,eACd,YACA,aACc;CACd,IAAI,YAAY,yBAAyB,YAAY,yBAAyB,OAAO;CACrF,IAAI,eAAe,iBAAiB,CAAC,YAAY,oBAAoB,OAAO;CAC5E,OAAO;AACT;;;;;;;;;;AAWA,IAAa,eAAuD;CAClE,QAAQ;CACR,SAAS;CACT,aAAa;AACf;;;;;;;AAgBA,SAAgB,oBACd,YACA,aACc;CACd,OAAO;EACL,SAAS,eAAe,cAAc,UAAU,WAAW;EAC3D,0BACE,YAAY,yBAAyB,YAAY;CACrD;AACF"}

package/dist/lib/themes.d.ts

@@ -33,6 +33,7 @@
  * `surfaceHover`, which is what shadcn components actually use it for.
  */
 import { type AccentPreset, type AdeaTheme, type AdeaThemeRecord } from '@adea-ai/themes';
+import { type AccentRoles } from './accent-roles';
 export { isThemeAccentId } from './theme-accents';
 export type ThemeAppearance = 'light' | 'dark';
 /**
@@ -289,7 +290,28 @@ export declare function appearancePreviewThemes(selection: {
 export declare function accentVariables(accentId: string, appearance: ThemeAppearance, pair?: {
     lightThemeId: string;
     darkThemeId: string;
-}): Record<string, string> | undefined;
+}, options?: AccentVariableOptions): Record<string, string> | undefined;
+/** What an accent is held to when it is resolved against a surface. */
+export type AccentVariableOptions = {
+    /** The surface the accent must read on: the variant's `colors.background`. */
+    background?: string;
+    /**
+     * The contrast floor against `background`. Absent, a preset is painted verbatim
+     * and only a custom `#rrggbb` is held to the default floor.
+     */
+    floor?: number;
+    /** The variant the accent is applied to, so the tint takes its measured strength. */
+    variantId?: string;
+};
+/**
+ * An accent selection resolved to the full {@link AccentRoles}, against a theme
+ * pair. {@link accentVariables} is the document half of this; an element-scoped
+ * paint (`paintAccentRoles`) wants all of it, including the tint.
+ */
+export declare function accentRolesForSelection(accentId: string, appearance: ThemeAppearance, pair?: {
+    lightThemeId: string;
+    darkThemeId: string;
+}, options?: AccentVariableOptions): AccentRoles | undefined;
 /**
  * The roles a variant sets, as CSS custom properties.
  *
@@ -299,6 +321,15 @@ export declare function accentVariables(accentId: string, appearance: ThemeAppea
  * than separate roles, which is why they are built here and not in the catalogue.
  */
 export declare function themeCssVariables(theme: ThemeVariant): Record<string, string>;
+/**
+ * The `--terminal-*` properties of a variant: the palette a terminal paints.
+ *
+ * What a pinned terminal theme writes over the interface variant's own. Taken from
+ * {@link themeCssVariables} rather than rebuilt, so the names, and a custom
+ * variant's verbatim `tokens`, can never drift from what the interface variant
+ * would have written for the same palette.
+ */
+export declare function terminalCssVariables(theme: ThemeVariant): Record<string, string>;
 /**
  * Token values with every `oklch()` colour written as `#rrggbb`.
  *

package/dist/lib/themes.d.ts.map

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

package/dist/lib/themes.js

@@ -1,5 +1,6 @@
+import { accentOverrideVariables, resolveAccentRoles } from "./accent-roles.js";
 import { isThemeAccentId } from "./theme-accents.js";
-import { accentForeground, accentRoles, chartSeries, contrastRatio, getAccent, getTheme, hasTheme, primaryHover, primarySubtleCss, shadcnDestructiveProjection, statusForeground, syntaxRoles, themeAccentPresets, themes, themesByAppearance, tint, validateCatalogue } from "@adea-ai/themes";
+import { accentForeground, chartSeries, contrastRatio as contrastRatio$1, getAccent, getTheme, hasTheme, primaryHover, primarySubtleCss, shadcnDestructiveProjection, statusForeground, syntaxRoles, themeAccentPresets, themes, themesByAppearance, tint, validateCatalogue } from "@adea-ai/themes";
 import { shadcnVariables } from "@adea-ai/themes/adapters/shadcn";
 import { oklchToHex, parseColor } from "@adea-ai/themes/oklch";
 //#region src/lib/themes.ts
@@ -364,18 +365,27 @@ function appearancePreviewThemes(selection) {
 function accentVariables(accentId, appearance, pair = {
 	lightThemeId: defaultLightThemeId,
 	darkThemeId: defaultDarkThemeId
-}) {
+}, options = {}) {
+	const roles = accentRolesForSelection(accentId, appearance, pair, options);
+	return roles ? accentOverrideVariables(roles) : void 0;
+}
+/**
+* An accent selection resolved to the full {@link AccentRoles}, against a theme
+* pair. {@link accentVariables} is the document half of this; an element-scoped
+* paint (`paintAccentRoles`) wants all of it, including the tint.
+*/
+function accentRolesForSelection(accentId, appearance, pair = {
+	lightThemeId: defaultLightThemeId,
+	darkThemeId: defaultDarkThemeId
+}, options = {}) {
 	if (accentId === "theme") return void 0;
-	const { light, dark } = recordPair(pair.lightThemeId, pair.darkThemeId);
-	const preset = resolveAccentPreset(accentId, light, dark);
-	if (!preset) return void 0;
-	const roles = accentRoles(preset, appearance);
-	return {
-		"--primary": roles.primary,
-		"--primary-foreground": roles.primaryForeground,
-		"--primary-hover": roles.primaryHover,
-		"--ring": roles.ring
-	};
+	const record = options.variantId ? getTheme(options.variantId) : void 0;
+	return resolveAccentRoles(accentId, {
+		target: record ?? appearance,
+		background: options.background,
+		floor: options.floor,
+		themeAccents: isThemeAccentId(accentId) ? themeAccentsFor(pair.lightThemeId, pair.darkThemeId) : void 0
+	});
 }
 /**
 * The roles a variant sets, as CSS custom properties.
@@ -484,6 +494,17 @@ function themeCssVariables(theme) {
 	} : derived;
 }
 /**
+* The `--terminal-*` properties of a variant: the palette a terminal paints.
+*
+* What a pinned terminal theme writes over the interface variant's own. Taken from
+* {@link themeCssVariables} rather than rebuilt, so the names, and a custom
+* variant's verbatim `tokens`, can never drift from what the interface variant
+* would have written for the same palette.
+*/
+function terminalCssVariables(theme) {
+	return Object.fromEntries(Object.entries(themeCssVariables(theme)).filter(([name]) => name.startsWith("--terminal-")));
+}
+/**
 * Token values with every `oklch()` colour written as `#rrggbb`.
 *
 * For a host whose stylesheet, tests or native shell speak hex: the catalogue's
@@ -531,6 +552,6 @@ function validateThemeRegistry(themes$1 = builtinThemes) {
 var defaultLightThemeId = "adea-light";
 var defaultDarkThemeId = "adea-dark";
 //#endregion
-export { accentVariables, appearancePreviewThemes, builtinThemes, contrastRatio, defaultDarkThemeId, defaultLightThemeId, isThemeAccentId, primarySubtleFor, resolveAccentPreset, resolveVariant, themeAccentsFor, themeById, themeCssVariables, themeFamilies, themeRecordById, themeRecords, themesForAppearance, tokensAsHex, validateTheme, validateThemeRegistry, variantFromRecord, withAccent };
+export { accentRolesForSelection, accentVariables, appearancePreviewThemes, builtinThemes, contrastRatio$1 as contrastRatio, defaultDarkThemeId, defaultLightThemeId, isThemeAccentId, primarySubtleFor, resolveAccentPreset, resolveVariant, terminalCssVariables, themeAccentsFor, themeById, themeCssVariables, themeFamilies, themeRecordById, themeRecords, themesForAppearance, tokensAsHex, validateTheme, validateThemeRegistry, variantFromRecord, withAccent };
 
 //# sourceMappingURL=themes.js.map