@celestia-island/hikari 0.55.223 → 0.55.225

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celestia-island/hikari",
-  "version": "0.55.223",
+  "version": "0.55.225",
   "private": false,
   "type": "module",
   "description": "Hikari UI library, Vue 3 runtime — one design system for Vue 3 and Rust/WASM applications",

package/src/components/HkAlert.scss

@@ -93,6 +93,11 @@
 }
 
 .hk-alert-text {
+  /* Alert body = the same copy-this-error-detail content class as the
+   * toast message and message-box text (L2 selection policy re-enables,
+   * 2026-10-29); the title above stays chrome. */
+  -webkit-user-select: text;
+  user-select: text;
   margin: 0;
   line-height: 1.5;
   color: color-mix(in srgb, var(--hi-color-text-secondary, #666666) 85%, transparent);

package/src/components/HkBlockingToast.scss

@@ -58,10 +58,17 @@
 }
 
 .hk-blocking-toast-title {
+  /* Content, not chrome — copy-worthy detail under the L2 selection
+   * policy (2026-10-29): the card shell denies, these two text blocks
+   * select again. */
+  -webkit-user-select: text;
+  user-select: text;
   font-weight: 700;
 }
 
 .hk-blocking-toast-message {
+  -webkit-user-select: text;
+  user-select: text;
   margin: 0;
   display: -webkit-box;
   -webkit-line-clamp: 5;

package/src/components/HkConfirmDialog.scss

@@ -15,6 +15,10 @@
 }
 
 .hk-confirm-dialog-message {
+  /* Dialog message = copy-worthy content, same class as the message-box
+   * text (L2 selection policy re-enables, 2026-10-29). */
+  -webkit-user-select: text;
+  user-select: text;
   margin: 0;
   color: color-mix(in srgb, var(--hi-color-text-secondary) 85%, transparent);
   font-size: var(--text-sm, 0.8125rem);

package/src/components/HkDiffViewer.scss

@@ -67,6 +67,10 @@
 }
 
 .hk-diff-viewer__code {
+  /* The diff body is content (review text users copy into replies);
+   * the line-number gutter above and the sign column stay denied. */
+  -webkit-user-select: text;
+  user-select: text;
   padding-inline-end: 1ch;
   min-width: 0;
 }

package/src/components/HkJsonTree.scss

@@ -45,6 +45,11 @@
 }
 
 .s-jt-row {
+  /* Tree rows are content — values users copy out of a payload — while
+   * the pane chrome above stays denied (L2 selection policy, 2026-10-29;
+   * the copy-tree affordance remains the bulk path). */
+  -webkit-user-select: text;
+  user-select: text;
   /* Baseline alignment keeps the small type hints (boolean/number/string)
      on the value's text baseline instead of floating above it. */
   display: flex;

package/src/components/HkLogWindow.scss

@@ -117,6 +117,12 @@
 }
 
 .s-log-entry {
+  /* Log lines are the canonical copy-me content (diagnostics users
+   * select per-fragment, not just via the toolbar copy-all) — re-enable
+   * under the L2 selection policy (2026-10-29); the toolbar chrome
+   * around them stays denied. */
+  -webkit-user-select: text;
+  user-select: text;
   padding: var(--space-2, 0.125rem) var(--space-4, 0.25rem);
   font-family: var(--font-mono, vars.$hikari-font-family-mono);
   font-size: var(--text-xs, 0.75rem);

package/src/components/HkMarkdownRenderer.scss

@@ -2,6 +2,11 @@
 @use "./hikari-vars" as vars;
 
 .hk-markdown {
+  /* Rendered prose is content by definition — the whole subtree selects
+   * again under the L2 selection policy (2026-10-29); its code blocks
+   * are covered twice over (whitelist tier 3). */
+  -webkit-user-select: text;
+  user-select: text;
   font-size: var(--text-base);
   line-height: 1.7;
   color: var(--hi-color-text-primary, #1e1e1e);

package/src/components/HkMessageBox.scss

@@ -25,6 +25,11 @@
 }
 
 .hk-message-box-text {
+  /* Dialog message = content the user may need to copy (error detail),
+   * not chrome — whitelisted under the L2 selection policy (2026-10-29).
+   * The prompt's field below is covered by the editable-controls tier. */
+  -webkit-user-select: text;
+  user-select: text;
   margin: 0;
   color: rgb(var(--color-text));
   font-size: var(--text-base, 15px);

package/src/components/HkScrollContainer.fade.contract.test.ts

@@ -0,0 +1,66 @@
+/**
+ * Source contract for the scroll-container edge fades (the 2026-10
+ * revision): each edge owns a CSS var and the viewport mask INTERSECTS a
+ * vertical and a horizontal gradient, so a two-axis container fades on all
+ * four sides and the corners fall off naturally.
+ *
+ * The regression this pins (user report: "the light effect is clipped at
+ * the two sides"): the old sheet wrote ONE `mask-image` per axis, so the
+ * last matching rule won, the other axis never faded, and its band ended in
+ * a hard cut. Vertical fades were missing entirely. Hence:
+ *   - exactly ONE mask declaration pair lives in the sheet (the composed
+ *     block on the viewport) — a new per-axis `mask-image` rule is drift;
+ *   - all four edge vars are declared (top/right/bottom/left, 0px base);
+ *   - start/end/both rules exist for BOTH axes;
+ *   - RTL swaps the horizontal vars instead of rewriting the mask.
+ */
+import { describe, expect, it } from "vitest";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const sheet = readFileSync(join(here, "HkScrollContainer.scss"), "utf-8");
+
+describe("scroll fade composition contract", () => {
+  it("declares one composed mask on the viewport (no per-axis overrides)", () => {
+    const declarations = sheet.match(/^\s*-?(?:webkit-)?mask-image:/gm) ?? [];
+    // The composed block owns exactly one pair: -webkit-mask-image + mask-image.
+    expect(declarations.length).toBe(2);
+    expect(sheet).toContain("mask-composite: intersect");
+    expect(sheet).toContain("-webkit-mask-composite: source-in");
+  });
+
+  it("declares the four edge vars with zero defaults", () => {
+    for (const edge of ["top", "right", "bottom", "left"]) {
+      expect(sheet).toContain(`--hk-scroll-fade-${edge}: 0px;`);
+    }
+  });
+
+  it("fades both axes from the sensed overflow", () => {
+    for (const axis of ["v", "h"]) {
+      for (const state of ["start", "end", "both"]) {
+        expect(sheet).toContain(
+          `[data-${axis}-overflow="${state}"]`,
+        );
+      }
+    }
+    // The vertical half is what the old sheet was missing entirely.
+    expect(sheet).toContain('--hk-scroll-fade-top: var(--hk-scroll-fade-size)');
+    expect(sheet).toContain('--hk-scroll-fade-bottom: var(--hk-scroll-fade-size)');
+  });
+
+  it("swaps horizontal sides under RTL instead of rewriting the mask", () => {
+    expect(sheet).toContain(
+      '[dir="rtl"] .hk-scroll-container[data-fade="true"][data-h-overflow="start"]',
+    );
+    expect(sheet).toContain(
+      '[dir="rtl"] .hk-scroll-container[data-fade="true"][data-h-overflow="end"]',
+    );
+  });
+
+  it("routes the dock fades through the same edge vars", () => {
+    expect(sheet).toContain('--hk-scroll-fade-bottom: var(--hk-scroll-dock-fade, 2rem)');
+    expect(sheet).toContain('--hk-scroll-fade-top: var(--hk-scroll-dock-fade, 2rem)');
+  });
+});

package/src/components/HkScrollContainer.scss

@@ -39,18 +39,104 @@
   margin-inline: auto;
 }
 
-/* ── Optional edge fades (fade=true) ──────────────────────────────
-   Pure CSS driven by the sensed overflow state the component mirrors
-   onto the root (data-h-overflow). Only the sides with hidden
-   content fade. The fade size custom property is declared on the
-   root so consumers can override it from the container element. */
+/* ── Optional edge fades (fade=true / dock fades) ─────────────────
+   FOUR-EDGE composition (2026-10 revision): each edge owns a CSS var, and
+   the viewport's mask INTERSECTS a vertical and a horizontal gradient, so
+   the fade reaches zero on every side that hides content and the corners
+   fall off naturally in all four directions. The previous per-axis rules
+   overwrote one `mask-image` property, so a two-axis container only faded
+   one axis AND the band ended in a hard cut at the other axis's edges
+   (user report: the light effect is clipped at the two sides). Vertical
+   fades were missing entirely. Dock fades ride the same vars, which also
+   removes their old mask-override conflict. */
+.hk-scroll-container:is([data-fade="true"], [data-dock-fade]) > .hk-scroll-container-viewport {
+  --hk-scroll-fade-top: 0px;
+  --hk-scroll-fade-right: 0px;
+  --hk-scroll-fade-bottom: 0px;
+  --hk-scroll-fade-left: 0px;
+  -webkit-mask-image:
+    linear-gradient(
+      to bottom,
+      transparent 0,
+      #000 var(--hk-scroll-fade-top),
+      #000 calc(100% - var(--hk-scroll-fade-bottom)),
+      transparent 100%
+    ),
+    linear-gradient(
+      to right,
+      transparent 0,
+      #000 var(--hk-scroll-fade-left),
+      #000 calc(100% - var(--hk-scroll-fade-right)),
+      transparent 100%
+    );
+  -webkit-mask-composite: source-in;
+  -webkit-mask-repeat: no-repeat;
+  mask-image:
+    linear-gradient(
+      to bottom,
+      transparent 0,
+      #000 var(--hk-scroll-fade-top),
+      #000 calc(100% - var(--hk-scroll-fade-bottom)),
+      transparent 100%
+    ),
+    linear-gradient(
+      to right,
+      transparent 0,
+      #000 var(--hk-scroll-fade-left),
+      #000 calc(100% - var(--hk-scroll-fade-right)),
+      transparent 100%
+    );
+  mask-composite: intersect;
+  mask-repeat: no-repeat;
+}
+
 .hk-scroll-container[data-fade="true"] {
   --hk-scroll-fade-size: var(--space-24);
 }
 
-.hk-scroll-container[data-fade="true"][data-h-overflow="end"] > .hk-scroll-container-viewport {
-  -webkit-mask-image: linear-gradient(to left, transparent 0, #000 var(--hk-scroll-fade-size));
-  mask-image: linear-gradient(to left, transparent 0, #000 var(--hk-scroll-fade-size));
+/* Vertical axis — the half the old implementation never had. */
+.hk-scroll-container[data-fade="true"][data-v-overflow="start"] {
+  --hk-scroll-fade-top: var(--hk-scroll-fade-size);
+}
+
+.hk-scroll-container[data-fade="true"][data-v-overflow="end"] {
+  --hk-scroll-fade-bottom: var(--hk-scroll-fade-size);
+}
+
+.hk-scroll-container[data-fade="true"][data-v-overflow="both"] {
+  --hk-scroll-fade-top: var(--hk-scroll-fade-size);
+  --hk-scroll-fade-bottom: var(--hk-scroll-fade-size);
+}
+
+/* Horizontal axis (LTR: inline start = left). */
+.hk-scroll-container[data-fade="true"][data-h-overflow="start"] {
+  --hk-scroll-fade-left: var(--hk-scroll-fade-size);
+}
+
+.hk-scroll-container[data-fade="true"][data-h-overflow="end"] {
+  --hk-scroll-fade-right: var(--hk-scroll-fade-size);
+}
+
+.hk-scroll-container[data-fade="true"][data-h-overflow="both"] {
+  --hk-scroll-fade-left: var(--hk-scroll-fade-size);
+  --hk-scroll-fade-right: var(--hk-scroll-fade-size);
+}
+
+/* RTL: the inline start edge is the right side, so the horizontal vars
+   swap instead of the mask (the mask itself is direction-neutral). */
+[dir="rtl"] .hk-scroll-container[data-fade="true"][data-h-overflow="start"] {
+  --hk-scroll-fade-left: 0px;
+  --hk-scroll-fade-right: var(--hk-scroll-fade-size);
+}
+
+[dir="rtl"] .hk-scroll-container[data-fade="true"][data-h-overflow="end"] {
+  --hk-scroll-fade-right: 0px;
+  --hk-scroll-fade-left: var(--hk-scroll-fade-size);
+}
+
+[dir="rtl"] .hk-scroll-container[data-fade="true"][data-h-overflow="both"] {
+  --hk-scroll-fade-left: var(--hk-scroll-fade-size);
+  --hk-scroll-fade-right: var(--hk-scroll-fade-size);
 }
 
 /* ── Anchored docks (dockTop / dockBottom slots) ─────────────────
@@ -74,14 +160,12 @@
    instead of a hard clip against the dock's top edge. Content never
    sits under the dock, so this fades the viewport's last few pixels,
    not the dock itself. */
-.hk-scroll-container[data-dock-fade="bottom"] > .hk-scroll-container-viewport {
-  -webkit-mask-image: linear-gradient(to bottom, #000 calc(100% - var(--hk-scroll-dock-fade, 2rem)), transparent);
-  mask-image: linear-gradient(to bottom, #000 calc(100% - var(--hk-scroll-dock-fade, 2rem)), transparent);
+.hk-scroll-container[data-dock-fade="bottom"] {
+  --hk-scroll-fade-bottom: var(--hk-scroll-dock-fade, 2rem);
 }
 
-.hk-scroll-container[data-dock-fade="top"] > .hk-scroll-container-viewport {
-  -webkit-mask-image: linear-gradient(to bottom, transparent, #000 var(--hk-scroll-dock-fade, 2rem));
-  mask-image: linear-gradient(to bottom, transparent, #000 var(--hk-scroll-dock-fade, 2rem));
+.hk-scroll-container[data-dock-fade="top"] {
+  --hk-scroll-fade-top: var(--hk-scroll-dock-fade, 2rem);
 }
 
 /* ── Floating-dock tail clearance (dockTailClearance opt-in) ──────
@@ -135,39 +219,7 @@
 }
 
 
-.hk-scroll-container[data-fade="true"][data-h-overflow="start"] > .hk-scroll-container-viewport {
-  -webkit-mask-image: linear-gradient(to right, transparent 0, #000 var(--hk-scroll-fade-size));
-  mask-image: linear-gradient(to right, transparent 0, #000 var(--hk-scroll-fade-size));
-}
-
-/* RTL: the horizontal scroll start/end edges swap sides, so the
- * directional fades flip (the "both" mask is end-symmetric — no flip). */
-[dir="rtl"] .hk-scroll-container[data-fade="true"][data-h-overflow="end"] > .hk-scroll-container-viewport {
-  -webkit-mask-image: linear-gradient(to right, transparent 0, #000 var(--hk-scroll-fade-size));
-  mask-image: linear-gradient(to right, transparent 0, #000 var(--hk-scroll-fade-size));
-}
 
-[dir="rtl"] .hk-scroll-container[data-fade="true"][data-h-overflow="start"] > .hk-scroll-container-viewport {
-  -webkit-mask-image: linear-gradient(to left, transparent 0, #000 var(--hk-scroll-fade-size));
-  mask-image: linear-gradient(to left, transparent 0, #000 var(--hk-scroll-fade-size));
-}
-
-.hk-scroll-container[data-fade="true"][data-h-overflow="both"] > .hk-scroll-container-viewport {
-  -webkit-mask-image: linear-gradient(
-    to right,
-    transparent 0,
-    #000 var(--hk-scroll-fade-size),
-    #000 calc(100% - var(--hk-scroll-fade-size)),
-    transparent 100%
-  );
-  mask-image: linear-gradient(
-    to right,
-    transparent 0,
-    #000 var(--hk-scroll-fade-size),
-    #000 calc(100% - var(--hk-scroll-fade-size)),
-    transparent 100%
-  );
-}
 
 /* autoFollow content is bottom-anchored while it fits the viewport: the
    newest row hugs the bottom edge (a tail-following console, e.g. the

package/src/components/HkTable.scss

@@ -420,6 +420,17 @@
   }
 }
 
+/* Opt-out consumers get plain selectable cells back — explicit because
+ * the L2 selection policy (2026-10-29) denies at the root now: absence
+ * of the copy-cells deny rule no longer means selectable. Same shape as
+ * the copy layer, so "wholesale" is a per-cell mirror of the default. */
+.hk-table:not([data-copy-cells]) {
+  .hk-table-cell {
+    -webkit-user-select: text;
+    user-select: text;
+  }
+}
+
 /* The standard trailing row-actions column (HkRowActions trigger):
    fixed narrow track, centered, never wrapping. */
 .hk-table-manage-cell {

package/src/components/HkToast.scss

@@ -55,6 +55,12 @@
 }
 
 .hk-toast-message {
+  /* The message text is content — error detail a user copies out of a
+   * failing app — not chrome. Re-enable inside the denied toast shell
+   * (L2 selection policy, 2026-10-29): the shell keeps its none, the
+   * message subtree selects again. */
+  -webkit-user-select: text;
+  user-select: text;
   flex: 1;
   min-width: 0;
   display: -webkit-box;
@@ -128,17 +134,21 @@
   to { transform: rotate(360deg); }
 }
 
-/* Inline action (e.g. Undo): a compact text pill in the toast chrome,
- *  between the body and the icon buttons. Sits in the same ghost-button
- *  family as copy/close, but reads as an affordance. */
+/* Inline action (e.g. Undo / open analysis): a GLASS PILL on the toast's
+ *  solid band. The old ghost outline sat flat on the accent fill — "a grey
+ *  outlined transparent button", user report 2026-10 — because it borrowed
+ *  the page-surface border tokens on a filled surface. A currentColor tint
+ *  follows every variant (white on the coloured bands, near-black on the
+ *  amber warning band) and reads as a real affordance without introducing
+ *  a second accent colour. */
 .hk-toast-action {
   flex: none;
   align-self: center;
   margin-inline-start: var(--space-4, 4px);
-  padding: var(--space-2, 2px) var(--space-8, 8px);
-  border: 1px solid rgb(var(--color-border, 100 100 100) / 30%);
-  border-radius: var(--radius-sm, 4px);
-  background: transparent;
+  padding: var(--space-4, 4px) var(--space-10, 10px);
+  border: 1px solid color-mix(in srgb, currentColor 38%, transparent);
+  border-radius: var(--radius-full, 9999px);
+  background: color-mix(in srgb, currentColor 14%, transparent);
   color: inherit;
   font: inherit;
   font-size: var(--text-sm, 0.8125rem);
@@ -146,14 +156,18 @@
   line-height: 1.4;
   cursor: pointer;
   white-space: nowrap;
-  opacity: 0.92;
-  transition: opacity var(--duration-fast, 0.15s) ease,
+  transition:
+    background var(--duration-fast, 0.15s) ease,
     border-color var(--duration-fast, 0.15s) ease;
 }
 
 .hk-toast-action:hover {
-  opacity: 1;
-  border-color: rgb(var(--color-border, 100 100 100) / 55%);
+  background: color-mix(in srgb, currentColor 24%, transparent);
+  border-color: color-mix(in srgb, currentColor 55%, transparent);
+}
+
+.hk-toast-action:active {
+  background: color-mix(in srgb, currentColor 32%, transparent);
 }
 
 .hk-toast-action:focus-visible {

package/src/res/boot-chrome.js

@@ -720,10 +720,11 @@
     // stays enabled even when the window controls degraded.
     button.disabled = false;
     button.removeAttribute("aria-disabled");
-    // Right-hand cluster, immediately LEFT of close: closing keeps the frame
-    // corner (the familiar target), so a user reaching for it on a hung window
-    // cannot hit reload by mistake.
-    actions.insertBefore(button, closeBtn);
+    // Reload LEADS the cluster (2026-10-29 user direction): the affordance
+    // sits ahead of the window controls — [reload][minimize][maximize][close]
+    // — so the three caption buttons (and the close frame corner) keep their
+    // familiar trailing positions.
+    actions.insertBefore(button, minimizeBtn);
     reloadBtn = button;
     return button;
   }

package/src/res/bootChrome.test.ts

@@ -396,19 +396,20 @@ describe("boot-chrome.js handoff and watchdog", () => {
     expect(control("close").disabled).toBe(false);
   });
 
-  it("puts the reload affordance at the right edge, next to close (S3-5)", () => {
+  it("puts the reload affordance ahead of the window controls (2026-10-29 user direction)", () => {
     useWindowApi(fakeWindowApi());
     setGlobal("__TAURI_INTERNALS__", { invoke: vi.fn() });
     runBootChrome({ hangMs: 1000 });
 
     vi.advanceTimersByTime(1000);
 
-    // Right-hand cluster, immediately left of close: closing keeps the frame
-    // corner, so a mis-aimed click on a hung window cannot reload it.
+    // Reload LEADS the cluster — [reload][min][max][close] — so the three
+    // caption buttons (and the close frame corner) keep their familiar
+    // trailing positions instead of the reload splitting max from close.
     expect(controls().map((button) => button.getAttribute("data-act"))).toEqual([
+      "reload",
       "minimize",
       "maximize",
-      "reload",
       "close",
     ]);
   });

package/src/styles/index.scss

@@ -6,6 +6,9 @@
 //   1. theme/channels.scss — the static seed: --color-* channel palette,
 //      --hi-color-* derivations, --c-*/--shadow-*/--border-* aliases and
 //      the icon-button bridge (vendored from src/tokens.scss).
+//   1b. selection.scss — the selection policy: deny-by-default at the
+//      root (chrome text never takes a drag selection), whitelisted back
+//      for editable controls and the .hk-selectable content hook.
 //   2. theme/scale.scss — the L2 scale tokens: spacing, type, radius,
 //      blur, opacity, durations, easings, z bands, fonts (vendored from
 //      src/scale.scss).
@@ -28,6 +31,7 @@
 // version of this file re-exported packages/theme + packages/components
 // through paths that escape the npm package and did not compile.
 @use "./reset.scss";
+@use "./selection.scss";
 @use "./theme/channels.scss";
 @use "./theme/scale.scss";
 @use "../overlay/overlayRoot.scss";

package/src/styles/selection.scss

@@ -0,0 +1,59 @@
+/* ── Selection policy (L2) — deny by default, whitelist back ───────────
+ * 2026-10-29 user direction: UI chrome text (workspace menus, buttons,
+ * tabs, labels, rails, caption bars) must not take a drag selection.
+ * The old model was a blacklist — every component sheet opted out
+ * piecemeal, and any surface a sheet forgot shipped selectable until a
+ * screenshot complained. This sheet flips the default: the root denies,
+ * and only whitelisted subtrees select again.
+ *
+ * How one rule covers everything: `user-select` is not inherited, but
+ * its initial value `auto` RESOLVES against the parent's used value.
+ * A single `none` on `html` therefore determines every descendant
+ * (shadow trees included), and a whitelisted subtree declaring a
+ * concrete value re-enables its own descendants the same way — no
+ * `*` sweep, and component/host rules keep winning by specificity or
+ * order wherever they speak.
+ *
+ * The whitelist:
+ *   1. Editable controls — input, textarea, select, contenteditable:
+ *      the user authored this text; selecting it is the point.
+ *   2. `.hk-selectable` — the opt-in utility for hosts and components:
+ *      put it on any subtree whose text is CONTENT (chat bodies, logs,
+ *      error details, IDs, prose, standalone code blocks) rather than
+ *      chrome. This is the contract that replaces the old per-component
+ *      blacklist.
+ *
+ * Deliberately NOT whitelisted: bare `pre` / `code` / `kbd` / `samp`.
+ * A concrete value on an element BEATS the ancestor's none-propagation,
+ * so an element-type whitelist would punch through chrome that embeds
+ * those elements — HkButton's HkKbd shortcut chip (denied `.hk-btn` on
+ * the button itself), or a `<code>` slotted into a click-to-copy table
+ * cell (the 2026-10-18 copy-cells contract). Content containers own
+ * their re-enables instead: hikari's prose/code components (markdown
+ * body, diff code, json-tree rows, log entries) self-declare
+ * `user-select: text` in their sheets, so vendored copies carry their
+ * own contract, and hosts mark standalone code/log surfaces with
+ * `.hk-selectable`.
+ *
+ * Order: SECOND in the canonical composition (index.scss), right after
+ * the reset — the same "only lowers defaults; component sheets and host
+ * styles override by specificity/order" discipline applies. A host that
+ * truly wants select-everything back sets `user-select: text` on its own
+ * root; marking content with `.hk-selectable` is the supported route.
+ */
+
+html {
+  -webkit-user-select: none;
+  user-select: none;
+}
+
+input,
+textarea,
+select,
+/* `i` flag: HTML enumerated attribute values are ASCII case-insensitive,
+ * so contenteditable="FALSE" (valid, means false) must be excluded too. */
+[contenteditable]:not([contenteditable='false' i]),
+.hk-selectable {
+  -webkit-user-select: text;
+  user-select: text;
+}

package/src/styles/selectionSheet.test.ts

@@ -0,0 +1,134 @@
+import { readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import * as sass from "sass";
+import { describe, expect, it } from "vitest";
+
+/**
+ * Selection policy guard (2026-10-29 user direction).
+ *
+ * `selection.scss` flips the selection model from a blacklist (component
+ * sheets opting out piecemeal; anything a sheet forgot shipped selectable)
+ * to a whitelist: the root denies, editable controls / the `.hk-selectable`
+ * content hook / pre-code conventions select again, and hikari's own
+ * content-bearing components self-declare their re-enables in their sheets
+ * (toast message, markdown body, diff code, json-tree rows, table opt-out).
+ *
+ * The contract under test, per half:
+ *   - the canonical composition loads the sheet SECOND (right after the
+ *     reset, before any theme/component sheet can override);
+ *   - the compiled policy carries the root deny and every whitelist tier
+ *     (assertions run on the COMPILED sheet — compressed drops both
+ *     comment styles, so raw-text matching cannot pass on a commented-out
+ *     rule);
+ *   - the component re-enables really exist in the compiled component
+ *     sheets, with the chrome halves still denied.
+ */
+
+const stylesDir = resolve(dirname(fileURLToPath(import.meta.url)));
+const srcDir = resolve(stylesDir, "..");
+
+function read(path: string): string {
+  return readFileSync(resolve(stylesDir, path), "utf8").replace(/\r\n/g, "\n");
+}
+
+function compile(path: string): string {
+  return sass.compile(resolve(stylesDir, path), {
+    loadPaths: [srcDir, join(srcDir, "components"), join(srcDir, "styles"), join(srcDir, "styles", "theme")],
+    style: "compressed",
+    silenceDeprecations: ["import", "global-builtin", "legacy-js-api"],
+  }).css;
+}
+
+describe("selection policy sheet", () => {
+  it("loads second in the canonical composition (right after the reset)", () => {
+    const uses = read("index.scss")
+      .split("\n")
+      .filter((line) => line.startsWith('@use "./'))
+      .map((line) => line.match(/^@use "([^"]+)"/)?.[1]);
+    expect(uses[0]).toBe("./reset.scss");
+    expect(uses[1]).toBe("./selection.scss");
+  });
+
+  it("denies selection at the root", () => {
+    const css = compile("selection.scss");
+    expect(css).toMatch(/html\s*\{[^}]*?-webkit-user-select:\s*none/);
+    expect(css).toMatch(/html\s*\{[^}]*?user-select:\s*none/);
+  });
+
+  it("whitelists exactly the editable controls and the content hook", () => {
+    const css = compile("selection.scss");
+    // Exact, comma-anchored selector list — substring matching would pass
+    // vacuously ("select" occurs inside every user-select declaration).
+    // Compressed output drops unnecessary attribute-quote characters.
+    const group = css.match(
+      /((?:input|textarea|select|\[[^\]]+\]|\.hk-selectable)[^{}]*)\{-webkit-user-select:\s*text;user-select:\s*text\}/,
+    );
+    expect(group).toBeTruthy();
+    expect(group![1].split(",").map((s) => s.trim())).toEqual([
+      "input",
+      "textarea",
+      "select",
+      "[contenteditable]:not([contenteditable=false i])",
+      ".hk-selectable",
+    ]);
+    // Element-type content conventions (pre/code/kbd/samp) stay OUT: a
+    // concrete value beats ancestor chrome denies, so a bare kbd/code
+    // whitelist punched through HkButton's denied shortcut chip and
+    // click-to-copy table cells (2026-10-29 review, S1).
+    expect(css).not.toMatch(/(^|[,\s])(pre|code|kbd|samp)([,\s]*\{|,)/);
+  });
+
+  it("re-enables the toast family message text (content, not chrome)", () => {
+    const css = compile("../components/HkToast.scss");
+    expect(css).toMatch(/\.hk-toast-message[^{]*\{[^}]*?-webkit-user-select:\s*text/);
+    // The shell stays denied — only the message subtree selects.
+    expect(css).toMatch(/\.hk-toast-item\s*\{[^}]*?user-select:\s*none/);
+    const cssBlocking = compile("../components/HkBlockingToast.scss");
+    expect(cssBlocking).toMatch(/\.hk-blocking-toast-title[^{]*\{[^}]*?user-select:\s*text/);
+    expect(cssBlocking).toMatch(/\.hk-blocking-toast-message[^{]*\{[^}]*?user-select:\s*text/);
+    const cssBox = compile("../components/HkMessageBox.scss");
+    expect(cssBox).toMatch(/\.hk-message-box-text[^{]*\{[^}]*?user-select:\s*text/);
+  });
+
+  it("re-enables the markdown body and the diff code, keeping the diff gutter denied", () => {
+    const css = compile("../components/HkMarkdownRenderer.scss");
+    expect(css).toMatch(/\.hk-markdown\s*\{[^}]*?user-select:\s*text/);
+    const cssDiff = compile("../components/HkDiffViewer.scss");
+    expect(cssDiff).toMatch(/\.hk-diff-viewer__code[^{]*\{[^}]*?user-select:\s*text/);
+    expect(cssDiff).toMatch(/\.hk-diff-viewer__no[^{]*\{[^}]*?user-select:\s*none/);
+    expect(cssDiff).toMatch(/\.hk-diff-viewer__sign[^{]*\{[^}]*?user-select:\s*none/);
+  });
+
+  it("re-enables json-tree rows inside the denied pane chrome", () => {
+    const css = compile("../components/HkJsonTree.scss");
+    expect(css).toMatch(/\.s-jt-row[^{]*\{[^}]*?user-select:\s*text/);
+    expect(css).toMatch(/\.s-tool-json-tree[^{]*\{[^}]*?user-select:\s*none/);
+  });
+
+  it("re-enables the alert body and the confirm-dialog message", () => {
+    // Same copy-this-error-detail content class as the toast/message-box
+    // surfaces (2026-10-29 review, S2: the parallel surfaces were missed
+    // in the first cut).
+    const cssAlert = compile("../components/HkAlert.scss");
+    expect(cssAlert).toMatch(/\.hk-alert-text[^{]*\{[^}]*?user-select:\s*text/);
+    const cssConfirm = compile("../components/HkConfirmDialog.scss");
+    expect(cssConfirm).toMatch(
+      /\.hk-confirm-dialog-message[^{]*\{[^}]*?user-select:\s*text/,
+    );
+    const cssLog = compile("../components/HkLogWindow.scss");
+    expect(cssLog).toMatch(/\.s-log-entry[^{]*\{[^}]*?user-select:\s*text/);
+  });
+
+  it("keeps the table contract two-sided under the deny-by-default root", () => {
+    // 2026-10-18 contract: copy-cells (default) denies cells with the
+    // click-to-copy cursor; the opt-out now needs an explicit mirror —
+    // absence of a deny no longer means selectable once the root denies.
+    const css = compile("../components/HkTable.scss");
+    expect(css).toMatch(/\.hk-table\[data-copy-cells\] \.hk-table-cell\{[^}]*?user-select:\s*none/);
+    expect(css).toMatch(
+      /\.hk-table:not\(\[data-copy-cells\]\) \.hk-table-cell\{[^}]*?user-select:\s*text/,
+    );
+  });
+});