@entifix/next-shell 0.1.0-0

package/dist/lib/command-palette/palette-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"palette-command.d.ts","sourceRoot":"","sources":["../../../src/lib/command-palette/palette-command.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAC7B,6DAA6D;IAC7D,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,+DAA+D;IAC/D,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6DAA6D;IAC7D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC,0DAA0D;AAC1D,eAAO,MAAM,yBAAyB,MAAM,CAAC"}

package/dist/lib/command-palette/palette-command.js

@@ -0,0 +1,19 @@
+/**
+ * A deterministic command, with its copy already resolved.
+ *
+ * The wire shape between a **server** layout — which is where `visibleNav`'s
+ * principal and the translate function live — and the client palette. So it is
+ * plain serializable data and nothing else: a `GuardedCommand` carries catalog
+ * keys and a `Permission`, neither of which a client component should have to
+ * deal with, and a function would not survive the crossing at all.
+ */ /**
+ * How many characters before records are queried at all.
+ *
+ * The same floor `/api/search` enforces, restated here so the palette can *say*
+ * why a record group is absent instead of silently showing nothing. Below it the
+ * route answers empty groups, which would otherwise read as "no matches" for a
+ * search that never ran.
+ */ export const RECORD_SEARCH_MIN_TERM = 2;
+/** How long after the last keystroke the fan-out runs. */ export const RECORD_SEARCH_DEBOUNCE_MS = 250;
+
+//# sourceMappingURL=palette-command.js.map

package/dist/lib/command-palette/palette-command.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/command-palette/palette-command.ts"],"sourcesContent":["/**\n * A deterministic command, with its copy already resolved.\n *\n * The wire shape between a **server** layout — which is where `visibleNav`'s\n * principal and the translate function live — and the client palette. So it is\n * plain serializable data and nothing else: a `GuardedCommand` carries catalog\n * keys and a `Permission`, neither of which a client component should have to\n * deal with, and a function would not survive the crossing at all.\n */\nexport interface PaletteCommand {\n  /** Stable across renders and hosts. Also the recency key. */\n  readonly key: string;\n  readonly label: string;\n  /** Already split from the catalog's comma list by the host. */\n  readonly keywords: readonly string[];\n  /** Locale-free; the palette prefixes it. */\n  readonly href: string;\n  /** The page this command sits on. Omitted means the root. */\n  readonly page?: string;\n}\n\n/**\n * How many characters before records are queried at all.\n *\n * The same floor `/api/search` enforces, restated here so the palette can *say*\n * why a record group is absent instead of silently showing nothing. Below it the\n * route answers empty groups, which would otherwise read as \"no matches\" for a\n * search that never ran.\n */\nexport const RECORD_SEARCH_MIN_TERM = 2;\n\n/** How long after the last keystroke the fan-out runs. */\nexport const RECORD_SEARCH_DEBOUNCE_MS = 250;\n"],"names":["RECORD_SEARCH_MIN_TERM","RECORD_SEARCH_DEBOUNCE_MS"],"mappings":"AAAA;;;;;;;;CAQC,GAaD;;;;;;;CAOC,GACD,OAAO,MAAMA,yBAAyB,EAAE;AAExC,wDAAwD,GACxD,OAAO,MAAMC,4BAA4B,IAAI"}

package/dist/lib/command-palette/use-command-recency.d.ts

@@ -0,0 +1,28 @@
+import type { CommandGroup } from '@entifix/core';
+export interface CommandRecency {
+    /** Reorder a group's options, most recently used first. */
+    readonly rank: (group: CommandGroup) => CommandGroup;
+    /** Remember that this command was just run. */
+    readonly remember: (id: string) => void;
+}
+/**
+ * Which commands this person reaches for, and in what order to offer them.
+ *
+ * **Recency reorders within a group and never across groups.** Group order is
+ * the ranking (ADR 0040), and it is fixed precisely so an operator learns where
+ * a kind of result lands; letting use move a whole group would take that away
+ * for a convenience nobody asked for. Inside a group there is no such contract,
+ * so the last thing you ran comes first.
+ *
+ * Stored as **one keyed record**, not a key per command — the same reasoning
+ * `back-office:nav-collapsed-groups` records: `useUiPreference` resolves after
+ * mount, so N keys are N first-paint transitions while one read settles the
+ * whole palette at once.
+ *
+ * A record group is deliberately left alone: its options are records, whose ids
+ * are primary keys, so remembering them would build a list of which records this
+ * person opened inside a UI preference. Only commands and destinations are
+ * ranked.
+ */
+export declare function useCommandRecency(): CommandRecency;
+//# sourceMappingURL=use-command-recency.d.ts.map

package/dist/lib/command-palette/use-command-recency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-command-recency.d.ts","sourceRoot":"","sources":["../../../src/lib/command-palette/use-command-recency.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAiBlD,MAAM,WAAW,cAAc;IAC7B,2DAA2D;IAC3D,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,YAAY,CAAC;IACrD,+CAA+C;IAC/C,QAAQ,CAAC,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,CA8BlD"}

package/dist/lib/command-palette/use-command-recency.js

@@ -0,0 +1,67 @@
+'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { useUiPreference } from '@entifix/react-controls';
+import { useCallback, useMemo } from 'react';
+/** `namespace:` is prepended by the store → `entifix-ui:back-office:command-recency`. */ const RECENCY_PREF_KEY = 'back-office:command-recency';
+/**
+ * How many commands are remembered.
+ *
+ * A cap rather than an unbounded map: the store writes the whole record on every
+ * run, and a record that only ever grows is a preference that gets slower for
+ * the rest of the person's account life. Twenty is far more than the number of
+ * commands anyone reaches for.
+ */ const RECENCY_LIMIT = 20;
+/**
+ * Which commands this person reaches for, and in what order to offer them.
+ *
+ * **Recency reorders within a group and never across groups.** Group order is
+ * the ranking (ADR 0040), and it is fixed precisely so an operator learns where
+ * a kind of result lands; letting use move a whole group would take that away
+ * for a convenience nobody asked for. Inside a group there is no such contract,
+ * so the last thing you ran comes first.
+ *
+ * Stored as **one keyed record**, not a key per command — the same reasoning
+ * `back-office:nav-collapsed-groups` records: `useUiPreference` resolves after
+ * mount, so N keys are N first-paint transitions while one read settles the
+ * whole palette at once.
+ *
+ * A record group is deliberately left alone: its options are records, whose ids
+ * are primary keys, so remembering them would build a list of which records this
+ * person opened inside a UI preference. Only commands and destinations are
+ * ranked.
+ */ export function useCommandRecency() {
+    const { value, setValue } = useUiPreference(RECENCY_PREF_KEY, {});
+    const rank = useCallback((group)=>{
+        if (group.key.startsWith('record:')) return group;
+        const options = [
+            ...group.options
+        ].sort((left, right)=>{
+            var _value_right_id, _value_left_id;
+            return ((_value_right_id = value[right.id]) != null ? _value_right_id : 0) - ((_value_left_id = value[left.id]) != null ? _value_left_id : 0);
+        });
+        return _extends({}, group, {
+            options
+        });
+    }, [
+        value
+    ]);
+    const remember = useCallback((id)=>{
+        const next = _extends({}, value, {
+            [id]: Date.now()
+        });
+        const kept = Object.entries(next).sort(([, left], [, right])=>right - left).slice(0, RECENCY_LIMIT);
+        setValue(Object.fromEntries(kept));
+    }, [
+        value,
+        setValue
+    ]);
+    return useMemo(()=>({
+            rank,
+            remember
+        }), [
+        rank,
+        remember
+    ]);
+}
+
+//# sourceMappingURL=use-command-recency.js.map

package/dist/lib/command-palette/use-command-recency.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/command-palette/use-command-recency.ts"],"sourcesContent":["'use client';\n\nimport type { CommandGroup } from '@entifix/core';\nimport { useUiPreference } from '@entifix/react-controls';\nimport { useCallback, useMemo } from 'react';\n\n/** `namespace:` is prepended by the store → `entifix-ui:back-office:command-recency`. */\nconst RECENCY_PREF_KEY = 'back-office:command-recency';\n\n/**\n * How many commands are remembered.\n *\n * A cap rather than an unbounded map: the store writes the whole record on every\n * run, and a record that only ever grows is a preference that gets slower for\n * the rest of the person's account life. Twenty is far more than the number of\n * commands anyone reaches for.\n */\nconst RECENCY_LIMIT = 20;\n\nexport interface CommandRecency {\n  /** Reorder a group's options, most recently used first. */\n  readonly rank: (group: CommandGroup) => CommandGroup;\n  /** Remember that this command was just run. */\n  readonly remember: (id: string) => void;\n}\n\n/**\n * Which commands this person reaches for, and in what order to offer them.\n *\n * **Recency reorders within a group and never across groups.** Group order is\n * the ranking (ADR 0040), and it is fixed precisely so an operator learns where\n * a kind of result lands; letting use move a whole group would take that away\n * for a convenience nobody asked for. Inside a group there is no such contract,\n * so the last thing you ran comes first.\n *\n * Stored as **one keyed record**, not a key per command — the same reasoning\n * `back-office:nav-collapsed-groups` records: `useUiPreference` resolves after\n * mount, so N keys are N first-paint transitions while one read settles the\n * whole palette at once.\n *\n * A record group is deliberately left alone: its options are records, whose ids\n * are primary keys, so remembering them would build a list of which records this\n * person opened inside a UI preference. Only commands and destinations are\n * ranked.\n */\nexport function useCommandRecency(): CommandRecency {\n  const { value, setValue } = useUiPreference<Record<string, number>>(\n    RECENCY_PREF_KEY,\n    {},\n  );\n\n  const rank = useCallback(\n    (group: CommandGroup): CommandGroup => {\n      if (group.key.startsWith('record:')) return group;\n\n      const options = [...group.options].sort(\n        (left, right) => (value[right.id] ?? 0) - (value[left.id] ?? 0),\n      );\n      return { ...group, options };\n    },\n    [value],\n  );\n\n  const remember = useCallback(\n    (id: string) => {\n      const next = { ...value, [id]: Date.now() };\n      const kept = Object.entries(next)\n        .sort(([, left], [, right]) => right - left)\n        .slice(0, RECENCY_LIMIT);\n      setValue(Object.fromEntries(kept));\n    },\n    [value, setValue],\n  );\n\n  return useMemo(() => ({ rank, remember }), [rank, remember]);\n}\n"],"names":["useUiPreference","useCallback","useMemo","RECENCY_PREF_KEY","RECENCY_LIMIT","useCommandRecency","value","setValue","rank","group","key","startsWith","options","sort","left","right","id","remember","next","Date","now","kept","Object","entries","slice","fromEntries"],"mappings":"AAAA;;AAGA,SAASA,eAAe,QAAQ,0BAA0B;AAC1D,SAASC,WAAW,EAAEC,OAAO,QAAQ,QAAQ;AAE7C,uFAAuF,GACvF,MAAMC,mBAAmB;AAEzB;;;;;;;CAOC,GACD,MAAMC,gBAAgB;AAStB;;;;;;;;;;;;;;;;;;CAkBC,GACD,OAAO,SAASC;IACd,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAGP,gBAC1BG,kBACA,CAAC;IAGH,MAAMK,OAAOP,YACX,CAACQ;QACC,IAAIA,MAAMC,GAAG,CAACC,UAAU,CAAC,YAAY,OAAOF;QAE5C,MAAMG,UAAU;eAAIH,MAAMG,OAAO;SAAC,CAACC,IAAI,CACrC,CAACC,MAAMC;gBAAWT,iBAAyBA;mBAA1B,EAACA,kBAAAA,KAAK,CAACS,MAAMC,EAAE,CAAC,YAAfV,kBAAmB,OAAMA,iBAAAA,KAAK,CAACQ,KAAKE,EAAE,CAAC,YAAdV,iBAAkB;;QAE/D,OAAO,aAAKG;YAAOG;;IACrB,GACA;QAACN;KAAM;IAGT,MAAMW,WAAWhB,YACf,CAACe;QACC,MAAME,OAAO,aAAKZ;YAAO,CAACU,GAAG,EAAEG,KAAKC,GAAG;;QACvC,MAAMC,OAAOC,OAAOC,OAAO,CAACL,MACzBL,IAAI,CAAC,CAAC,GAAGC,KAAK,EAAE,GAAGC,MAAM,GAAKA,QAAQD,MACtCU,KAAK,CAAC,GAAGpB;QACZG,SAASe,OAAOG,WAAW,CAACJ;IAC9B,GACA;QAACf;QAAOC;KAAS;IAGnB,OAAOL,QAAQ,IAAO,CAAA;YAAEM;YAAMS;QAAS,CAAA,GAAI;QAACT;QAAMS;KAAS;AAC7D"}

package/dist/lib/command-palette/use-command-source.d.ts

@@ -0,0 +1,17 @@
+import { type CommandSource } from '@entifix/core';
+import type { PaletteCommand } from './palette-command.js';
+/**
+ * The deterministic commands — "Nuevo producto", "Nuevo usuario" — as one group.
+ *
+ * **This hook filters; the palette does not.** Every source in the palette
+ * arrives pre-filtered, because the record source is filtered by the service
+ * that answered it and a component that filtered again would have to know which
+ * groups were already narrowed.
+ *
+ * Commands declared on a sub-page do not appear at the root. What appears there
+ * instead is one entry that descends into the page, which is what makes the
+ * palette's first screen a short list of *kinds* of thing rather than one row
+ * per creatable entity competing with the destinations beside them.
+ */
+export declare function useCommandSource(commands: readonly PaletteCommand[], term: string, page: string | undefined): CommandSource;
+//# sourceMappingURL=use-command-source.d.ts.map

package/dist/lib/command-palette/use-command-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-command-source.d.ts","sourceRoot":"","sources":["../../../src/lib/command-palette/use-command-source.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,aAAa,EAEnB,MAAM,eAAe,CAAC;AAKvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,SAAS,cAAc,EAAE,EACnC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GAAG,SAAS,GACvB,aAAa,CAyCf"}

package/dist/lib/command-palette/use-command-source.js

@@ -0,0 +1,70 @@
+'use client';
+import { NEW_COMMAND_PAGE } from '@entifix/authz';
+import { matchesCommand } from '@entifix/core';
+import { useT } from '@entifix/react-controls';
+import { useMemo } from 'react';
+import { useLocaleHref } from '../i18n/index.js';
+/**
+ * The deterministic commands — "Nuevo producto", "Nuevo usuario" — as one group.
+ *
+ * **This hook filters; the palette does not.** Every source in the palette
+ * arrives pre-filtered, because the record source is filtered by the service
+ * that answered it and a component that filtered again would have to know which
+ * groups were already narrowed.
+ *
+ * Commands declared on a sub-page do not appear at the root. What appears there
+ * instead is one entry that descends into the page, which is what makes the
+ * palette's first screen a short list of *kinds* of thing rather than one row
+ * per creatable entity competing with the destinations beside them.
+ */ export function useCommandSource(commands, term, page) {
+    const t = useT('shell');
+    const withLocale = useLocaleHref();
+    return useMemo(()=>{
+        const onThisPage = commands.filter((command)=>{
+            var _command_page;
+            return ((_command_page = command.page) != null ? _command_page : undefined) === page;
+        });
+        const options = onThisPage.map((command)=>({
+                id: command.key,
+                label: command.label,
+                keywords: command.keywords,
+                href: withLocale(command.href)
+            }));
+        // The root gains the entry that opens the create page — synthesized rather
+        // than declared, because no shell can know whether *another* shell also
+        // contributed a create command, and two shells each declaring the opener
+        // would render it twice.
+        if (page === undefined && commands.some((c)=>c.page === NEW_COMMAND_PAGE)) {
+            options.unshift({
+                id: 'palette:new',
+                label: t('commandPalette.newLabel'),
+                keywords: [
+                    'new',
+                    'create',
+                    'nuevo',
+                    'crear'
+                ],
+                push: NEW_COMMAND_PAGE
+            });
+        }
+        return {
+            key: 'commands',
+            groups: [
+                {
+                    key: 'commands',
+                    label: t('commandPalette.groups.commands'),
+                    options: options.filter((option)=>matchesCommand(term, option)),
+                    isLoading: false
+                }
+            ]
+        };
+    }, [
+        commands,
+        page,
+        term,
+        t,
+        withLocale
+    ]);
+}
+
+//# sourceMappingURL=use-command-source.js.map

package/dist/lib/command-palette/use-command-source.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/command-palette/use-command-source.ts"],"sourcesContent":["'use client';\n\nimport { NEW_COMMAND_PAGE } from '@entifix/authz';\nimport {\n  type CommandOption,\n  type CommandSource,\n  matchesCommand,\n} from '@entifix/core';\nimport { useT } from '@entifix/react-controls';\nimport { useMemo } from 'react';\n\nimport { useLocaleHref } from '../i18n/index.js';\nimport type { PaletteCommand } from './palette-command.js';\n\n/**\n * The deterministic commands — \"Nuevo producto\", \"Nuevo usuario\" — as one group.\n *\n * **This hook filters; the palette does not.** Every source in the palette\n * arrives pre-filtered, because the record source is filtered by the service\n * that answered it and a component that filtered again would have to know which\n * groups were already narrowed.\n *\n * Commands declared on a sub-page do not appear at the root. What appears there\n * instead is one entry that descends into the page, which is what makes the\n * palette's first screen a short list of *kinds* of thing rather than one row\n * per creatable entity competing with the destinations beside them.\n */\nexport function useCommandSource(\n  commands: readonly PaletteCommand[],\n  term: string,\n  page: string | undefined,\n): CommandSource {\n  const t = useT('shell');\n  const withLocale = useLocaleHref();\n\n  return useMemo(() => {\n    const onThisPage = commands.filter(\n      command => (command.page ?? undefined) === page,\n    );\n\n    const options: CommandOption[] = onThisPage.map(command => ({\n      id: command.key,\n      label: command.label,\n      keywords: command.keywords,\n      href: withLocale(command.href),\n    }));\n\n    // The root gains the entry that opens the create page — synthesized rather\n    // than declared, because no shell can know whether *another* shell also\n    // contributed a create command, and two shells each declaring the opener\n    // would render it twice.\n    if (page === undefined && commands.some(c => c.page === NEW_COMMAND_PAGE)) {\n      options.unshift({\n        id: 'palette:new',\n        label: t('commandPalette.newLabel'),\n        keywords: ['new', 'create', 'nuevo', 'crear'],\n        push: NEW_COMMAND_PAGE,\n      });\n    }\n\n    return {\n      key: 'commands',\n      groups: [\n        {\n          key: 'commands',\n          label: t('commandPalette.groups.commands'),\n          options: options.filter(option => matchesCommand(term, option)),\n          isLoading: false,\n        },\n      ],\n    } satisfies CommandSource;\n  }, [commands, page, term, t, withLocale]);\n}\n"],"names":["NEW_COMMAND_PAGE","matchesCommand","useT","useMemo","useLocaleHref","useCommandSource","commands","term","page","t","withLocale","onThisPage","filter","command","undefined","options","map","id","key","label","keywords","href","some","c","unshift","push","groups","option","isLoading"],"mappings":"AAAA;AAEA,SAASA,gBAAgB,QAAQ,iBAAiB;AAClD,SAGEC,cAAc,QACT,gBAAgB;AACvB,SAASC,IAAI,QAAQ,0BAA0B;AAC/C,SAASC,OAAO,QAAQ,QAAQ;AAEhC,SAASC,aAAa,QAAQ,mBAAmB;AAGjD;;;;;;;;;;;;CAYC,GACD,OAAO,SAASC,iBACdC,QAAmC,EACnCC,IAAY,EACZC,IAAwB;IAExB,MAAMC,IAAIP,KAAK;IACf,MAAMQ,aAAaN;IAEnB,OAAOD,QAAQ;QACb,MAAMQ,aAAaL,SAASM,MAAM,CAChCC,CAAAA;gBAAYA;mBAAD,EAACA,gBAAAA,QAAQL,IAAI,YAAZK,gBAAgBC,eAAeN;;QAG7C,MAAMO,UAA2BJ,WAAWK,GAAG,CAACH,CAAAA,UAAY,CAAA;gBAC1DI,IAAIJ,QAAQK,GAAG;gBACfC,OAAON,QAAQM,KAAK;gBACpBC,UAAUP,QAAQO,QAAQ;gBAC1BC,MAAMX,WAAWG,QAAQQ,IAAI;YAC/B,CAAA;QAEA,2EAA2E;QAC3E,wEAAwE;QACxE,yEAAyE;QACzE,yBAAyB;QACzB,IAAIb,SAASM,aAAaR,SAASgB,IAAI,CAACC,CAAAA,IAAKA,EAAEf,IAAI,KAAKR,mBAAmB;YACzEe,QAAQS,OAAO,CAAC;gBACdP,IAAI;gBACJE,OAAOV,EAAE;gBACTW,UAAU;oBAAC;oBAAO;oBAAU;oBAAS;iBAAQ;gBAC7CK,MAAMzB;YACR;QACF;QAEA,OAAO;YACLkB,KAAK;YACLQ,QAAQ;gBACN;oBACER,KAAK;oBACLC,OAAOV,EAAE;oBACTM,SAASA,QAAQH,MAAM,CAACe,CAAAA,SAAU1B,eAAeM,MAAMoB;oBACvDC,WAAW;gBACb;aACD;QACH;IACF,GAAG;QAACtB;QAAUE;QAAMD;QAAME;QAAGC;KAAW;AAC1C"}

package/dist/lib/command-palette/use-nav-source.d.ts

@@ -0,0 +1,21 @@
+import { type CommandSource } from '@entifix/core';
+import type { NavSection } from '../back-office/nav.js';
+/**
+ * Every destination this caller may reach, as one group.
+ *
+ * The nav is already the answer to "what may this person see": `visibleNav`
+ * applies both of ADR 0037's ceilings server-side, and what reaches here is the
+ * resolved, filtered tree the sidebar renders. So the palette holds no second
+ * projection of navigation — the thing ADR 0037 deleted `GET /api/menu` for.
+ *
+ * A destination that can also be a workspace tab contributes a **second**
+ * option rather than a modifier on the first. The palette runs on Enter and has
+ * no place to hang "hold ⌥ to open as a tab", and a hidden modifier is exactly
+ * the undiscoverable affordance the sidebar's own workspace link was fixed for.
+ *
+ * The section's screen type is the option's hint, so Definiciones and
+ * Operaciones stay distinguishable in a flat list — the sidebar's top tier
+ * (ADR 0033) surviving the flattening rather than being dropped by it.
+ */
+export declare function useNavSource(sections: readonly NavSection[], term: string): CommandSource;
+//# sourceMappingURL=use-nav-source.d.ts.map

package/dist/lib/command-palette/use-nav-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-nav-source.d.ts","sourceRoot":"","sources":["../../../src/lib/command-palette/use-nav-source.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,aAAa,EAEnB,MAAM,eAAe,CAAC;AAIvB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAOxD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,SAAS,UAAU,EAAE,EAC/B,IAAI,EAAE,MAAM,GACX,aAAa,CAkDf"}

package/dist/lib/command-palette/use-nav-source.js

@@ -0,0 +1,78 @@
+'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { SCREEN_TYPE_LABEL_KEYS } from '@entifix/authz';
+import { matchesCommand } from '@entifix/core';
+import { useT, useTranslateKey } from '@entifix/react-controls';
+import { useMemo } from 'react';
+import { useLocaleHref } from '../i18n/index.js';
+/** The workspace deep link a nav item's `workspace` address resolves to. */ const workspaceHref = (workspace)=>`/workspace?tab=${encodeURIComponent(workspace)}`;
+/**
+ * Every destination this caller may reach, as one group.
+ *
+ * The nav is already the answer to "what may this person see": `visibleNav`
+ * applies both of ADR 0037's ceilings server-side, and what reaches here is the
+ * resolved, filtered tree the sidebar renders. So the palette holds no second
+ * projection of navigation — the thing ADR 0037 deleted `GET /api/menu` for.
+ *
+ * A destination that can also be a workspace tab contributes a **second**
+ * option rather than a modifier on the first. The palette runs on Enter and has
+ * no place to hang "hold ⌥ to open as a tab", and a hidden modifier is exactly
+ * the undiscoverable affordance the sidebar's own workspace link was fixed for.
+ *
+ * The section's screen type is the option's hint, so Definiciones and
+ * Operaciones stay distinguishable in a flat list — the sidebar's top tier
+ * (ADR 0033) surviving the flattening rather than being dropped by it.
+ */ export function useNavSource(sections, term) {
+    const t = useT('shell');
+    const translateKey = useTranslateKey();
+    const withLocale = useLocaleHref();
+    return useMemo(()=>{
+        const options = [];
+        for (const section of sections){
+            // Only the screen type. Falling back to the section title here read as
+            // "Perfil · Cuenta · Cuenta" on the untyped account section, because the
+            // title is already the sublabel — one fact, printed twice.
+            const hint = section.type === undefined ? undefined : translateKey(SCREEN_TYPE_LABEL_KEYS[section.type]);
+            for (const item of section.items){
+                options.push(_extends({
+                    id: `nav:${item.href}`,
+                    label: item.label,
+                    href: withLocale(item.href)
+                }, hint === undefined ? {} : {
+                    hint
+                }, section.title === undefined ? {} : {
+                    sublabel: section.title
+                }));
+                if (item.workspace !== undefined) {
+                    options.push(_extends({
+                        id: `nav:workspace:${item.workspace}`,
+                        label: item.label,
+                        href: withLocale(workspaceHref(item.workspace)),
+                        hint: t('commandPalette.openInWorkspaceHint')
+                    }, section.title === undefined ? {} : {
+                        sublabel: section.title
+                    }));
+                }
+            }
+        }
+        return {
+            key: 'navigation',
+            groups: [
+                {
+                    key: 'navigation',
+                    label: t('commandPalette.groups.navigation'),
+                    options: options.filter((option)=>matchesCommand(term, option)),
+                    isLoading: false
+                }
+            ]
+        };
+    }, [
+        sections,
+        term,
+        t,
+        translateKey,
+        withLocale
+    ]);
+}
+
+//# sourceMappingURL=use-nav-source.js.map

package/dist/lib/command-palette/use-nav-source.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/command-palette/use-nav-source.ts"],"sourcesContent":["'use client';\n\nimport { SCREEN_TYPE_LABEL_KEYS } from '@entifix/authz';\nimport {\n  type CommandOption,\n  type CommandSource,\n  matchesCommand,\n} from '@entifix/core';\nimport { useT, useTranslateKey } from '@entifix/react-controls';\nimport { useMemo } from 'react';\n\nimport type { NavSection } from '../back-office/nav.js';\nimport { useLocaleHref } from '../i18n/index.js';\n\n/** The workspace deep link a nav item's `workspace` address resolves to. */\nconst workspaceHref = (workspace: string) =>\n  `/workspace?tab=${encodeURIComponent(workspace)}`;\n\n/**\n * Every destination this caller may reach, as one group.\n *\n * The nav is already the answer to \"what may this person see\": `visibleNav`\n * applies both of ADR 0037's ceilings server-side, and what reaches here is the\n * resolved, filtered tree the sidebar renders. So the palette holds no second\n * projection of navigation — the thing ADR 0037 deleted `GET /api/menu` for.\n *\n * A destination that can also be a workspace tab contributes a **second**\n * option rather than a modifier on the first. The palette runs on Enter and has\n * no place to hang \"hold ⌥ to open as a tab\", and a hidden modifier is exactly\n * the undiscoverable affordance the sidebar's own workspace link was fixed for.\n *\n * The section's screen type is the option's hint, so Definiciones and\n * Operaciones stay distinguishable in a flat list — the sidebar's top tier\n * (ADR 0033) surviving the flattening rather than being dropped by it.\n */\nexport function useNavSource(\n  sections: readonly NavSection[],\n  term: string,\n): CommandSource {\n  const t = useT('shell');\n  const translateKey = useTranslateKey();\n  const withLocale = useLocaleHref();\n\n  return useMemo(() => {\n    const options: CommandOption[] = [];\n\n    for (const section of sections) {\n      // Only the screen type. Falling back to the section title here read as\n      // \"Perfil · Cuenta · Cuenta\" on the untyped account section, because the\n      // title is already the sublabel — one fact, printed twice.\n      const hint =\n        section.type === undefined\n          ? undefined\n          : translateKey(SCREEN_TYPE_LABEL_KEYS[section.type]);\n\n      for (const item of section.items) {\n        options.push({\n          id: `nav:${item.href}`,\n          label: item.label,\n          href: withLocale(item.href),\n          ...(hint === undefined ? {} : { hint }),\n          ...(section.title === undefined ? {} : { sublabel: section.title }),\n        });\n\n        if (item.workspace !== undefined) {\n          options.push({\n            id: `nav:workspace:${item.workspace}`,\n            label: item.label,\n            href: withLocale(workspaceHref(item.workspace)),\n            hint: t('commandPalette.openInWorkspaceHint'),\n            ...(section.title === undefined ? {} : { sublabel: section.title }),\n          });\n        }\n      }\n    }\n\n    return {\n      key: 'navigation',\n      groups: [\n        {\n          key: 'navigation',\n          label: t('commandPalette.groups.navigation'),\n          options: options.filter(option => matchesCommand(term, option)),\n          isLoading: false,\n        },\n      ],\n    } satisfies CommandSource;\n  }, [sections, term, t, translateKey, withLocale]);\n}\n"],"names":["SCREEN_TYPE_LABEL_KEYS","matchesCommand","useT","useTranslateKey","useMemo","useLocaleHref","workspaceHref","workspace","encodeURIComponent","useNavSource","sections","term","t","translateKey","withLocale","options","section","hint","type","undefined","item","items","push","id","href","label","title","sublabel","key","groups","filter","option","isLoading"],"mappings":"AAAA;;AAEA,SAASA,sBAAsB,QAAQ,iBAAiB;AACxD,SAGEC,cAAc,QACT,gBAAgB;AACvB,SAASC,IAAI,EAAEC,eAAe,QAAQ,0BAA0B;AAChE,SAASC,OAAO,QAAQ,QAAQ;AAGhC,SAASC,aAAa,QAAQ,mBAAmB;AAEjD,0EAA0E,GAC1E,MAAMC,gBAAgB,CAACC,YACrB,CAAC,eAAe,EAAEC,mBAAmBD,YAAY;AAEnD;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,SAASE,aACdC,QAA+B,EAC/BC,IAAY;IAEZ,MAAMC,IAAIV,KAAK;IACf,MAAMW,eAAeV;IACrB,MAAMW,aAAaT;IAEnB,OAAOD,QAAQ;QACb,MAAMW,UAA2B,EAAE;QAEnC,KAAK,MAAMC,WAAWN,SAAU;YAC9B,uEAAuE;YACvE,yEAAyE;YACzE,2DAA2D;YAC3D,MAAMO,OACJD,QAAQE,IAAI,KAAKC,YACbA,YACAN,aAAab,sBAAsB,CAACgB,QAAQE,IAAI,CAAC;YAEvD,KAAK,MAAME,QAAQJ,QAAQK,KAAK,CAAE;gBAChCN,QAAQO,IAAI,CAAC;oBACXC,IAAI,CAAC,IAAI,EAAEH,KAAKI,IAAI,EAAE;oBACtBC,OAAOL,KAAKK,KAAK;oBACjBD,MAAMV,WAAWM,KAAKI,IAAI;mBACtBP,SAASE,YAAY,CAAC,IAAI;oBAAEF;gBAAK,GACjCD,QAAQU,KAAK,KAAKP,YAAY,CAAC,IAAI;oBAAEQ,UAAUX,QAAQU,KAAK;gBAAC;gBAGnE,IAAIN,KAAKb,SAAS,KAAKY,WAAW;oBAChCJ,QAAQO,IAAI,CAAC;wBACXC,IAAI,CAAC,cAAc,EAAEH,KAAKb,SAAS,EAAE;wBACrCkB,OAAOL,KAAKK,KAAK;wBACjBD,MAAMV,WAAWR,cAAcc,KAAKb,SAAS;wBAC7CU,MAAML,EAAE;uBACJI,QAAQU,KAAK,KAAKP,YAAY,CAAC,IAAI;wBAAEQ,UAAUX,QAAQU,KAAK;oBAAC;gBAErE;YACF;QACF;QAEA,OAAO;YACLE,KAAK;YACLC,QAAQ;gBACN;oBACED,KAAK;oBACLH,OAAOb,EAAE;oBACTG,SAASA,QAAQe,MAAM,CAACC,CAAAA,SAAU9B,eAAeU,MAAMoB;oBACvDC,WAAW;gBACb;aACD;QACH;IACF,GAAG;QAACtB;QAAUC;QAAMC;QAAGC;QAAcC;KAAW;AAClD"}

package/dist/lib/command-palette/use-records-source.d.ts

@@ -0,0 +1,23 @@
+import type { CommandSource } from '@entifix/core';
+/**
+ * Records matching the term, one group per source, in the order the host
+ * declared them.
+ *
+ * The whole of the *keystroke* policy lives here rather than in `searchRecords`,
+ * which is deliberately a bare typed `fetch`: the palette is the thing that
+ * knows a keystroke is not a query. So this owns the debounce, the abort and the
+ * two-character floor, while the route owns the fan-out, the per-source timeout
+ * and the authorization.
+ *
+ * **No index, ever.** Every option here came back from `/api/search` for this
+ * principal and this organization, on this keystroke. A prefetched client index
+ * is the shape that surfaces another organization's record the first time a
+ * session's scope moves under it, and ADR 0040 forecloses it permanently.
+ *
+ * Below the two-character floor the group is present and **says why** rather
+ * than being empty or absent: empty would claim nothing matched a search that
+ * never ran, and absent would leave someone wondering whether records are
+ * searchable here at all.
+ */
+export declare function useRecordsSource(term: string, enabled: boolean): CommandSource;
+//# sourceMappingURL=use-records-source.d.ts.map

package/dist/lib/command-palette/use-records-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-records-source.d.ts","sourceRoot":"","sources":["../../../src/lib/command-palette/use-records-source.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,aAAa,EAEd,MAAM,eAAe,CAAC;AA8CvB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,OAAO,GACf,aAAa,CAgJf"}

package/dist/lib/command-palette/use-records-source.js

@@ -0,0 +1,199 @@
+'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { useT, useTranslateKey } from '@entifix/react-controls';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { useLocaleHref } from '../i18n/index.js';
+import { searchRecords } from '../search/search-records.js';
+import { RECORD_SEARCH_DEBOUNCE_MS, RECORD_SEARCH_MIN_TERM } from './palette-command.js';
+/**
+ * Which reasons are the caller's ordinary state, and which mean something broke.
+ *
+ * The split is ADR 0040's, restated as severity because that is what the palette
+ * renders. An operator holds no membership, so every tenant-plane source answers
+ * `409` on every keystroke — painting that as an outage teaches them to ignore
+ * the row entirely, and then the `timeout` that does matter goes unread too.
+ */ const SEVERITY = {
+    forbidden: 'scope',
+    noActiveOrganization: 'scope',
+    unauthenticated: 'scope',
+    timeout: 'reachability',
+    network: 'reachability',
+    invalidQuery: 'reachability',
+    notFound: 'reachability',
+    unexpected: 'reachability'
+};
+const NOTHING_YET = {
+    term: '',
+    failed: false
+};
+/**
+ * Records matching the term, one group per source, in the order the host
+ * declared them.
+ *
+ * The whole of the *keystroke* policy lives here rather than in `searchRecords`,
+ * which is deliberately a bare typed `fetch`: the palette is the thing that
+ * knows a keystroke is not a query. So this owns the debounce, the abort and the
+ * two-character floor, while the route owns the fan-out, the per-source timeout
+ * and the authorization.
+ *
+ * **No index, ever.** Every option here came back from `/api/search` for this
+ * principal and this organization, on this keystroke. A prefetched client index
+ * is the shape that surfaces another organization's record the first time a
+ * session's scope moves under it, and ADR 0040 forecloses it permanently.
+ *
+ * Below the two-character floor the group is present and **says why** rather
+ * than being empty or absent: empty would claim nothing matched a search that
+ * never ran, and absent would leave someone wondering whether records are
+ * searchable here at all.
+ */ export function useRecordsSource(term, enabled) {
+    const t = useT('shell');
+    const translateKey = useTranslateKey();
+    const withLocale = useLocaleHref();
+    const [state, setState] = useState(NOTHING_YET);
+    // The term the request in flight is for. A ref, not state: it changes on every
+    // keystroke and nothing renders from it.
+    const pending = useRef(null);
+    const active = enabled && term.length >= RECORD_SEARCH_MIN_TERM;
+    useEffect(()=>{
+        // Nothing is cleared here on purpose. A `setState` in an effect body is a
+        // cascading render, and there is nothing to clear: the memo below returns no
+        // groups while inactive, so a previous answer is unreachable rather than
+        // stale — and the host empties the term when it opens the palette.
+        if (!active) {
+            pending.current = null;
+            return;
+        }
+        const controller = new AbortController();
+        pending.current = term;
+        const timer = setTimeout(()=>{
+            void searchRecords(term, {
+                signal: controller.signal
+            }).then((response)=>{
+                if (pending.current !== term) return;
+                setState({
+                    term,
+                    response,
+                    failed: false
+                });
+            }).catch(()=>{
+                // An abort lands here too and must not be shown: the term moved on,
+                // so there is nothing to report about the request that did not finish.
+                if (controller.signal.aborted || pending.current !== term) return;
+                setState({
+                    term,
+                    failed: true
+                });
+            });
+        }, RECORD_SEARCH_DEBOUNCE_MS);
+        return ()=>{
+            clearTimeout(timer);
+            controller.abort();
+        };
+    }, [
+        active,
+        term
+    ]);
+    return useMemo(()=>{
+        const heading = t('commandPalette.groups.records');
+        if (!active) {
+            // Someone who has typed one character is mid-word, not looking at an
+            // answer. Saying so is better than both alternatives: an empty group would
+            // claim nothing matched a search that never ran, and an absent one would
+            // leave them wondering whether records are searchable at all.
+            if (!enabled || term.length === 0) return {
+                key: 'records',
+                groups: []
+            };
+            return {
+                key: 'records',
+                groups: [
+                    {
+                        key: 'records',
+                        label: heading,
+                        options: [],
+                        isLoading: false,
+                        unavailable: {
+                            message: t('commandPalette.typeMore', {
+                                count: RECORD_SEARCH_MIN_TERM
+                            }),
+                            severity: 'scope'
+                        }
+                    }
+                ]
+            };
+        }
+        // A newer term is in flight. The previous answer stays on screen with its
+        // groups marked loading rather than blanking: a list that empties between
+        // keystrokes flickers, and the rows it drops were correct a moment ago.
+        const isLoading = state.term !== term;
+        if (state.response === undefined) {
+            return {
+                key: 'records',
+                groups: [
+                    _extends({
+                        key: 'records',
+                        label: heading,
+                        options: [],
+                        isLoading: !state.failed
+                    }, state.failed ? {
+                        unavailable: {
+                            message: t('commandPalette.unavailableReach', {
+                                reason: translateKey('errors:unexpected')
+                            }),
+                            severity: 'reachability'
+                        }
+                    } : {})
+                ]
+            };
+        }
+        const groups = state.response.groups.map((group)=>({
+                key: `record:${group.source}`,
+                // The entity's own `pluralKey`, so record search introduces no copy of
+                // its own and a group is titled exactly as its screen is.
+                label: translateKey(group.labelKey),
+                options: group.items.map((item)=>_extends({
+                        id: `record:${group.source}:${item.id}`,
+                        label: item.label
+                    }, item.sublabel === undefined ? {} : {
+                        sublabel: item.sublabel
+                    }, {
+                        href: withLocale(item.href)
+                    })),
+                total: group.total,
+                isLoading
+            }));
+        for (const degraded of state.response.unavailable){
+            const severity = SEVERITY[degraded.reason];
+            groups.push({
+                key: `record:${degraded.source}`,
+                // Derived from the entity rather than from the source key, which is an
+                // identifier and would render as `product-specification`. Every
+                // searchable entity declares a `pluralKey` — `catalogSurface` throws
+                // without one — so this always resolves.
+                label: translateKey(`entity:${degraded.entity}.plural`),
+                options: [],
+                isLoading: false,
+                unavailable: {
+                    message: t(severity === 'scope' ? 'commandPalette.unavailableScope' : 'commandPalette.unavailableReach', {
+                        reason: translateKey(`errors:${degraded.reason}`)
+                    }),
+                    severity
+                }
+            });
+        }
+        return {
+            key: 'records',
+            groups
+        };
+    }, [
+        active,
+        enabled,
+        state,
+        term,
+        t,
+        translateKey,
+        withLocale
+    ]);
+}
+
+//# sourceMappingURL=use-records-source.js.map

package/dist/lib/command-palette/use-records-source.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/command-palette/use-records-source.ts"],"sourcesContent":["'use client';\n\nimport type {\n  CommandGroup,\n  CommandSource,\n  CommandUnavailableSeverity,\n} from '@entifix/core';\nimport { useT, useTranslateKey } from '@entifix/react-controls';\nimport { useEffect, useMemo, useRef, useState } from 'react';\n\nimport { useLocaleHref } from '../i18n/index.js';\nimport type {\n  RecordSearchResponse,\n  RecordSearchUnavailableReason,\n} from '../search/record-search.types.js';\nimport { searchRecords } from '../search/search-records.js';\nimport {\n  RECORD_SEARCH_DEBOUNCE_MS,\n  RECORD_SEARCH_MIN_TERM,\n} from './palette-command.js';\n\n/**\n * Which reasons are the caller's ordinary state, and which mean something broke.\n *\n * The split is ADR 0040's, restated as severity because that is what the palette\n * renders. An operator holds no membership, so every tenant-plane source answers\n * `409` on every keystroke — painting that as an outage teaches them to ignore\n * the row entirely, and then the `timeout` that does matter goes unread too.\n */\nconst SEVERITY: Readonly<\n  Record<RecordSearchUnavailableReason, CommandUnavailableSeverity>\n> = {\n  forbidden: 'scope',\n  noActiveOrganization: 'scope',\n  unauthenticated: 'scope',\n  timeout: 'reachability',\n  network: 'reachability',\n  invalidQuery: 'reachability',\n  notFound: 'reachability',\n  unexpected: 'reachability',\n};\n\n/** What the browser is currently showing for records. */\ninterface RecordsState {\n  /** The term this answer is for, so a stale response cannot overwrite a newer one. */\n  readonly term: string;\n  readonly response?: RecordSearchResponse;\n  readonly failed: boolean;\n}\n\nconst NOTHING_YET: RecordsState = { term: '', failed: false };\n\n/**\n * Records matching the term, one group per source, in the order the host\n * declared them.\n *\n * The whole of the *keystroke* policy lives here rather than in `searchRecords`,\n * which is deliberately a bare typed `fetch`: the palette is the thing that\n * knows a keystroke is not a query. So this owns the debounce, the abort and the\n * two-character floor, while the route owns the fan-out, the per-source timeout\n * and the authorization.\n *\n * **No index, ever.** Every option here came back from `/api/search` for this\n * principal and this organization, on this keystroke. A prefetched client index\n * is the shape that surfaces another organization's record the first time a\n * session's scope moves under it, and ADR 0040 forecloses it permanently.\n *\n * Below the two-character floor the group is present and **says why** rather\n * than being empty or absent: empty would claim nothing matched a search that\n * never ran, and absent would leave someone wondering whether records are\n * searchable here at all.\n */\nexport function useRecordsSource(\n  term: string,\n  enabled: boolean,\n): CommandSource {\n  const t = useT('shell');\n  const translateKey = useTranslateKey();\n  const withLocale = useLocaleHref();\n\n  const [state, setState] = useState<RecordsState>(NOTHING_YET);\n  // The term the request in flight is for. A ref, not state: it changes on every\n  // keystroke and nothing renders from it.\n  const pending = useRef<string | null>(null);\n\n  const active = enabled && term.length >= RECORD_SEARCH_MIN_TERM;\n\n  useEffect(() => {\n    // Nothing is cleared here on purpose. A `setState` in an effect body is a\n    // cascading render, and there is nothing to clear: the memo below returns no\n    // groups while inactive, so a previous answer is unreachable rather than\n    // stale — and the host empties the term when it opens the palette.\n    if (!active) {\n      pending.current = null;\n      return;\n    }\n\n    const controller = new AbortController();\n    pending.current = term;\n\n    const timer = setTimeout(() => {\n      void searchRecords(term, { signal: controller.signal })\n        .then(response => {\n          if (pending.current !== term) return;\n          setState({ term, response, failed: false });\n        })\n        .catch(() => {\n          // An abort lands here too and must not be shown: the term moved on,\n          // so there is nothing to report about the request that did not finish.\n          if (controller.signal.aborted || pending.current !== term) return;\n          setState({ term, failed: true });\n        });\n    }, RECORD_SEARCH_DEBOUNCE_MS);\n\n    return () => {\n      clearTimeout(timer);\n      controller.abort();\n    };\n  }, [active, term]);\n\n  return useMemo(() => {\n    const heading = t('commandPalette.groups.records');\n\n    if (!active) {\n      // Someone who has typed one character is mid-word, not looking at an\n      // answer. Saying so is better than both alternatives: an empty group would\n      // claim nothing matched a search that never ran, and an absent one would\n      // leave them wondering whether records are searchable at all.\n      if (!enabled || term.length === 0) return { key: 'records', groups: [] };\n      return {\n        key: 'records',\n        groups: [\n          {\n            key: 'records',\n            label: heading,\n            options: [],\n            isLoading: false,\n            unavailable: {\n              message: t('commandPalette.typeMore', {\n                count: RECORD_SEARCH_MIN_TERM,\n              }),\n              severity: 'scope',\n            },\n          },\n        ],\n      };\n    }\n    // A newer term is in flight. The previous answer stays on screen with its\n    // groups marked loading rather than blanking: a list that empties between\n    // keystrokes flickers, and the rows it drops were correct a moment ago.\n    const isLoading = state.term !== term;\n\n    if (state.response === undefined) {\n      return {\n        key: 'records',\n        groups: [\n          {\n            key: 'records',\n            label: heading,\n            options: [],\n            isLoading: !state.failed,\n            // The whole endpoint failed — a lapsed session or a `400`, both of\n            // which arrive as a rejection rather than inside a `200`. It is\n            // named for the same reason a single degraded source is.\n            ...(state.failed\n              ? {\n                  unavailable: {\n                    message: t('commandPalette.unavailableReach', {\n                      reason: translateKey('errors:unexpected'),\n                    }),\n                    severity: 'reachability' as const,\n                  },\n                }\n              : {}),\n          },\n        ],\n      };\n    }\n\n    const groups: CommandGroup[] = state.response.groups.map(group => ({\n      key: `record:${group.source}`,\n      // The entity's own `pluralKey`, so record search introduces no copy of\n      // its own and a group is titled exactly as its screen is.\n      label: translateKey(group.labelKey),\n      options: group.items.map(item => ({\n        id: `record:${group.source}:${item.id}`,\n        label: item.label,\n        ...(item.sublabel === undefined ? {} : { sublabel: item.sublabel }),\n        href: withLocale(item.href),\n      })),\n      total: group.total,\n      isLoading,\n    }));\n\n    for (const degraded of state.response.unavailable) {\n      const severity = SEVERITY[degraded.reason];\n      groups.push({\n        key: `record:${degraded.source}`,\n        // Derived from the entity rather than from the source key, which is an\n        // identifier and would render as `product-specification`. Every\n        // searchable entity declares a `pluralKey` — `catalogSurface` throws\n        // without one — so this always resolves.\n        label: translateKey(`entity:${degraded.entity}.plural`),\n        options: [],\n        isLoading: false,\n        unavailable: {\n          message: t(\n            severity === 'scope'\n              ? 'commandPalette.unavailableScope'\n              : 'commandPalette.unavailableReach',\n            { reason: translateKey(`errors:${degraded.reason}`) },\n          ),\n          severity,\n        },\n      });\n    }\n\n    return { key: 'records', groups };\n  }, [active, enabled, state, term, t, translateKey, withLocale]);\n}\n"],"names":["useT","useTranslateKey","useEffect","useMemo","useRef","useState","useLocaleHref","searchRecords","RECORD_SEARCH_DEBOUNCE_MS","RECORD_SEARCH_MIN_TERM","SEVERITY","forbidden","noActiveOrganization","unauthenticated","timeout","network","invalidQuery","notFound","unexpected","NOTHING_YET","term","failed","useRecordsSource","enabled","t","translateKey","withLocale","state","setState","pending","active","length","current","controller","AbortController","timer","setTimeout","signal","then","response","catch","aborted","clearTimeout","abort","heading","key","groups","label","options","isLoading","unavailable","message","count","severity","undefined","reason","map","group","source","labelKey","items","item","id","sublabel","href","total","degraded","push","entity"],"mappings":"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"}