@entifix/core 0.1.0-0

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

@@ -0,0 +1,116 @@
+import { EntifixLogicError } from '../base-entities/entifix-error/index.js';
+/**
+ * Normalize a string for matching: case-folded, and with accents removed.
+ *
+ * ⚠️ The accent fold is correctness, not polish. The fleet ships Spanish as its
+ * default locale, and without it `categoria` does not match `Categoría`, `marron`
+ * does not match `Marrón`, and `articulo` does not match `Artículo` — so the
+ * palette silently finds nothing for the most natural way to type most of its
+ * own copy. Nobody reaches for the accented key in a search box.
+ *
+ * NFD splits a precomposed letter into its base plus a combining mark, and the
+ * `\p{Diacritic}` class is what then removes only the mark. `ñ` decomposes too,
+ * so `nino` matches `Niño` — which is what a person typing quickly wants, even
+ * though ñ is a letter of its own in Spanish rather than an accented n.
+ */ export function foldForMatch(text) {
+    return text.normalize('NFD').replace(RegExp("[\\u005E\\u0060\\u00A8\\u00AF\\u00B4\\u00B7-\\u00B8\\u02B0-\\u034E\\u0350-\\u0357\\u035D-\\u0362\\u0374-\\u0375\\u037A\\u0384-\\u0385\\u0483-\\u0487\\u0559\\u0591-\\u05BD\\u05BF\\u05C1-\\u05C2\\u05C4-\\u05C5\\u05C7\\u064B-\\u0652\\u0657-\\u0658\\u06DF-\\u06E0\\u06E5-\\u06E6\\u06EA-\\u06EC\\u0730-\\u074A\\u07A6-\\u07B0\\u07EB-\\u07F5\\u0818-\\u0819\\u0898-\\u089F\\u08C9-\\u08D2\\u08E3-\\u08FE\\u093C\\u094D\\u0951-\\u0954\\u0971\\u09BC\\u09CD\\u0A3C\\u0A4D\\u0ABC\\u0ACD\\u0AFD-\\u0AFF\\u0B3C\\u0B4D\\u0B55\\u0BCD\\u0C3C\\u0C4D\\u0CBC\\u0CCD\\u0D3B-\\u0D3C\\u0D4D\\u0DCA\\u0E3A\\u0E47-\\u0E4C\\u0E4E\\u0EBA\\u0EC8-\\u0ECC\\u0F18-\\u0F19\\u0F35\\u0F37\\u0F39\\u0F3E-\\u0F3F\\u0F82-\\u0F84\\u0F86-\\u0F87\\u0FC6\\u1037\\u1039-\\u103A\\u1063-\\u1064\\u1069-\\u106D\\u1087-\\u108D\\u108F\\u109A-\\u109B\\u135D-\\u135F\\u1714-\\u1715\\u1734\\u17C9-\\u17D3\\u17DD\\u1939-\\u193B\\u1A60\\u1A75-\\u1A7C\\u1A7F\\u1AB0-\\u1ABE\\u1AC1-\\u1ACB\\u1ACF-\\u1ADD\\u1AE0-\\u1AEB\\u1B34\\u1B44\\u1B6B-\\u1B73\\u1BAA-\\u1BAB\\u1BE6\\u1BF2-\\u1BF3\\u1C36-\\u1C37\\u1C78-\\u1C7D\\u1CD0-\\u1CE8\\u1CED\\u1CF4\\u1CF7-\\u1CF9\\u1D2C-\\u1D6A\\u1D9B-\\u1DBE\\u1DC4-\\u1DCF\\u1DF5-\\u1DFF\\u1FBD\\u1FBF-\\u1FC1\\u1FCD-\\u1FCF\\u1FDD-\\u1FDF\\u1FED-\\u1FEF\\u1FFD-\\u1FFE\\u2CEF-\\u2CF1\\u2E2F\\u302A-\\u302F\\u3099-\\u309C\\u30FC\\uA66F\\uA67C-\\uA67D\\uA67F\\uA69C-\\uA69D\\uA6F0-\\uA6F1\\uA700-\\uA721\\uA788-\\uA78A\\uA7F1\\uA7F8-\\uA7F9\\uA806\\uA82C\\uA8C4\\uA8E0-\\uA8F1\\uA92B-\\uA92E\\uA953\\uA9B3\\uA9C0\\uA9E5\\uAA7B-\\uAA7D\\uAABF-\\uAAC2\\uAAF6\\uAB5B-\\uAB5F\\uAB69-\\uAB6B\\uABEC-\\uABED\\uFB1E\\uFE20-\\uFE2F\\uFF3E\\uFF40\\uFF70\\uFF9E-\\uFF9F\\uFFE3\\u{102E0}\\u{10780}-\\u{10785}\\u{10787}-\\u{107B0}\\u{107B2}-\\u{107BA}\\u{10A38}-\\u{10A3A}\\u{10A3F}\\u{10AE5}-\\u{10AE6}\\u{10D22}-\\u{10D27}\\u{10D4E}\\u{10D69}-\\u{10D6D}\\u{10EFA}\\u{10EFD}-\\u{10EFF}\\u{10F46}-\\u{10F50}\\u{10F82}-\\u{10F85}\\u{11046}\\u{11070}\\u{110B9}-\\u{110BA}\\u{11133}-\\u{11134}\\u{11173}\\u{111C0}\\u{111CA}-\\u{111CC}\\u{11235}-\\u{11236}\\u{112E9}-\\u{112EA}\\u{1133B}-\\u{1133C}\\u{1134D}\\u{11366}-\\u{1136C}\\u{11370}-\\u{11374}\\u{113CE}-\\u{113D0}\\u{113D2}-\\u{113D3}\\u{113E1}-\\u{113E2}\\u{11442}\\u{11446}\\u{114C2}-\\u{114C3}\\u{115BF}-\\u{115C0}\\u{1163F}\\u{116B6}-\\u{116B7}\\u{1172B}\\u{11839}-\\u{1183A}\\u{1193D}-\\u{1193E}\\u{11943}\\u{119E0}\\u{11A34}\\u{11A47}\\u{11A99}\\u{11C3F}\\u{11D42}\\u{11D44}-\\u{11D45}\\u{11D97}\\u{11DD9}\\u{11F41}-\\u{11F42}\\u{11F5A}\\u{13447}-\\u{13455}\\u{1612F}\\u{16AF0}-\\u{16AF4}\\u{16B30}-\\u{16B36}\\u{16D6B}-\\u{16D6C}\\u{16F8F}-\\u{16F9F}\\u{16FF0}-\\u{16FF1}\\u{1AFF0}-\\u{1AFF3}\\u{1AFF5}-\\u{1AFFB}\\u{1AFFD}-\\u{1AFFE}\\u{1CF00}-\\u{1CF2D}\\u{1CF30}-\\u{1CF46}\\u{1D167}-\\u{1D169}\\u{1D16D}-\\u{1D172}\\u{1D17B}-\\u{1D182}\\u{1D185}-\\u{1D18B}\\u{1D1AA}-\\u{1D1AD}\\u{1E030}-\\u{1E06D}\\u{1E130}-\\u{1E136}\\u{1E2AE}\\u{1E2EC}-\\u{1E2EF}\\u{1E5EE}-\\u{1E5EF}\\u{1E8D0}-\\u{1E8D6}\\u{1E944}-\\u{1E946}\\u{1E948}-\\u{1E94A}]", "gu"), '').toLocaleLowerCase();
+}
+/**
+ * Does `text` contain every character of `term`, in order?
+ *
+ * Subsequence rather than substring, so `prbr` finds "Producto Bruto" and `numa`
+ * finds "Nueva marca" — the thing that makes a palette feel fast. Deliberately
+ * **not** scored: ADR 0040 fixed group order as the ranking, and a score inside
+ * a group would reshuffle it on every keystroke for no gain a person can learn.
+ *
+ * An empty term matches everything, which is what makes an unfiltered palette
+ * the same code path as a filtered one.
+ */ export function subsequenceMatch(term, text) {
+    const needle = foldForMatch(term);
+    if (needle === '') return true;
+    const haystack = foldForMatch(text);
+    let cursor = 0;
+    for (const character of haystack){
+        if (character === needle[cursor]) cursor += 1;
+        if (cursor === needle.length) return true;
+    }
+    return false;
+}
+/**
+ * Does this option answer to `term`, by its label or by any of its keywords?
+ *
+ * The keywords are what let a Spanish command match an English word someone
+ * typed — "Nuevo producto" answering to `new` — without translating the label.
+ */ export function matchesCommand(term, option) {
+    var _option_keywords;
+    if (subsequenceMatch(term, option.label)) return true;
+    return ((_option_keywords = option.keywords) != null ? _option_keywords : []).some((keyword)=>subsequenceMatch(term, keyword));
+}
+/**
+ * Split a catalog-resolved keyword list into terms.
+ *
+ * `MetaUseCase.keywordsKey` is a catalog **key** rather than a `string[]` so the
+ * terms are per-locale; what the catalog holds is therefore one string, and this
+ * is the convention for reading it. Commas, because a keyword may itself be two
+ * words ("cerrar sesión") and splitting on whitespace would break that into
+ * terms that match nothing on their own.
+ *
+ * Empty entries are dropped rather than kept as `''`, which would match every
+ * option through {@link subsequenceMatch}'s empty-term rule.
+ */ export function parseKeywords(value) {
+    if (value === undefined) return [];
+    return value.split(',').map((keyword)=>keyword.trim()).filter((keyword)=>keyword !== '');
+}
+/**
+ * `>` narrows to commands, `#` to records, anything else searches both.
+ *
+ * A grammar for *entry* rather than for depth: descending into a sub-picker is a
+ * page stack, not a third prefix, because a prefix a person has to remember is
+ * worse than a list they can see. Two characters only, and both are the ones
+ * VS Code and GitHub already trained people on.
+ *
+ * The prefix is stripped and the remainder trimmed at the front only — a
+ * trailing space is something the person is still typing, and eating it would
+ * make the list jump between keystrokes.
+ */ export function parseCommandTerm(raw) {
+    if (raw.startsWith('>')) {
+        return {
+            scope: 'commands',
+            term: raw.slice(1).trimStart()
+        };
+    }
+    if (raw.startsWith('#')) {
+        return {
+            scope: 'records',
+            term: raw.slice(1).trimStart()
+        };
+    }
+    return {
+        scope: 'all',
+        term: raw
+    };
+}
+/**
+ * The one thing selecting an option does.
+ *
+ * An option declaring none is a line that looks selectable and does nothing;
+ * one declaring two is a line whose behaviour depends on the order a renderer
+ * happens to check its members in. Both are silent, so this throws — at the
+ * first render of the palette rather than on the click, which is the posture
+ * `surfaceFor` and `assertSearchable` already take for the same reason.
+ */ export function commandEffectOf(option) {
+    const declared = [
+        'href',
+        'run',
+        'push'
+    ].filter((effect)=>option[effect] !== undefined);
+    if (declared.length !== 1) {
+        throw new EntifixLogicError(`The command "${option.id}" declares ${declared.length} effects (${declared.join(', ') || 'none'}), and must declare exactly one. ` + 'Give it an `href` to navigate, a `run` to invoke, or a `push` to open another page.', undefined, {
+            id: option.id,
+            declared
+        });
+    }
+    return declared[0];
+}
+
+//# sourceMappingURL=command-matching.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/command-palette/command-matching.ts"],"sourcesContent":["import { EntifixLogicError } from '../base-entities/entifix-error/index.js';\nimport type { CommandOption } from './command-source.js';\n\n/**\n * Normalize a string for matching: case-folded, and with accents removed.\n *\n * ⚠️ The accent fold is correctness, not polish. The fleet ships Spanish as its\n * default locale, and without it `categoria` does not match `Categoría`, `marron`\n * does not match `Marrón`, and `articulo` does not match `Artículo` — so the\n * palette silently finds nothing for the most natural way to type most of its\n * own copy. Nobody reaches for the accented key in a search box.\n *\n * NFD splits a precomposed letter into its base plus a combining mark, and the\n * `\\p{Diacritic}` class is what then removes only the mark. `ñ` decomposes too,\n * so `nino` matches `Niño` — which is what a person typing quickly wants, even\n * though ñ is a letter of its own in Spanish rather than an accented n.\n */\nexport function foldForMatch(text: string): string {\n  return text\n    .normalize('NFD')\n    .replace(/\\p{Diacritic}/gu, '')\n    .toLocaleLowerCase();\n}\n\n/**\n * Does `text` contain every character of `term`, in order?\n *\n * Subsequence rather than substring, so `prbr` finds \"Producto Bruto\" and `numa`\n * finds \"Nueva marca\" — the thing that makes a palette feel fast. Deliberately\n * **not** scored: ADR 0040 fixed group order as the ranking, and a score inside\n * a group would reshuffle it on every keystroke for no gain a person can learn.\n *\n * An empty term matches everything, which is what makes an unfiltered palette\n * the same code path as a filtered one.\n */\nexport function subsequenceMatch(term: string, text: string): boolean {\n  const needle = foldForMatch(term);\n  if (needle === '') return true;\n\n  const haystack = foldForMatch(text);\n  let cursor = 0;\n  for (const character of haystack) {\n    if (character === needle[cursor]) cursor += 1;\n    if (cursor === needle.length) return true;\n  }\n  return false;\n}\n\n/**\n * Does this option answer to `term`, by its label or by any of its keywords?\n *\n * The keywords are what let a Spanish command match an English word someone\n * typed — \"Nuevo producto\" answering to `new` — without translating the label.\n */\nexport function matchesCommand(term: string, option: CommandOption): boolean {\n  if (subsequenceMatch(term, option.label)) return true;\n  return (option.keywords ?? []).some(keyword =>\n    subsequenceMatch(term, keyword),\n  );\n}\n\n/**\n * Split a catalog-resolved keyword list into terms.\n *\n * `MetaUseCase.keywordsKey` is a catalog **key** rather than a `string[]` so the\n * terms are per-locale; what the catalog holds is therefore one string, and this\n * is the convention for reading it. Commas, because a keyword may itself be two\n * words (\"cerrar sesión\") and splitting on whitespace would break that into\n * terms that match nothing on their own.\n *\n * Empty entries are dropped rather than kept as `''`, which would match every\n * option through {@link subsequenceMatch}'s empty-term rule.\n */\nexport function parseKeywords(value: string | undefined): string[] {\n  if (value === undefined) return [];\n  return value\n    .split(',')\n    .map(keyword => keyword.trim())\n    .filter(keyword => keyword !== '');\n}\n\n/** Which sources a typed term is asking for. */\nexport type CommandScope = 'all' | 'commands' | 'records';\n\n/** A term, split into the scope its prefix asked for and the rest. */\nexport interface ParsedCommandTerm {\n  readonly scope: CommandScope;\n  readonly term: string;\n}\n\n/**\n * `>` narrows to commands, `#` to records, anything else searches both.\n *\n * A grammar for *entry* rather than for depth: descending into a sub-picker is a\n * page stack, not a third prefix, because a prefix a person has to remember is\n * worse than a list they can see. Two characters only, and both are the ones\n * VS Code and GitHub already trained people on.\n *\n * The prefix is stripped and the remainder trimmed at the front only — a\n * trailing space is something the person is still typing, and eating it would\n * make the list jump between keystrokes.\n */\nexport function parseCommandTerm(raw: string): ParsedCommandTerm {\n  if (raw.startsWith('>')) {\n    return { scope: 'commands', term: raw.slice(1).trimStart() };\n  }\n  if (raw.startsWith('#')) {\n    return { scope: 'records', term: raw.slice(1).trimStart() };\n  }\n  return { scope: 'all', term: raw };\n}\n\n/**\n * The one thing selecting an option does.\n *\n * An option declaring none is a line that looks selectable and does nothing;\n * one declaring two is a line whose behaviour depends on the order a renderer\n * happens to check its members in. Both are silent, so this throws — at the\n * first render of the palette rather than on the click, which is the posture\n * `surfaceFor` and `assertSearchable` already take for the same reason.\n */\nexport function commandEffectOf(\n  option: CommandOption,\n): 'href' | 'run' | 'push' {\n  const declared = (['href', 'run', 'push'] as const).filter(\n    effect => option[effect] !== undefined,\n  );\n\n  if (declared.length !== 1) {\n    throw new EntifixLogicError(\n      `The command \"${option.id}\" declares ${declared.length} effects (${declared.join(', ') || 'none'}), and must declare exactly one. ` +\n        'Give it an `href` to navigate, a `run` to invoke, or a `push` to open another page.',\n      undefined,\n      { id: option.id, declared },\n    );\n  }\n\n  return declared[0];\n}\n"],"names":["EntifixLogicError","foldForMatch","text","normalize","replace","toLocaleLowerCase","subsequenceMatch","term","needle","haystack","cursor","character","length","matchesCommand","option","label","keywords","some","keyword","parseKeywords","value","undefined","split","map","trim","filter","parseCommandTerm","raw","startsWith","scope","slice","trimStart","commandEffectOf","declared","effect","id","join"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,0CAA0C;AAG5E;;;;;;;;;;;;;CAaC,GACD,OAAO,SAASC,aAAaC,IAAY;IACvC,OAAOA,KACJC,SAAS,CAAC,OACVC,OAAO,CAAC,q6FAAmB,IAC3BC,iBAAiB;AACtB;AAEA;;;;;;;;;;CAUC,GACD,OAAO,SAASC,iBAAiBC,IAAY,EAAEL,IAAY;IACzD,MAAMM,SAASP,aAAaM;IAC5B,IAAIC,WAAW,IAAI,OAAO;IAE1B,MAAMC,WAAWR,aAAaC;IAC9B,IAAIQ,SAAS;IACb,KAAK,MAAMC,aAAaF,SAAU;QAChC,IAAIE,cAAcH,MAAM,CAACE,OAAO,EAAEA,UAAU;QAC5C,IAAIA,WAAWF,OAAOI,MAAM,EAAE,OAAO;IACvC;IACA,OAAO;AACT;AAEA;;;;;CAKC,GACD,OAAO,SAASC,eAAeN,IAAY,EAAEO,MAAqB;QAExDA;IADR,IAAIR,iBAAiBC,MAAMO,OAAOC,KAAK,GAAG,OAAO;IACjD,OAAO,EAACD,mBAAAA,OAAOE,QAAQ,YAAfF,mBAAmB,EAAE,EAAEG,IAAI,CAACC,CAAAA,UAClCZ,iBAAiBC,MAAMW;AAE3B;AAEA;;;;;;;;;;;CAWC,GACD,OAAO,SAASC,cAAcC,KAAyB;IACrD,IAAIA,UAAUC,WAAW,OAAO,EAAE;IAClC,OAAOD,MACJE,KAAK,CAAC,KACNC,GAAG,CAACL,CAAAA,UAAWA,QAAQM,IAAI,IAC3BC,MAAM,CAACP,CAAAA,UAAWA,YAAY;AACnC;AAWA;;;;;;;;;;;CAWC,GACD,OAAO,SAASQ,iBAAiBC,GAAW;IAC1C,IAAIA,IAAIC,UAAU,CAAC,MAAM;QACvB,OAAO;YAAEC,OAAO;YAAYtB,MAAMoB,IAAIG,KAAK,CAAC,GAAGC,SAAS;QAAG;IAC7D;IACA,IAAIJ,IAAIC,UAAU,CAAC,MAAM;QACvB,OAAO;YAAEC,OAAO;YAAWtB,MAAMoB,IAAIG,KAAK,CAAC,GAAGC,SAAS;QAAG;IAC5D;IACA,OAAO;QAAEF,OAAO;QAAOtB,MAAMoB;IAAI;AACnC;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASK,gBACdlB,MAAqB;IAErB,MAAMmB,WAAW,AAAC;QAAC;QAAQ;QAAO;KAAO,CAAWR,MAAM,CACxDS,CAAAA,SAAUpB,MAAM,CAACoB,OAAO,KAAKb;IAG/B,IAAIY,SAASrB,MAAM,KAAK,GAAG;QACzB,MAAM,IAAIZ,kBACR,CAAC,aAAa,EAAEc,OAAOqB,EAAE,CAAC,WAAW,EAAEF,SAASrB,MAAM,CAAC,UAAU,EAAEqB,SAASG,IAAI,CAAC,SAAS,OAAO,iCAAiC,CAAC,GACjI,uFACFf,WACA;YAAEc,IAAIrB,OAAOqB,EAAE;YAAEF;QAAS;IAE9B;IAEA,OAAOA,QAAQ,CAAC,EAAE;AACpB"}

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

@@ -0,0 +1,109 @@
+/**
+ * What a command palette renders, as state rather than as a query.
+ *
+ * The same contract `EntityLinkSource` is, and for the same boundary reason: the
+ * hooks that fetch live in the shell layer, the component that renders lives in
+ * `@entifix/react-controls`, and those two may not import each other. It carries
+ * no Effect, no React and no router — a source hands over resolved copy and a
+ * thunk, never a key and never a `push()`.
+ */
+/** How a group's absence is explained. */
+export type CommandUnavailableSeverity = 'scope' | 'reachability';
+/**
+ * A source that produced no options, and why.
+ *
+ * The two severities must not be conflated, which is the same split ADR 0040's
+ * `RecordSearchUnavailableReason` draws and the reason this member is not a
+ * bare string. `scope` is the **normal** state for some callers — an operator
+ * holds no membership, so every tenant-plane search answers `409` on every
+ * keystroke — while `reachability` means something is actually wrong. Rendering
+ * a warning for the ordinary case teaches people to ignore the one that matters.
+ */
+export interface CommandUnavailable {
+    /** Already-resolved copy. The source owns the catalog lookup. */
+    readonly message: string;
+    readonly severity: CommandUnavailableSeverity;
+}
+/** What selecting an option does. Exactly one arm is populated. */
+export interface CommandEffect {
+    /**
+     * Navigate. **Already locale-prefixed** by the source, because the palette is
+     * presentational and a control may not reach for a router or a locale.
+     */
+    readonly href?: string;
+    /** Invoke. The source owns the request, the optimism and the error. */
+    readonly run?: () => void | Promise<void>;
+    /** Descend into another {@link CommandPage} by id — this is the page stack. */
+    readonly push?: string;
+}
+/** Ask before running. Resolved copy, like everything else that crosses here. */
+export interface CommandConfirm {
+    readonly tone: 'destructive' | 'neutral';
+    readonly message: string;
+}
+/** One selectable line. */
+export interface CommandOption extends CommandEffect {
+    /** Unique within the whole palette — it is also the recency key. */
+    readonly id: string;
+    /** Resolved copy. A source that holds a catalog key resolves it before here. */
+    readonly label: string;
+    /** A second line: a code, a role, the record's entity. */
+    readonly sublabel?: string;
+    /**
+     * Extra terms this option matches on, so a Spanish command still answers to
+     * the English word someone typed. Raycast's mechanism, and the reason
+     * `MetaUseCase` carries a `keywordsKey` at all.
+     */
+    readonly keywords?: readonly string[];
+    /** Trailing text — a shortcut hint, the source's own name. */
+    readonly hint?: string;
+    readonly confirm?: CommandConfirm;
+}
+/** One heading and the options under it. */
+export interface CommandGroup {
+    readonly key: string;
+    /** Resolved copy. */
+    readonly label: string;
+    readonly options: readonly CommandOption[];
+    /**
+     * Matches **before** any per-group limit, so "N más" is renderable. Omitted
+     * when the source did not count — never defaulted to `options.length`, which
+     * would claim there is no more when nobody looked.
+     */
+    readonly total?: number;
+    readonly isLoading: boolean;
+    /**
+     * Set when this group could not be produced. A group carrying this is still
+     * rendered: an omitted group reads as "nothing matched", which is a confident
+     * claim nobody is in a position to make about a source they could not reach.
+     */
+    readonly unavailable?: CommandUnavailable;
+}
+/**
+ * One contributor's whole answer.
+ *
+ * Several groups, not one, because the record search fans out over four entities
+ * and each is its own heading — flattening them here would make the palette
+ * re-derive what ADR 0040 already grouped.
+ */
+export interface CommandSource {
+    readonly key: string;
+    readonly groups: readonly CommandGroup[];
+}
+/**
+ * One level of the palette.
+ *
+ * Depth is a **stack of pages** rather than nested prefixes: selecting "Nuevo…"
+ * makes the palette *become* the entity picker, which is Raycast's and Linear's
+ * arrangement and reads far better than a second grammar character.
+ */
+export interface CommandPage {
+    readonly id: string;
+    /** Shown as a chip beside the input on any page but the root. */
+    readonly title?: string;
+    readonly placeholder: string;
+    readonly sources: readonly CommandSource[];
+}
+/** The id of the page a palette opens on. */
+export declare const ROOT_COMMAND_PAGE = "root";
+//# sourceMappingURL=command-source.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"command-source.d.ts","sourceRoot":"","sources":["../../src/command-palette/command-source.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,0CAA0C;AAC1C,MAAM,MAAM,0BAA0B,GAAG,OAAO,GAAG,cAAc,CAAC;AAElE;;;;;;;;;GASG;AACH,MAAM,WAAW,kBAAkB;IACjC,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,0BAA0B,CAAC;CAC/C;AAED,mEAAmE;AACnE,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,uEAAuE;IACvE,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,CAAC;IACzC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,2BAA2B;AAC3B,MAAM,WAAW,aAAc,SAAQ,aAAa;IAClD,oEAAoE;IACpE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,0DAA0D;IAC1D,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC;CACnC;AAED,4CAA4C;AAC5C,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,qBAAqB;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,CAAC;IAC3C;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,kBAAkB,CAAC;CAC3C;AAED;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAC;CAC1C;AAED;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,iEAAiE;IACjE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,CAAC;CAC5C;AAED,6CAA6C;AAC7C,eAAO,MAAM,iBAAiB,SAAS,CAAC"}

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

@@ -0,0 +1,11 @@
+/**
+ * What a command palette renders, as state rather than as a query.
+ *
+ * The same contract `EntityLinkSource` is, and for the same boundary reason: the
+ * hooks that fetch live in the shell layer, the component that renders lives in
+ * `@entifix/react-controls`, and those two may not import each other. It carries
+ * no Effect, no React and no router — a source hands over resolved copy and a
+ * thunk, never a key and never a `push()`.
+ */ /** How a group's absence is explained. */ /** The id of the page a palette opens on. */ export const ROOT_COMMAND_PAGE = 'root';
+
+//# sourceMappingURL=command-source.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/command-palette/command-source.ts"],"sourcesContent":["/**\n * What a command palette renders, as state rather than as a query.\n *\n * The same contract `EntityLinkSource` is, and for the same boundary reason: the\n * hooks that fetch live in the shell layer, the component that renders lives in\n * `@entifix/react-controls`, and those two may not import each other. It carries\n * no Effect, no React and no router — a source hands over resolved copy and a\n * thunk, never a key and never a `push()`.\n */\n\n/** How a group's absence is explained. */\nexport type CommandUnavailableSeverity = 'scope' | 'reachability';\n\n/**\n * A source that produced no options, and why.\n *\n * The two severities must not be conflated, which is the same split ADR 0040's\n * `RecordSearchUnavailableReason` draws and the reason this member is not a\n * bare string. `scope` is the **normal** state for some callers — an operator\n * holds no membership, so every tenant-plane search answers `409` on every\n * keystroke — while `reachability` means something is actually wrong. Rendering\n * a warning for the ordinary case teaches people to ignore the one that matters.\n */\nexport interface CommandUnavailable {\n  /** Already-resolved copy. The source owns the catalog lookup. */\n  readonly message: string;\n  readonly severity: CommandUnavailableSeverity;\n}\n\n/** What selecting an option does. Exactly one arm is populated. */\nexport interface CommandEffect {\n  /**\n   * Navigate. **Already locale-prefixed** by the source, because the palette is\n   * presentational and a control may not reach for a router or a locale.\n   */\n  readonly href?: string;\n  /** Invoke. The source owns the request, the optimism and the error. */\n  readonly run?: () => void | Promise<void>;\n  /** Descend into another {@link CommandPage} by id — this is the page stack. */\n  readonly push?: string;\n}\n\n/** Ask before running. Resolved copy, like everything else that crosses here. */\nexport interface CommandConfirm {\n  readonly tone: 'destructive' | 'neutral';\n  readonly message: string;\n}\n\n/** One selectable line. */\nexport interface CommandOption extends CommandEffect {\n  /** Unique within the whole palette — it is also the recency key. */\n  readonly id: string;\n  /** Resolved copy. A source that holds a catalog key resolves it before here. */\n  readonly label: string;\n  /** A second line: a code, a role, the record's entity. */\n  readonly sublabel?: string;\n  /**\n   * Extra terms this option matches on, so a Spanish command still answers to\n   * the English word someone typed. Raycast's mechanism, and the reason\n   * `MetaUseCase` carries a `keywordsKey` at all.\n   */\n  readonly keywords?: readonly string[];\n  /** Trailing text — a shortcut hint, the source's own name. */\n  readonly hint?: string;\n  readonly confirm?: CommandConfirm;\n}\n\n/** One heading and the options under it. */\nexport interface CommandGroup {\n  readonly key: string;\n  /** Resolved copy. */\n  readonly label: string;\n  readonly options: readonly CommandOption[];\n  /**\n   * Matches **before** any per-group limit, so \"N más\" is renderable. Omitted\n   * when the source did not count — never defaulted to `options.length`, which\n   * would claim there is no more when nobody looked.\n   */\n  readonly total?: number;\n  readonly isLoading: boolean;\n  /**\n   * Set when this group could not be produced. A group carrying this is still\n   * rendered: an omitted group reads as \"nothing matched\", which is a confident\n   * claim nobody is in a position to make about a source they could not reach.\n   */\n  readonly unavailable?: CommandUnavailable;\n}\n\n/**\n * One contributor's whole answer.\n *\n * Several groups, not one, because the record search fans out over four entities\n * and each is its own heading — flattening them here would make the palette\n * re-derive what ADR 0040 already grouped.\n */\nexport interface CommandSource {\n  readonly key: string;\n  readonly groups: readonly CommandGroup[];\n}\n\n/**\n * One level of the palette.\n *\n * Depth is a **stack of pages** rather than nested prefixes: selecting \"Nuevo…\"\n * makes the palette *become* the entity picker, which is Raycast's and Linear's\n * arrangement and reads far better than a second grammar character.\n */\nexport interface CommandPage {\n  readonly id: string;\n  /** Shown as a chip beside the input on any page but the root. */\n  readonly title?: string;\n  readonly placeholder: string;\n  readonly sources: readonly CommandSource[];\n}\n\n/** The id of the page a palette opens on. */\nexport const ROOT_COMMAND_PAGE = 'root';\n"],"names":["ROOT_COMMAND_PAGE"],"mappings":"AAAA;;;;;;;;CAQC,GAED,wCAAwC,GAyGxC,2CAA2C,GAC3C,OAAO,MAAMA,oBAAoB,OAAO"}

package/dist/command-palette/index.d.ts

@@ -0,0 +1,3 @@
+export * from './command-matching.js';
+export * from './command-source.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/command-palette/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC"}

package/dist/command-palette/index.js

@@ -0,0 +1,4 @@
+export * from './command-matching.js';
+export * from './command-source.js';
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/command-palette/index.ts"],"sourcesContent":["export * from './command-matching.js';\nexport * from './command-source.js';\n"],"names":[],"mappings":"AAAA,cAAc,wBAAwB;AACtC,cAAc,sBAAsB"}

package/dist/entity-definition/decorators/accessor/accessor.d.ts

@@ -0,0 +1,3 @@
+import { MetaAccessorOptions } from '../../meta-entities/meta-accessor/index.js';
+export declare function accessor(options?: MetaAccessorOptions): (_value: unknown, context: ClassGetterDecoratorContext | ClassSetterDecoratorContext) => void;
+//# sourceMappingURL=accessor.d.ts.map

package/dist/entity-definition/decorators/accessor/accessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessor.d.ts","sourceRoot":"","sources":["../../../../src/entity-definition/decorators/accessor/accessor.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,mBAAmB,EACpB,MAAM,4CAA4C,CAAC;AAEpD,wBAAgB,QAAQ,CAAC,OAAO,CAAC,EAAE,mBAAmB,IAElD,QAAQ,OAAO,EACf,SAAS,2BAA2B,GAAG,2BAA2B,UAOrE"}

package/dist/entity-definition/decorators/accessor/accessor.js

@@ -0,0 +1,11 @@
+import { appendMetaAccessor } from '../../helpers/index.js';
+import { MetaAccessor } from '../../meta-entities/meta-accessor/index.js';
+export function accessor(options) {
+    return (_value, context)=>{
+        const kind = context.kind === 'getter' ? 'getter' : 'setter';
+        const meta = new MetaAccessor(context.name, kind, options);
+        appendMetaAccessor(context.metadata, meta);
+    };
+}
+
+//# sourceMappingURL=accessor.js.map

package/dist/entity-definition/decorators/accessor/accessor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/entity-definition/decorators/accessor/accessor.ts"],"sourcesContent":["import { appendMetaAccessor } from '../../helpers/index.js';\nimport {\n  MetaAccessor,\n  MetaAccessorKind,\n  MetaAccessorOptions,\n} from '../../meta-entities/meta-accessor/index.js';\n\nexport function accessor(options?: MetaAccessorOptions) {\n  return (\n    _value: unknown,\n    context: ClassGetterDecoratorContext | ClassSetterDecoratorContext,\n  ) => {\n    const kind: MetaAccessorKind =\n      context.kind === 'getter' ? 'getter' : 'setter';\n    const meta = new MetaAccessor(context.name, kind, options);\n    appendMetaAccessor(context.metadata, meta);\n  };\n}\n"],"names":["appendMetaAccessor","MetaAccessor","accessor","options","_value","context","kind","meta","name","metadata"],"mappings":"AAAA,SAASA,kBAAkB,QAAQ,yBAAyB;AAC5D,SACEC,YAAY,QAGP,6CAA6C;AAEpD,OAAO,SAASC,SAASC,OAA6B;IACpD,OAAO,CACLC,QACAC;QAEA,MAAMC,OACJD,QAAQC,IAAI,KAAK,WAAW,WAAW;QACzC,MAAMC,OAAO,IAAIN,aAAaI,QAAQG,IAAI,EAAEF,MAAMH;QAClDH,mBAAmBK,QAAQI,QAAQ,EAAEF;IACvC;AACF"}

package/dist/entity-definition/decorators/accessor/index.d.ts

@@ -0,0 +1,2 @@
+export * from './accessor.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/entity-definition/decorators/accessor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/entity-definition/decorators/accessor/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC"}

package/dist/entity-definition/decorators/accessor/index.js

@@ -0,0 +1,3 @@
+export * from './accessor.js';
+
+//# sourceMappingURL=index.js.map

package/dist/entity-definition/decorators/accessor/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/entity-definition/decorators/accessor/index.ts"],"sourcesContent":["export * from './accessor.js';\n"],"names":[],"mappings":"AAAA,cAAc,gBAAgB"}

package/dist/entity-definition/decorators/entity/entity.d.ts

@@ -0,0 +1,4 @@
+import type { Entity, EntityConstructor } from '../../../types/Entity.js';
+import { MetaEntityOptions } from '../../meta-entities/meta-entity/index.js';
+export declare function entity<TEntity extends Entity>(options?: MetaEntityOptions): (target: EntityConstructor<TEntity>, context: ClassDecoratorContext) => void;
+//# sourceMappingURL=entity.d.ts.map

package/dist/entity-definition/decorators/entity/entity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../../../../src/entity-definition/decorators/entity/entity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE1E,OAAO,EAEL,iBAAiB,EAClB,MAAM,0CAA0C,CAAC;AAElD,wBAAgB,MAAM,CAAC,OAAO,SAAS,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,IAEtE,QAAQ,iBAAiB,CAAC,OAAO,CAAC,EAClC,SAAS,qBAAqB,UAIjC"}

package/dist/entity-definition/decorators/entity/entity.js

@@ -0,0 +1,9 @@
+import { setMetaEntity } from '../../helpers/index.js';
+import { MetaEntity } from '../../meta-entities/meta-entity/index.js';
+export function entity(options) {
+    return (target, context)=>{
+        setMetaEntity(context.metadata, new MetaEntity(target.name, options));
+    };
+}
+
+//# sourceMappingURL=entity.js.map

package/dist/entity-definition/decorators/entity/entity.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/entity-definition/decorators/entity/entity.ts"],"sourcesContent":["import type { Entity, EntityConstructor } from '../../../types/Entity.js';\nimport { setMetaEntity } from '../../helpers/index.js';\nimport {\n  MetaEntity,\n  MetaEntityOptions,\n} from '../../meta-entities/meta-entity/index.js';\n\nexport function entity<TEntity extends Entity>(options?: MetaEntityOptions) {\n  return (\n    target: EntityConstructor<TEntity>,\n    context: ClassDecoratorContext,\n  ) => {\n    setMetaEntity(context.metadata, new MetaEntity(target.name, options));\n  };\n}\n"],"names":["setMetaEntity","MetaEntity","entity","options","target","context","metadata","name"],"mappings":"AACA,SAASA,aAAa,QAAQ,yBAAyB;AACvD,SACEC,UAAU,QAEL,2CAA2C;AAElD,OAAO,SAASC,OAA+BC,OAA2B;IACxE,OAAO,CACLC,QACAC;QAEAL,cAAcK,QAAQC,QAAQ,EAAE,IAAIL,WAAWG,OAAOG,IAAI,EAAEJ;IAC9D;AACF"}

package/dist/entity-definition/decorators/entity/index.d.ts

@@ -0,0 +1,2 @@
+export * from './entity.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/entity-definition/decorators/entity/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/entity-definition/decorators/entity/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/dist/entity-definition/decorators/entity/index.js

@@ -0,0 +1,3 @@
+export * from './entity.js';
+
+//# sourceMappingURL=index.js.map

package/dist/entity-definition/decorators/entity/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/entity-definition/decorators/entity/index.ts"],"sourcesContent":["export * from './entity.js';\n"],"names":[],"mappings":"AAAA,cAAc,cAAc"}

package/dist/entity-definition/decorators/method/index.d.ts

@@ -0,0 +1,2 @@
+export * from './method.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/entity-definition/decorators/method/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/entity-definition/decorators/method/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/dist/entity-definition/decorators/method/index.js

@@ -0,0 +1,3 @@
+export * from './method.js';
+
+//# sourceMappingURL=index.js.map

package/dist/entity-definition/decorators/method/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/entity-definition/decorators/method/index.ts"],"sourcesContent":["export * from './method.js';\n"],"names":[],"mappings":"AAAA,cAAc,cAAc"}

package/dist/entity-definition/decorators/method/method.d.ts

@@ -0,0 +1,3 @@
+import { MetaMethodOptions } from '../../meta-entities/meta-method/index.js';
+export declare function method(options?: MetaMethodOptions): (_value: (...args: unknown[]) => unknown, context: ClassMethodDecoratorContext) => void;
+//# sourceMappingURL=method.d.ts.map

package/dist/entity-definition/decorators/method/method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"method.d.ts","sourceRoot":"","sources":["../../../../src/entity-definition/decorators/method/method.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,iBAAiB,EAClB,MAAM,0CAA0C,CAAC;AAElD,wBAAgB,MAAM,CAAC,OAAO,CAAC,EAAE,iBAAiB,IAE9C,QAAQ,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,EACvC,SAAS,2BAA2B,UAKvC"}

package/dist/entity-definition/decorators/method/method.js

@@ -0,0 +1,10 @@
+import { appendMetaMethod } from '../../helpers/index.js';
+import { MetaMethod } from '../../meta-entities/meta-method/index.js';
+export function method(options) {
+    return (_value, context)=>{
+        const meta = new MetaMethod(context.name, options);
+        appendMetaMethod(context.metadata, meta);
+    };
+}
+
+//# sourceMappingURL=method.js.map

package/dist/entity-definition/decorators/method/method.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/entity-definition/decorators/method/method.ts"],"sourcesContent":["import { appendMetaMethod } from '../../helpers/index.js';\nimport {\n  MetaMethod,\n  MetaMethodOptions,\n} from '../../meta-entities/meta-method/index.js';\n\nexport function method(options?: MetaMethodOptions) {\n  return (\n    _value: (...args: unknown[]) => unknown,\n    context: ClassMethodDecoratorContext,\n  ) => {\n    const meta = new MetaMethod(context.name, options);\n    appendMetaMethod(context.metadata, meta);\n  };\n}\n"],"names":["appendMetaMethod","MetaMethod","method","options","_value","context","meta","name","metadata"],"mappings":"AAAA,SAASA,gBAAgB,QAAQ,yBAAyB;AAC1D,SACEC,UAAU,QAEL,2CAA2C;AAElD,OAAO,SAASC,OAAOC,OAA2B;IAChD,OAAO,CACLC,QACAC;QAEA,MAAMC,OAAO,IAAIL,WAAWI,QAAQE,IAAI,EAAEJ;QAC1CH,iBAAiBK,QAAQG,QAAQ,EAAEF;IACrC;AACF"}

package/dist/entity-definition/decorators/use-case/index.d.ts

@@ -0,0 +1,2 @@
+export * from './use-case.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/entity-definition/decorators/use-case/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/entity-definition/decorators/use-case/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC"}

package/dist/entity-definition/decorators/use-case/index.js

@@ -0,0 +1,3 @@
+export * from './use-case.js';
+
+//# sourceMappingURL=index.js.map

package/dist/entity-definition/decorators/use-case/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/entity-definition/decorators/use-case/index.ts"],"sourcesContent":["export * from './use-case.js';\n"],"names":[],"mappings":"AAAA,cAAc,gBAAgB"}

package/dist/entity-definition/decorators/use-case/use-case.d.ts

@@ -0,0 +1,18 @@
+import type { Entity } from '../../../types/Entity.js';
+import { MetaUseCaseOptions } from '../../meta-entities/meta-use-case/index.js';
+/**
+ * Declares a use case: a verb on an entity beyond the `read`/`write`/`delete`
+ * triple, with everything a surface needs to render it.
+ *
+ * It writes twice, and the two writes have different jobs. The descriptor is
+ * appended to the **entity's** metadata, because that is what a form, a table or
+ * the palette holds. The entity/verb pair is written to the **class's own**
+ * metadata, which is what lets `permissionForUseCase(SomeUC)` derive the
+ * permission from one argument.
+ *
+ * The `const` type parameter keeps `key` a literal at the declaration site.
+ * Write it inline — `@useCase({ ...DESCRIPTOR })` would compile and would make
+ * the source scan in `@r10c/slices` stop seeing the declaration.
+ */
+export declare function useCase<const TKey extends string, TEntity extends Entity>(options: MetaUseCaseOptions<TKey, TEntity>): (_target: unknown, context: ClassDecoratorContext) => void;
+//# sourceMappingURL=use-case.d.ts.map

package/dist/entity-definition/decorators/use-case/use-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-case.d.ts","sourceRoot":"","sources":["../../../../src/entity-definition/decorators/use-case/use-case.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAKvD,OAAO,EAEL,kBAAkB,EACnB,MAAM,4CAA4C,CAAC;AAEpD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,KAAK,CAAC,IAAI,SAAS,MAAM,EAAE,OAAO,SAAS,MAAM,EACvE,OAAO,EAAE,kBAAkB,CAAC,IAAI,EAAE,OAAO,CAAC,IAElC,SAAS,OAAO,EAAE,SAAS,qBAAqB,UAOzD"}

package/dist/entity-definition/decorators/use-case/use-case.js

@@ -0,0 +1,26 @@
+import { appendMetaUseCase, setMetaUseCaseBinding } from '../../helpers/index.js';
+import { MetaUseCase } from '../../meta-entities/meta-use-case/index.js';
+/**
+ * Declares a use case: a verb on an entity beyond the `read`/`write`/`delete`
+ * triple, with everything a surface needs to render it.
+ *
+ * It writes twice, and the two writes have different jobs. The descriptor is
+ * appended to the **entity's** metadata, because that is what a form, a table or
+ * the palette holds. The entity/verb pair is written to the **class's own**
+ * metadata, which is what lets `permissionForUseCase(SomeUC)` derive the
+ * permission from one argument.
+ *
+ * The `const` type parameter keeps `key` a literal at the declaration site.
+ * Write it inline — `@useCase({ ...DESCRIPTOR })` would compile and would make
+ * the source scan in `@r10c/slices` stop seeing the declaration.
+ */ export function useCase(options) {
+    return (_target, context)=>{
+        appendMetaUseCase(options.entity, new MetaUseCase(options));
+        setMetaUseCaseBinding(context.metadata, {
+            entity: options.entity,
+            key: options.key
+        });
+    };
+}
+
+//# sourceMappingURL=use-case.js.map

package/dist/entity-definition/decorators/use-case/use-case.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/entity-definition/decorators/use-case/use-case.ts"],"sourcesContent":["import type { Entity } from '../../../types/Entity.js';\nimport {\n  appendMetaUseCase,\n  setMetaUseCaseBinding,\n} from '../../helpers/index.js';\nimport {\n  MetaUseCase,\n  MetaUseCaseOptions,\n} from '../../meta-entities/meta-use-case/index.js';\n\n/**\n * Declares a use case: a verb on an entity beyond the `read`/`write`/`delete`\n * triple, with everything a surface needs to render it.\n *\n * It writes twice, and the two writes have different jobs. The descriptor is\n * appended to the **entity's** metadata, because that is what a form, a table or\n * the palette holds. The entity/verb pair is written to the **class's own**\n * metadata, which is what lets `permissionForUseCase(SomeUC)` derive the\n * permission from one argument.\n *\n * The `const` type parameter keeps `key` a literal at the declaration site.\n * Write it inline — `@useCase({ ...DESCRIPTOR })` would compile and would make\n * the source scan in `@r10c/slices` stop seeing the declaration.\n */\nexport function useCase<const TKey extends string, TEntity extends Entity>(\n  options: MetaUseCaseOptions<TKey, TEntity>,\n) {\n  return (_target: unknown, context: ClassDecoratorContext) => {\n    appendMetaUseCase(options.entity, new MetaUseCase(options));\n    setMetaUseCaseBinding(context.metadata, {\n      entity: options.entity,\n      key: options.key,\n    });\n  };\n}\n"],"names":["appendMetaUseCase","setMetaUseCaseBinding","MetaUseCase","useCase","options","_target","context","entity","metadata","key"],"mappings":"AACA,SACEA,iBAAiB,EACjBC,qBAAqB,QAChB,yBAAyB;AAChC,SACEC,WAAW,QAEN,6CAA6C;AAEpD;;;;;;;;;;;;;CAaC,GACD,OAAO,SAASC,QACdC,OAA0C;IAE1C,OAAO,CAACC,SAAkBC;QACxBN,kBAAkBI,QAAQG,MAAM,EAAE,IAAIL,YAAYE;QAClDH,sBAAsBK,QAAQE,QAAQ,EAAE;YACtCD,QAAQH,QAAQG,MAAM;YACtBE,KAAKL,QAAQK,GAAG;QAClB;IACF;AACF"}

package/dist/entity-definition/describe/describe-child-columns.d.ts

@@ -0,0 +1,33 @@
+import type { ChildConstructor } from '../meta-entities/meta-accessor/index.js';
+import { type EntityFieldDescriptor } from './describe-entity-columns.js';
+/**
+ * The columns of one row of an owned collection.
+ *
+ * Thin over {@link describeEntityColumns}, which already accepts a
+ * `ChildConstructor` — a child is described by its accessors and needs no
+ * `@entity()` ([ADR 0034](../../../../../../../docs/adr/0034-composition-metadata.md)).
+ * What this adds is the one rule a row has and an entity does not.
+ *
+ * **A child may not declare `$key`.** That name is the row's minted client
+ * identity, and a member of the same name would be overwritten by it — the row
+ * would re-key on every keystroke, drop focus mid-word, and address another
+ * row's errors. Throwing is the only honest option: silently renaming the
+ * member would write the wrong column, and preferring the member over the key
+ * would leave the grid with no identity at all.
+ *
+ * `EntifixBuildError` rather than a logic error, because this is a declaration
+ * fault in the entity — the same class `assertNotQueryable` raises when a
+ * collection claims to be sortable.
+ */
+export declare function describeChildColumns<TChild extends object>(childType: ChildConstructor<TChild>, sample?: TChild): EntityFieldDescriptor[];
+/**
+ * The columns a detail grid actually edits.
+ *
+ * A read-only member still has a column — it is shown, just not written, exactly
+ * as a form shows one. What is dropped is a **nested collection**: a child that
+ * owns rows of its own would need a grid inside a grid, and `reconstructChild`
+ * is one level deep by decision. Dropping it here rather than rendering a
+ * disabled cell keeps that decision in one place.
+ */
+export declare function editableChildColumns(descriptors: readonly EntityFieldDescriptor[]): EntityFieldDescriptor[];
+//# sourceMappingURL=describe-child-columns.d.ts.map

package/dist/entity-definition/describe/describe-child-columns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"describe-child-columns.d.ts","sourceRoot":"","sources":["../../../src/entity-definition/describe/describe-child-columns.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yCAAyC,CAAC;AAChF,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,8BAA8B,CAAC;AAEtC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,SAAS,MAAM,EACxD,SAAS,EAAE,gBAAgB,CAAC,MAAM,CAAC,EACnC,MAAM,CAAC,EAAE,MAAM,GACd,qBAAqB,EAAE,CAezB;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,SAAS,qBAAqB,EAAE,GAC5C,qBAAqB,EAAE,CAOzB"}

package/dist/entity-definition/describe/describe-child-columns.js

@@ -0,0 +1,44 @@
+import { EntifixBuildError } from '../../base-entities/entifix-error/index.js';
+import { ROW_KEY } from '../../types/EntityRowDraft.js';
+import { describeEntityColumns } from './describe-entity-columns.js';
+/**
+ * The columns of one row of an owned collection.
+ *
+ * Thin over {@link describeEntityColumns}, which already accepts a
+ * `ChildConstructor` — a child is described by its accessors and needs no
+ * `@entity()` ([ADR 0034](../../../../../../../docs/adr/0034-composition-metadata.md)).
+ * What this adds is the one rule a row has and an entity does not.
+ *
+ * **A child may not declare `$key`.** That name is the row's minted client
+ * identity, and a member of the same name would be overwritten by it — the row
+ * would re-key on every keystroke, drop focus mid-word, and address another
+ * row's errors. Throwing is the only honest option: silently renaming the
+ * member would write the wrong column, and preferring the member over the key
+ * would leave the grid with no identity at all.
+ *
+ * `EntifixBuildError` rather than a logic error, because this is a declaration
+ * fault in the entity — the same class `assertNotQueryable` raises when a
+ * collection claims to be sortable.
+ */ export function describeChildColumns(childType, sample) {
+    const descriptors = describeEntityColumns(childType, sample);
+    const reserved = descriptors.find((descriptor)=>descriptor.name === ROW_KEY);
+    if (reserved !== undefined) {
+        throw new EntifixBuildError(`A composition child declares a member named \`${ROW_KEY}\`, which is reserved ` + 'for the row’s client-side key. Rename the member: the key and the member ' + 'cannot share a name, and the row would lose its identity on every edit.', undefined, {
+            member: ROW_KEY
+        });
+    }
+    return descriptors;
+}
+/**
+ * The columns a detail grid actually edits.
+ *
+ * A read-only member still has a column — it is shown, just not written, exactly
+ * as a form shows one. What is dropped is a **nested collection**: a child that
+ * owns rows of its own would need a grid inside a grid, and `reconstructChild`
+ * is one level deep by decision. Dropping it here rather than rendering a
+ * disabled cell keeps that decision in one place.
+ */ export function editableChildColumns(descriptors) {
+    return descriptors.filter((descriptor)=>descriptor.type !== 'composition' && descriptor.type !== 'linkCollection' && descriptor.type !== 'link');
+}
+
+//# sourceMappingURL=describe-child-columns.js.map

package/dist/entity-definition/describe/describe-child-columns.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/entity-definition/describe/describe-child-columns.ts"],"sourcesContent":["import { EntifixBuildError } from '../../base-entities/entifix-error/index.js';\nimport { ROW_KEY } from '../../types/EntityRowDraft.js';\nimport type { ChildConstructor } from '../meta-entities/meta-accessor/index.js';\nimport {\n  describeEntityColumns,\n  type EntityFieldDescriptor,\n} from './describe-entity-columns.js';\n\n/**\n * The columns of one row of an owned collection.\n *\n * Thin over {@link describeEntityColumns}, which already accepts a\n * `ChildConstructor` — a child is described by its accessors and needs no\n * `@entity()` ([ADR 0034](../../../../../../../docs/adr/0034-composition-metadata.md)).\n * What this adds is the one rule a row has and an entity does not.\n *\n * **A child may not declare `$key`.** That name is the row's minted client\n * identity, and a member of the same name would be overwritten by it — the row\n * would re-key on every keystroke, drop focus mid-word, and address another\n * row's errors. Throwing is the only honest option: silently renaming the\n * member would write the wrong column, and preferring the member over the key\n * would leave the grid with no identity at all.\n *\n * `EntifixBuildError` rather than a logic error, because this is a declaration\n * fault in the entity — the same class `assertNotQueryable` raises when a\n * collection claims to be sortable.\n */\nexport function describeChildColumns<TChild extends object>(\n  childType: ChildConstructor<TChild>,\n  sample?: TChild,\n): EntityFieldDescriptor[] {\n  const descriptors = describeEntityColumns(childType, sample);\n  const reserved = descriptors.find(descriptor => descriptor.name === ROW_KEY);\n\n  if (reserved !== undefined) {\n    throw new EntifixBuildError(\n      `A composition child declares a member named \\`${ROW_KEY}\\`, which is reserved ` +\n        'for the row’s client-side key. Rename the member: the key and the member ' +\n        'cannot share a name, and the row would lose its identity on every edit.',\n      undefined,\n      { member: ROW_KEY },\n    );\n  }\n\n  return descriptors;\n}\n\n/**\n * The columns a detail grid actually edits.\n *\n * A read-only member still has a column — it is shown, just not written, exactly\n * as a form shows one. What is dropped is a **nested collection**: a child that\n * owns rows of its own would need a grid inside a grid, and `reconstructChild`\n * is one level deep by decision. Dropping it here rather than rendering a\n * disabled cell keeps that decision in one place.\n */\nexport function editableChildColumns(\n  descriptors: readonly EntityFieldDescriptor[],\n): EntityFieldDescriptor[] {\n  return descriptors.filter(\n    descriptor =>\n      descriptor.type !== 'composition' &&\n      descriptor.type !== 'linkCollection' &&\n      descriptor.type !== 'link',\n  );\n}\n"],"names":["EntifixBuildError","ROW_KEY","describeEntityColumns","describeChildColumns","childType","sample","descriptors","reserved","find","descriptor","name","undefined","member","editableChildColumns","filter","type"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,6CAA6C;AAC/E,SAASC,OAAO,QAAQ,gCAAgC;AAExD,SACEC,qBAAqB,QAEhB,+BAA+B;AAEtC;;;;;;;;;;;;;;;;;;CAkBC,GACD,OAAO,SAASC,qBACdC,SAAmC,EACnCC,MAAe;IAEf,MAAMC,cAAcJ,sBAAsBE,WAAWC;IACrD,MAAME,WAAWD,YAAYE,IAAI,CAACC,CAAAA,aAAcA,WAAWC,IAAI,KAAKT;IAEpE,IAAIM,aAAaI,WAAW;QAC1B,MAAM,IAAIX,kBACR,CAAC,8CAA8C,EAAEC,QAAQ,sBAAsB,CAAC,GAC9E,8EACA,2EACFU,WACA;YAAEC,QAAQX;QAAQ;IAEtB;IAEA,OAAOK;AACT;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASO,qBACdP,WAA6C;IAE7C,OAAOA,YAAYQ,MAAM,CACvBL,CAAAA,aACEA,WAAWM,IAAI,KAAK,iBACpBN,WAAWM,IAAI,KAAK,oBACpBN,WAAWM,IAAI,KAAK;AAE1B"}