@leavepulse/ui 0.90.0 → 0.92.0

package/dist/assets/{LpCommandPalette-CO_5TFOQ.css → LpCommandPalette-D9ZuNQmc.css}

@@ -5,28 +5,28 @@
  * pane from its right edge as it grows. Animating the columns themselves made
  * every line of the list and the pane re-wrap on every frame.
  */
-.lp-cmd-dialog[data-v-1801065c] {
+.lp-cmd-dialog[data-v-d51dc98f] {
   --lp-cmd-list: min(92vw, 40rem);
   --lp-cmd-pane: max(0px, min(26rem, 96vw - var(--lp-cmd-list)));
   width: var(--lp-cmd-list);
 }
-.lp-cmd-split[data-v-1801065c] {
+.lp-cmd-split[data-v-d51dc98f] {
   transition:
     width 300ms var(--ease-emphasized, ease),
     min-height 300ms var(--ease-emphasized, ease);
 }
 @media (min-width: 768px) {
-.lp-cmd-split .lp-cmd-list[data-v-1801065c] {
+.lp-cmd-split .lp-cmd-list[data-v-d51dc98f] {
     flex: 0 0 auto;
     /* the dialog's 1px border on each side */
     width: calc(var(--lp-cmd-list) - 2px);
 }
-.lp-cmd-dialog[data-pane="open"][data-v-1801065c] {
+.lp-cmd-dialog[data-pane="open"][data-v-d51dc98f] {
     width: calc(var(--lp-cmd-list) + var(--lp-cmd-pane));
     min-height: min(76vh, 36rem);
 }
 }
-.lp-cmd-pane[data-v-1801065c] {
+.lp-cmd-pane[data-v-d51dc98f] {
   width: var(--lp-cmd-pane);
 }
 /*
@@ -36,7 +36,7 @@
  * desktop window keeps the card.
  */
 @media (hover: none) and (pointer: coarse) and (max-width: 639px) {
-.lp-cmd-dialog[data-v-1801065c] {
+.lp-cmd-dialog[data-v-d51dc98f] {
     inset: var(--lp-cmd-vy, 0) auto auto var(--lp-cmd-vx, 0);
     translate: none;
     width: var(--lp-cmd-vw, 100%);
@@ -48,10 +48,10 @@
     padding-bottom: env(safe-area-inset-bottom);
 }
 }
-.lp-cmd-dialog[data-editing] .lp-cmd-pane[data-v-1801065c] {
+.lp-cmd-dialog[data-editing] .lp-cmd-pane[data-v-d51dc98f] {
   width: 100%;
 }
-.lp-cmd-dialog[data-editing][data-v-1801065c] {
+.lp-cmd-dialog[data-editing][data-v-d51dc98f] {
   width: var(--lp-cmd-list);
   min-height: 0;
 }
@@ -59,43 +59,43 @@
  * The pane rides in from the right edge while the dialog opens up to it, and
  * leaves the same way, for as long as the dialog takes to close over it.
  */
-.lp-cmd-pane-enter-active[data-v-1801065c],
-.lp-cmd-pane-leave-active[data-v-1801065c] {
+.lp-cmd-pane-enter-active[data-v-d51dc98f],
+.lp-cmd-pane-leave-active[data-v-d51dc98f] {
   transition:
     transform 300ms var(--ease-emphasized, ease),
     opacity 300ms ease;
 }
-.lp-cmd-pane-enter-from[data-v-1801065c],
-.lp-cmd-pane-leave-to[data-v-1801065c] {
+.lp-cmd-pane-enter-from[data-v-d51dc98f],
+.lp-cmd-pane-leave-to[data-v-d51dc98f] {
   opacity: 0;
   transform: translateX(40%);
 }
-.lp-cmd-para[data-v-1801065c] {
+.lp-cmd-para[data-v-d51dc98f] {
   --rise: 4px;
   animation: rise-in 260ms ease-out both;
 }
 @media (prefers-reduced-motion: reduce) {
-.lp-cmd-split[data-v-1801065c],
-  .lp-cmd-pane-enter-active[data-v-1801065c],
-  .lp-cmd-pane-leave-active[data-v-1801065c] {
+.lp-cmd-split[data-v-d51dc98f],
+  .lp-cmd-pane-enter-active[data-v-d51dc98f],
+  .lp-cmd-pane-leave-active[data-v-d51dc98f] {
     transition: none;
 }
-.lp-cmd-para[data-v-1801065c] {
+.lp-cmd-para[data-v-d51dc98f] {
     animation: none;
 }
 }
-.lp-cmd-excerpt[data-v-1801065c] {
+.lp-cmd-excerpt[data-v-d51dc98f] {
   display: -webkit-box;
   -webkit-box-orient: vertical;
   overflow: hidden;
 }
 /* Each result eases in; honours reduced motion. */
-.lp-cmd-item[data-v-1801065c] {
+.lp-cmd-item[data-v-d51dc98f] {
   --rise: 3px;
   animation: rise-in 140ms ease-out both;
 }
 @media (prefers-reduced-motion: reduce) {
-.lp-cmd-item[data-v-1801065c] {
+.lp-cmd-item[data-v-d51dc98f] {
     animation: none;
 }
 }

package/dist/assets/{LpTable-DAVNb-x2.css → LpTable-B3hNJQVl.css}

@@ -1,4 +1,27 @@
 
+/*
+ * A list line's facts, one dot between each two that are there. Every field
+ * carries its own dot before it; the row sits one dot to the left inside a
+ * box that clips, so the dot opening the line, or any wrapped line, falls
+ * outside and only the dots between facts are seen. A cell whose slot drew
+ * nothing (a v-if that failed, an empty value) is left out, dot and all.
+ */
+.lp-line[data-v-62285817] {
+  --lp-line-sep: 1rem;
+}
+.lp-line-row[data-v-62285817] {
+  margin-left: calc(-1 * var(--lp-line-sep));
+}
+.lp-line-field[data-v-62285817]::before {
+  content: "·" / "";
+  display: inline-block;
+  width: var(--lp-line-sep);
+  text-align: center;
+}
+.lp-line-field[data-v-62285817]:has(> .lp-line-value:empty) {
+  display: none;
+}
+
 /*
  * Rows arriving, leaving and moving as the filter changes.
  *
@@ -11,17 +34,17 @@
  * fade before closing the gap and the whole list lurches at the end instead of
  * gliding.
  */
-.lp-row-enter-active[data-v-f0750892],
-.lp-row-leave-active[data-v-f0750892] {
+.lp-row-enter-active[data-v-62285817],
+.lp-row-leave-active[data-v-62285817] {
   transition:
     opacity var(--duration-fast) var(--ease-emphasized),
     transform var(--duration-fast) var(--ease-emphasized);
 }
-.lp-row-move[data-v-f0750892] {
+.lp-row-move[data-v-62285817] {
   transition: transform var(--duration-medium) var(--ease-emphasized);
 }
-.lp-row-enter-from[data-v-f0750892],
-.lp-row-leave-to[data-v-f0750892] {
+.lp-row-enter-from[data-v-62285817],
+.lp-row-leave-to[data-v-62285817] {
   opacity: 0;
   transform: translateX(-0.5rem);
 }
@@ -35,7 +58,7 @@
  * drops out of the table layout entirely. Nothing sits below this row to be
  * dragged around, so simply not animating its exit costs nothing.
  */
-.lp-row-empty.lp-row-leave-active[data-v-f0750892] {
+.lp-row-empty.lp-row-leave-active[data-v-62285817] {
   display: none;
 }
 
@@ -54,7 +77,7 @@
  * once anything is selected. An earlier version collapsed the column to nothing
  * and floated the hover box over the first cell, where it sat on the text.
  */
-.lp-tick[data-v-f0750892] {
+.lp-tick[data-v-62285817] {
   display: flex;
   align-items: center;
   max-width: 0;
@@ -66,17 +89,17 @@
     padding var(--duration-medium) var(--ease-emphasized),
     opacity var(--duration-fast) ease;
 }
-.lp-tick-open[data-v-f0750892] {
+.lp-tick-open[data-v-62285817] {
   max-width: 3.25rem;
   padding-inline: 1rem;
   opacity: 1;
 }
-.lp-tick-hidden[data-v-f0750892],
-.lp-tick-cue[data-v-f0750892] {
+.lp-tick-hidden[data-v-62285817],
+.lp-tick-cue[data-v-62285817] {
   opacity: 0;
 }
-tr:hover .lp-tick-cue[data-v-f0750892],
-.lp-tick-cue[data-v-f0750892]:focus-within {
+tr:hover .lp-tick-cue[data-v-62285817],
+.lp-tick-cue[data-v-62285817]:focus-within {
   opacity: 1;
 }
 
@@ -84,15 +107,15 @@ tr:hover .lp-tick-cue[data-v-f0750892],
    turned down the rows change without animating rather than not changing. */
 /* Only where there is a hover to reveal it; a finger long-presses instead. */
 @media (hover: none) {
-tr:hover .lp-tick-cue[data-v-f0750892] {
+tr:hover .lp-tick-cue[data-v-62285817] {
     opacity: 0;
 }
 
   /* Nor is there anything for the column's width to hold until then: on a
      touch screen it stays closed until a long press starts selecting, and
      eases open like the rest of the column. */
-.lp-tick-hidden[data-v-f0750892],
-  .lp-tick-cue[data-v-f0750892] {
+.lp-tick-hidden[data-v-62285817],
+  .lp-tick-cue[data-v-62285817] {
     max-width: 0;
     padding-inline: 0;
 }
@@ -102,7 +125,7 @@ tr:hover .lp-tick-cue[data-v-f0750892] {
  * A list line's tick opens from nothing, as the table's column does, so lines
  * do not carry an empty gap until selection starts.
  */
-.lp-tick-line[data-v-f0750892] {
+.lp-tick-line[data-v-62285817] {
   max-width: 2rem;
   opacity: 1;
 }
@@ -112,28 +135,28 @@ tr:hover .lp-tick-cue[data-v-f0750892] {
  * open; a cue shows it only while
  * the card is pointed at or holds focus, the same rule as a row's.
  */
-.lp-tick-card[data-v-f0750892] {
+.lp-tick-card[data-v-62285817] {
   max-width: none;
   padding-inline: 0;
   opacity: 1;
 }
-.lp-tick[data-cue][data-v-f0750892] {
+.lp-tick[data-cue][data-v-62285817] {
   opacity: 0;
 }
-.lp-item:hover .lp-tick[data-cue][data-v-f0750892],
-.lp-tick[data-cue][data-v-f0750892]:focus-within {
+.lp-item:hover .lp-tick[data-cue][data-v-62285817],
+.lp-tick[data-cue][data-v-62285817]:focus-within {
   opacity: 1;
 }
 @media (hover: none) {
-.lp-item:hover .lp-tick[data-cue][data-v-f0750892] {
+.lp-item:hover .lp-tick[data-cue][data-v-62285817] {
     opacity: 0;
 }
 }
 @media (prefers-reduced-motion: reduce) {
-.lp-row-enter-active[data-v-f0750892],
-  .lp-row-leave-active[data-v-f0750892],
-  .lp-row-move[data-v-f0750892],
-  .lp-tick[data-v-f0750892] {
+.lp-row-enter-active[data-v-62285817],
+  .lp-row-leave-active[data-v-62285817],
+  .lp-row-move[data-v-62285817],
+  .lp-tick[data-v-62285817] {
     transition: none;
 }
 }

package/dist/components/LpCommandPalette.vue.d.ts

@@ -53,11 +53,19 @@ export interface Command {
     group?: string;
     disabled?: boolean;
     /**
-     * Hidden from the default (empty-query) list — only surfaces once the user
-     * types something it matches. For rarely-used or destructive actions (prune,
-     * decommission, …) that shouldn't clutter the palette but stay reachable.
+     * Hidden from the default (empty-query) list and surfaced only when the query
+     * names it: every typed word starts a word of its label or keywords. A word
+     * inside another word, the description or a near miss does not reveal it.
+     * For rarely-used or destructive actions (prune, decommission, …) that
+     * shouldn't clutter the palette but stay reachable.
      */
     hidden?: boolean;
+    /**
+     * For a hidden command: the words that reveal it, instead of its label and
+     * keywords. A variant whose label repeats its parent's word ("Vacation: sick
+     * leave…") then stays out of a search for the parent and shows up for "sick".
+     */
+    revealOn?: string[];
     /**
      * Picking this opens a mode instead of closing: a nested list, either given
      * outright or fetched from the query typed inside it. This is what keeps a

package/dist/components/LpCommandPalette.vue.js

@@ -26,7 +26,7 @@ import { parsePaletteQuery, parseCommandQuery, searchCommandItems, applyQueryFil
 import { PALETTE_MODES, modeChipLabel, settleFetched, fallbackRows, readRecent, resolveRecentItems, recentVisible, commandHasPreview, matchModePrefix, isSafeHref, absoluteHref, commandKey, recentKey, pushRecent, moreRowId, toRecentItem } from "./commandPalette.js";
 import { useView, usePortalTarget, useOutsideGuard, viewWindow } from "../composables/useView.js";
 import { _ as _export_sfc } from "../chunks/_plugin-vue_export-helper-1tPrXgE0.js";
-import '../assets/LpCommandPalette-CO_5TFOQ.css';const _hoisted_1 = { class: "relative flex shrink-0 items-center gap-2.5 border-b border-line px-4" };
+import '../assets/LpCommandPalette-D9ZuNQmc.css';const _hoisted_1 = { class: "relative flex shrink-0 items-center gap-2.5 border-b border-line px-4" };
 const _hoisted_2 = ["title", "onClick"];
 const _hoisted_3 = ["readonly", "aria-label", "aria-expanded", "aria-controls", "aria-activedescendant", "placeholder", "onKeydown"];
 const _hoisted_4 = { class: "shrink-0 rounded-small border border-line px-1.5 py-0.5 text-[10px] text-muted [@media(hover:none)_and_(pointer:coarse)]:hidden" };
@@ -1400,7 +1400,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const LpCommandPalette = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-1801065c"]]);
+const LpCommandPalette = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-d51dc98f"]]);
 export {
   LpCommandPalette as default
 };

package/dist/components/LpTable.vue.d.ts

@@ -2,6 +2,8 @@ import { type ColumnPin, type ColumnPreset, type TableLayout } from "./tableFeat
 import { type CsvOptions } from "./exportData";
 import { type TableFilters } from "./tableFilter";
 import { type TableRowMenuResult } from "./tableRowMenu";
+/** How a column reads in a list line: alone, after its label, or not at all. */
+export type TableListMode = boolean | "label";
 export interface TableColumn<Row> {
     key: string;
     label: string;
@@ -58,6 +60,19 @@ export interface TableColumn<Row> {
      * user's own show/hide applies as usual.
      */
     hideBelow?: number;
+    /**
+     * How the column reads in a list line (the `list` layout, and a table drawn
+     * as a list below `layoutBelow`), where there are no headers to name it.
+     * `true` (default) puts the value alone in the line; `"label"` prefixes its
+     * label, for a figure that means nothing on its own ("Cores 28"); `false`
+     * leaves it out: an actions column (the row menu holds the same actions),
+     * or a fact the line already says. A function decides per row, for a fact
+     * worth a place only when it holds something ("needs attention", a stack
+     * that is set): a cell slot cannot say "nothing" itself, since an empty
+     * slot falls back to the raw value. Cards always show labels and are not
+     * affected.
+     */
+    list?: TableListMode | ((row: Row) => TableListMode);
     /** Stick to this edge while the table scrolls sideways. Pinned columns move to that edge. */
     pin?: ColumnPin;
     /** Bounds in px for `resizableColumns`. */

package/dist/components/LpTable.vue.js

@@ -34,7 +34,7 @@ import { toCsv, downloadFile, fileStem } from "./exportData.js";
 import { toHiddenSets, sameHidden, summarizeShown, parseTableState, mergeRestored, serializeTableState, fromHiddenSets } from "./tableFilter.js";
 import { resolveRowMenu } from "./tableRowMenu.js";
 import { _ as _export_sfc } from "../chunks/_plugin-vue_export-helper-1tPrXgE0.js";
-import '../assets/LpTable-DAVNb-x2.css';const _hoisted_1 = {
+import '../assets/LpTable-B3hNJQVl.css';const _hoisted_1 = {
   key: 0,
   class: "flex min-h-8 flex-wrap items-center gap-x-3 gap-y-2 pb-3 text-xs"
 };
@@ -132,13 +132,15 @@ const _hoisted_44 = {
 };
 const _hoisted_45 = {
   key: 1,
-  class: "flex min-w-0 flex-wrap items-center gap-x-2 gap-y-0.5 text-xs text-muted"
+  class: "lp-line min-w-0 overflow-hidden text-xs text-muted"
 };
-const _hoisted_46 = {
+const _hoisted_46 = { class: "lp-line-row flex flex-wrap items-center gap-y-0.5" };
+const _hoisted_47 = ["title"];
+const _hoisted_48 = {
   key: 0,
-  "aria-hidden": "true"
+  class: "lp-line-label"
 };
-const _hoisted_47 = ["title"];
+const _hoisted_49 = { class: "lp-line-value" };
 const __default__ = { inheritAttrs: false };
 const _sfc_main = /* @__PURE__ */ defineComponent({
   ...__default__,
@@ -936,6 +938,10 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     );
     const titleColumn = computed(() => cardColumns.value[0]);
     const fieldColumns = computed(() => cardColumns.value.slice(1).filter((col) => col.label));
+    const lineColumns = computed(() => fieldColumns.value.filter((col) => col.list !== false));
+    function lineMode(col, row) {
+      return (typeof col.list === "function" ? col.list(row) : col.list) ?? true;
+    }
     watch(chosenLayout, (layout) => {
       if (storageKey.value && restored.value) store.set(`${storageKey.value}:layout`, layout);
     });
@@ -1840,26 +1846,31 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                                   createTextVNode(toDisplayString(entry.row[titleColumn.value.key]), 1)
                                 ], true)
                               ])) : createCommentVNode("", true),
-                              fieldColumns.value.length ? (openBlock(), createElementBlock("div", _hoisted_45, [
-                                (openBlock(true), createElementBlock(Fragment, null, renderList(fieldColumns.value, (col, ci) => {
-                                  return openBlock(), createElementBlock(Fragment, {
-                                    key: col.key
-                                  }, [
-                                    ci > 0 ? (openBlock(), createElementBlock("span", _hoisted_46, "·")) : createCommentVNode("", true),
-                                    createElementVNode("span", {
-                                      class: "min-w-0 truncate",
-                                      title: col.label
+                              lineColumns.value.length ? (openBlock(), createElementBlock("div", _hoisted_45, [
+                                createElementVNode("div", _hoisted_46, [
+                                  (openBlock(true), createElementBlock(Fragment, null, renderList(lineColumns.value, (col) => {
+                                    return openBlock(), createElementBlock(Fragment, {
+                                      key: col.key
                                     }, [
-                                      renderSlot(_ctx.$slots, `cell-${col.key}`, {
-                                        row: entry.row,
-                                        value: entry.row[col.key],
-                                        openMenu: openRowMenu
-                                      }, () => [
-                                        createTextVNode(toDisplayString(entry.row[col.key]), 1)
-                                      ], true)
-                                    ], 8, _hoisted_47)
-                                  ], 64);
-                                }), 128))
+                                      lineMode(col, entry.row) !== false ? (openBlock(), createElementBlock("span", {
+                                        key: 0,
+                                        class: "lp-line-field min-w-0 truncate",
+                                        title: col.label
+                                      }, [
+                                        lineMode(col, entry.row) === "label" ? (openBlock(), createElementBlock("span", _hoisted_48, toDisplayString(`${col.label} `), 1)) : createCommentVNode("", true),
+                                        createElementVNode("span", _hoisted_49, [
+                                          renderSlot(_ctx.$slots, `cell-${col.key}`, {
+                                            row: entry.row,
+                                            value: entry.row[col.key],
+                                            openMenu: openRowMenu
+                                          }, () => [
+                                            createTextVNode(toDisplayString(entry.row[col.key]), 1)
+                                          ], true)
+                                        ])
+                                      ], 8, _hoisted_47)) : createCommentVNode("", true)
+                                    ], 64);
+                                  }), 128))
+                                ])
                               ])) : createCommentVNode("", true)
                             ], true)
                           ]))
@@ -1887,7 +1898,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const LpTable = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-f0750892"]]);
+const LpTable = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-62285817"]]);
 export {
   LpTable as default
 };

package/dist/components/commandSearch.d.ts

@@ -3,6 +3,8 @@ export interface SearchableCommand {
     description?: string;
     keywords?: string[];
     group?: string;
+    hidden?: boolean;
+    revealOn?: string[];
 }
 export interface CommandSearchTerms {
     include: string[];

package/dist/components/commandSearch.js

@@ -26,9 +26,17 @@ function nearWord(term, label) {
   if (term.length < 5) return false;
   return label.split(/[^\p{L}\p{N}]+/u).some((word) => withinOne(term, word) || word.length > term.length && withinOne(term, word.slice(0, term.length)));
 }
+function wordStarts(text, term) {
+  return text.split(/[^\p{L}\p{N}]+/u).some((word) => word.startsWith(term));
+}
+function named(command, terms) {
+  const words = command.revealOn ? command.revealOn.map((word) => word.toLowerCase()) : [command.label.toLowerCase(), ...(command.keywords ?? []).map((keyword) => keyword.toLowerCase())];
+  return terms.include.length > 0 && terms.include.every((term) => words.some((text) => wordStarts(text, term)));
+}
 function score(command, terms) {
+  if (command.hidden && !named(command, terms)) return 0;
   const label = command.label.toLowerCase();
-  const keywords = (command.keywords ?? []).map((keyword) => keyword.toLowerCase());
+  const keywords = [...command.keywords ?? [], ...command.revealOn ?? []].map((keyword) => keyword.toLowerCase());
   const description = command.description?.toLowerCase() ?? "";
   const group = command.group?.toLowerCase() ?? "";
   if (terms.exclude.some((term) => matches(command, term)) || terms.groups.some((term) => !group.includes(term))) return 0;

package/dist/index.d.ts

@@ -191,7 +191,7 @@ export { default as LpStepper } from "./components/LpStepper.vue";
 export type { Step } from "./components/LpStepper.vue";
 export { default as LpSwitch } from "./components/LpSwitch.vue";
 export { default as LpTable } from "./components/LpTable.vue";
-export type { SortState, TableColumn, TablePage, TableQuery } from "./components/LpTable.vue";
+export type { SortState, TableColumn, TableListMode, TablePage, TableQuery } from "./components/LpTable.vue";
 export type { TableLabels } from "./components/LpTable.vue";
 export type { TableCellEdit, TableExportOptions, TableSelectionToken } from "./components/LpTable.vue";
 export type { ColumnPin, ColumnPreset, TableLayout } from "./components/tableFeatures";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leavepulse/ui",
-  "version": "0.90.0",
+  "version": "0.92.0",
   "type": "module",
   "description": "LeavePulse token-driven Vue component kit.",
   "repository": {

package/src/components/LpCommandPalette.vue

@@ -143,11 +143,19 @@ export interface Command {
   group?: string
   disabled?: boolean
   /**
-   * Hidden from the default (empty-query) list — only surfaces once the user
-   * types something it matches. For rarely-used or destructive actions (prune,
-   * decommission, …) that shouldn't clutter the palette but stay reachable.
+   * Hidden from the default (empty-query) list and surfaced only when the query
+   * names it: every typed word starts a word of its label or keywords. A word
+   * inside another word, the description or a near miss does not reveal it.
+   * For rarely-used or destructive actions (prune, decommission, …) that
+   * shouldn't clutter the palette but stay reachable.
    */
   hidden?: boolean
+  /**
+   * For a hidden command: the words that reveal it, instead of its label and
+   * keywords. A variant whose label repeats its parent's word ("Vacation: sick
+   * leave…") then stays out of a search for the parent and shows up for "sick".
+   */
+  revealOn?: string[]
   /**
    * Picking this opens a mode instead of closing: a nested list, either given
    * outright or fetched from the query typed inside it. This is what keeps a
@@ -902,8 +910,8 @@ const local = computed<{ items: Command[]; terms: string[] }>(() => {
   const filtered = query.value.trim()
     ? source.value.filter((c) => !c.fallback)
     : source.value.filter((c) => !c.hidden && !c.fallback)
-  // Empty query: show everything EXCEPT hidden commands (they only surface once
-  // typed). With a query, hidden commands rank like any other.
+  // Empty query: show everything EXCEPT hidden commands. With a query, a hidden
+  // command ranks only when the query names it (see commandSearch).
   if (!terms.include.length && !terms.exclude.length && !terms.groups.length) return { items: filtered, terms: [] }
   return searchCommandItems(filtered, terms)
 })

package/src/components/LpTable.vue

@@ -62,6 +62,9 @@ import {
 } from "./tableFilter"
 import { resolveRowMenu, type TableRowMenuResult } from "./tableRowMenu"
 
+/** How a column reads in a list line: alone, after its label, or not at all. */
+export type TableListMode = boolean | "label"
+
 export interface TableColumn<Row> {
   key: string
   label: string
@@ -118,6 +121,19 @@ export interface TableColumn<Row> {
    * user's own show/hide applies as usual.
    */
   hideBelow?: number
+  /**
+   * How the column reads in a list line (the `list` layout, and a table drawn
+   * as a list below `layoutBelow`), where there are no headers to name it.
+   * `true` (default) puts the value alone in the line; `"label"` prefixes its
+   * label, for a figure that means nothing on its own ("Cores 28"); `false`
+   * leaves it out: an actions column (the row menu holds the same actions),
+   * or a fact the line already says. A function decides per row, for a fact
+   * worth a place only when it holds something ("needs attention", a stack
+   * that is set): a cell slot cannot say "nothing" itself, since an empty
+   * slot falls back to the raw value. Cards always show labels and are not
+   * affected.
+   */
+  list?: TableListMode | ((row: Row) => TableListMode)
   /** Stick to this edge while the table scrolls sideways. Pinned columns move to that edge. */
   pin?: ColumnPin
   /** Bounds in px for `resizableColumns`. */
@@ -1545,6 +1561,10 @@ const cardColumns = computed(() =>
 )
 const titleColumn = computed(() => cardColumns.value[0])
 const fieldColumns = computed(() => cardColumns.value.slice(1).filter((col) => col.label))
+const lineColumns = computed(() => fieldColumns.value.filter((col) => col.list !== false))
+function lineMode(col: TableColumn<T>, row: T): TableListMode {
+  return (typeof col.list === "function" ? col.list(row) : col.list) ?? true
+}
 
 watch(chosenLayout, (layout) => {
   if (storageKey.value && restored.value) store.set(`${storageKey.value}:layout`, layout)
@@ -2377,13 +2397,19 @@ usePaletteCommands(() => {
               <div v-if="titleColumn" class="min-w-0 truncate font-medium text-ink">
                 <slot :name="`cell-${titleColumn.key}`" :row="entry.row" :value="entry.row[titleColumn.key]" :open-menu="openRowMenu">{{ entry.row[titleColumn.key] }}</slot>
               </div>
-              <div v-if="fieldColumns.length" class="flex min-w-0 flex-wrap items-center gap-x-2 gap-y-0.5 text-xs text-muted">
-                <template v-for="(col, ci) in fieldColumns" :key="col.key">
-                  <span v-if="ci > 0" aria-hidden="true">·</span>
-                  <span class="min-w-0 truncate" :title="col.label">
-                    <slot :name="`cell-${col.key}`" :row="entry.row" :value="entry.row[col.key]" :open-menu="openRowMenu">{{ entry.row[col.key] }}</slot>
+              <!-- Separators belong between the facts that are there: a cell
+                   that drew nothing takes no dot, and the dot that would open
+                   a wrapped line is clipped off (the inner row starts one
+                   separator to the left of the clip box). -->
+              <div v-if="lineColumns.length" class="lp-line min-w-0 overflow-hidden text-xs text-muted">
+                <div class="lp-line-row flex flex-wrap items-center gap-y-0.5">
+                  <template v-for="col in lineColumns" :key="col.key">
+                  <span v-if="lineMode(col, entry.row) !== false" class="lp-line-field min-w-0 truncate" :title="col.label">
+                    <span v-if="lineMode(col, entry.row) === 'label'" class="lp-line-label">{{ `${col.label} ` }}</span>
+                    <span class="lp-line-value"><slot :name="`cell-${col.key}`" :row="entry.row" :value="entry.row[col.key]" :open-menu="openRowMenu">{{ entry.row[col.key] }}</slot></span>
                   </span>
-                </template>
+                  </template>
+                </div>
               </div>
             </slot>
           </div>
@@ -2403,6 +2429,32 @@ usePaletteCommands(() => {
 </template>
 
 <style scoped>
+/*
+ * A list line's facts, one dot between each two that are there. Every field
+ * carries its own dot before it; the row sits one dot to the left inside a
+ * box that clips, so the dot opening the line, or any wrapped line, falls
+ * outside and only the dots between facts are seen. A cell whose slot drew
+ * nothing (a v-if that failed, an empty value) is left out, dot and all.
+ */
+.lp-line {
+  --lp-line-sep: 1rem;
+}
+
+.lp-line-row {
+  margin-left: calc(-1 * var(--lp-line-sep));
+}
+
+.lp-line-field::before {
+  content: "·" / "";
+  display: inline-block;
+  width: var(--lp-line-sep);
+  text-align: center;
+}
+
+.lp-line-field:has(> .lp-line-value:empty) {
+  display: none;
+}
+
 /*
  * Rows arriving, leaving and moving as the filter changes.
  *

package/src/components/commandSearch.ts

@@ -3,6 +3,8 @@ export interface SearchableCommand {
   description?: string
   keywords?: string[]
   group?: string
+  hidden?: boolean
+  revealOn?: string[]
 }
 
 export interface CommandSearchTerms {
@@ -50,9 +52,29 @@ function nearWord(term: string, label: string): boolean {
     .some((word) => withinOne(term, word) || (word.length > term.length && withinOne(term, word.slice(0, term.length))))
 }
 
+function wordStarts(text: string, term: string): boolean {
+  return text.split(/[^\p{L}\p{N}]+/u).some((word) => word.startsWith(term))
+}
+
+/*
+ * A hidden command is there for whoever names it, not for whoever types a word
+ * it happens to contain. Every term has to start a word of its label or of a
+ * keyword (or of `revealOn`, which then replaces both): "пт" no longer digs a
+ * settings key out of "Транскрипты", and "vacation" no longer spills every
+ * hidden variant of it. Descriptions, mid-word hits and near misses do not
+ * reveal; the visible list keeps all of those.
+ */
+function named(command: SearchableCommand, terms: CommandSearchTerms): boolean {
+  const words = command.revealOn
+    ? command.revealOn.map((word) => word.toLowerCase())
+    : [command.label.toLowerCase(), ...(command.keywords ?? []).map((keyword) => keyword.toLowerCase())]
+  return terms.include.length > 0 && terms.include.every((term) => words.some((text) => wordStarts(text, term)))
+}
+
 function score(command: SearchableCommand, terms: CommandSearchTerms): number {
+  if (command.hidden && !named(command, terms)) return 0
   const label = command.label.toLowerCase()
-  const keywords = (command.keywords ?? []).map((keyword) => keyword.toLowerCase())
+  const keywords = [...(command.keywords ?? []), ...(command.revealOn ?? [])].map((keyword) => keyword.toLowerCase())
   const description = command.description?.toLowerCase() ?? ""
   const group = command.group?.toLowerCase() ?? ""
   if (terms.exclude.some((term) => matches(command, term)) || terms.groups.some((term) => !group.includes(term))) return 0

package/src/index.ts

@@ -267,7 +267,7 @@ export { default as LpStepper } from "./components/LpStepper.vue"
 export type { Step } from "./components/LpStepper.vue"
 export { default as LpSwitch } from "./components/LpSwitch.vue"
 export { default as LpTable } from "./components/LpTable.vue"
-export type { SortState, TableColumn, TablePage, TableQuery } from "./components/LpTable.vue"
+export type { SortState, TableColumn, TableListMode, TablePage, TableQuery } from "./components/LpTable.vue"
 export type { TableLabels } from "./components/LpTable.vue"
 export type { TableCellEdit, TableExportOptions, TableSelectionToken } from "./components/LpTable.vue"
 export type { ColumnPin, ColumnPreset, TableLayout } from "./components/tableFeatures"