@celestia-island/hikari 0.55.223 → 0.55.224

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celestia-island/hikari",
-  "version": "0.55.223",
+  "version": "0.55.224",
   "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/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;

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/,
+    );
+  });
+});