@shrkcrft/inspector 0.1.0-alpha.30 → 0.1.0-alpha.31

package/dist/scaffold-patterns.js

@@ -5,50 +5,124 @@
  * into a single in-memory list. Patterns are data; this module never executes
  * shell commands or evaluates pack code beyond a dynamic import.
  */
-import { existsSync } from 'node:fs';
+import { existsSync, readdirSync, statSync } from 'node:fs';
 import * as nodePath from 'node:path';
-import { importModuleViaLoader } from '@shrkcrft/core';
-import { isRecognizedScaffoldStrategy, } from '@shrkcrft/plugin-api';
+import { DEAD_SELECTOR_CAUSES, importModuleViaLoader, MARKABLE_UNIT_LISTS, MarkableUnitList, mergeUnitMarks, normalizeUnitList, qualifyListPath, qualifyUnitMarks, RejectionCause, settleUnitLiveness, stampUnitMarks, UnitDeadWeight, UnitLivenessState, unitListProblems, unitProblemsOf, } from '@shrkcrft/core';
+import { isRecognizedScaffoldStrategy, normalizeScaffoldPattern, resolveScaffoldStrategy, } from '@shrkcrft/plugin-api';
+/** THE closed set of a pattern's `confidence` — the loader and the doctor read one set. */
+const SCAFFOLD_CONFIDENCES = new Set(['high', 'medium', 'low']);
+/**
+ * THE scaffold-pattern acceptance predicate (round 12, 12.1 / 12.1d): `id`,
+ * `templateId`, a non-empty `matchPaths` and a `confidence` from the closed
+ * set — `[]` means accepted. `confidence` was checked only by `scaffolds
+ * doctor`, so a pattern without one was ACCEPTED and `scaffolds list` crashed
+ * on it (`p.pattern.confidence.padEnd`).
+ */
+export function scaffoldPatternRejectionReasons(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return ['(entry): must be an object'];
+    const p = raw;
+    const out = [];
+    if (typeof p.id !== 'string' || p.id.length === 0)
+        out.push('id: must be a non-empty string');
+    if (typeof p.templateId !== 'string' || p.templateId.length === 0) {
+        out.push('templateId: must be a non-empty string');
+    }
+    if (!Array.isArray(p.matchPaths) || p.matchPaths.length === 0) {
+        out.push('matchPaths: must be a non-empty array');
+    }
+    else {
+        // Round 13: each entry is a glob string or a well-formed
+        // `{ pattern, expectEmpty: true, reason? }` marker — THE core parser's
+        // problems, one per bad entry. An object used to load as the glob
+        // `[object Object]` (matching nothing, silently).
+        out.push(...unitListProblems(p.matchPaths, MATCH_PATHS));
+    }
+    if ('expectEmptyUnits' in p) {
+        out.push(`expectEmptyUnits: derived by the loader — mark the entry itself: matchPaths: [{ pattern, expectEmpty: true }]`);
+    }
+    if (typeof p.confidence !== 'string' || !SCAFFOLD_CONFIDENCES.has(p.confidence)) {
+        out.push(`confidence: must be high|medium|low (got "${String(p.confidence)}")`);
+    }
+    return out;
+}
+/** THE list path of `matchPaths` — the loader's marks and the doctor's observations share it. */
+const MATCH_PATHS = MARKABLE_UNIT_LISTS[MarkableUnitList.ScaffoldPatternMatchPaths].listPath;
+/**
+ * A pattern's `matchPaths` as plain globs plus its marker ledger — idempotent,
+ * so a hand-built pattern that still carries `{ pattern, expectEmpty }` entries
+ * is read by its units instead of as the glob `[object Object]`.
+ */
+function patternUnits(p) {
+    const list = Array.isArray(p.matchPaths) ? p.matchPaths : [];
+    const n = normalizeUnitList(list, MATCH_PATHS);
+    return n.ok
+        ? { units: n.value.units, marks: mergeUnitMarks(p.expectEmptyUnits, n.value.marks) }
+        : { units: list.filter((g) => typeof g === 'string'), marks: p.expectEmptyUnits ?? [] };
+}
 export async function loadScaffoldPatternsFromFile(file) {
-    if (!existsSync(file))
-        return { patterns: [], warnings: [`scaffold pattern file missing: ${file}`] };
+    if (!existsSync(file)) {
+        return { patterns: [], indices: [], warnings: [`scaffold pattern file missing: ${file}`], rejected: [] };
+    }
     try {
         const mod = await importModuleViaLoader(file);
         const raw = mod.default ?? mod;
         if (!Array.isArray(raw)) {
             return {
                 patterns: [],
+                indices: [],
                 warnings: [`scaffold pattern file did not default-export an array: ${file}`],
+                rejected: [],
             };
         }
         const out = [];
-        const warnings = [];
-        for (const candidate of raw) {
-            if (!candidate || typeof candidate !== 'object') {
-                warnings.push(`scaffold pattern entry is not an object in ${file}`);
-                continue;
-            }
-            const p = candidate;
-            if (!p.id || typeof p.id !== 'string') {
-                warnings.push(`scaffold pattern missing id in ${file}`);
-                continue;
-            }
-            if (!p.templateId || typeof p.templateId !== 'string') {
-                warnings.push(`scaffold pattern "${p.id}" missing templateId in ${file}`);
-                continue;
+        const indices = [];
+        const rejected = [];
+        raw.forEach((candidate, index) => {
+            const reasons = scaffoldPatternRejectionReasons(candidate);
+            if (reasons.length > 0) {
+                const id = candidate && typeof candidate === 'object' ? candidate.id : undefined;
+                rejected.push({
+                    file,
+                    index,
+                    exportName: 'default',
+                    ...(typeof id === 'string' && id.length > 0 ? { entryId: id } : {}),
+                    reasons,
+                    cause: RejectionCause.Invalid,
+                });
+                return;
             }
-            if (!Array.isArray(p.matchPaths) || p.matchPaths.length === 0) {
-                warnings.push(`scaffold pattern "${p.id}" must declare matchPaths in ${file}`);
-                continue;
+            // THE normaliser (round 13): `matchPaths` markers become plain globs + the
+            // `expectEmptyUnits` ledger (the pack stamp is added by the inspection
+            // loader, which knows the pack). A new object — the module's export is
+            // never patched.
+            const normalized = normalizeScaffoldPattern(candidate);
+            if (!normalized.ok) {
+                const id = candidate.id;
+                rejected.push({
+                    file,
+                    index,
+                    exportName: 'default',
+                    ...(typeof id === 'string' && id.length > 0 ? { entryId: id } : {}),
+                    reasons: unitProblemsOf(normalized.error),
+                    cause: RejectionCause.Invalid,
+                });
+                return;
             }
-            out.push(p);
-        }
-        return { patterns: out, warnings };
+            const p = normalized.value;
+            // The list every consumer iterates (`extractVariablesForFile`): a missing
+            // one is normalised to a frozen [] rather than reaching it as undefined.
+            out.push(Array.isArray(p.variables) ? p : { ...p, variables: Object.freeze([]) });
+            indices.push(index);
+        });
+        return { patterns: out, indices, warnings: [], rejected };
     }
     catch (e) {
         return {
             patterns: [],
+            indices: [],
             warnings: [`failed to import scaffold pattern file ${file}: ${e.message}`],
+            rejected: [],
         };
     }
 }
@@ -59,22 +133,35 @@ export async function loadScaffoldPatternsFromFile(file) {
 export async function loadScaffoldPatternsFromInspection(inspection) {
     const seen = new Map();
     const warnings = [];
+    const rejected = [];
+    const duplicate = (p, file, index, prev) => {
+        rejected.push({
+            file,
+            index,
+            exportName: 'default',
+            entryId: p.id,
+            reasons: [`id: "${p.id}" is already declared in ${prev.source.file ?? prev.source.type}`],
+            cause: RejectionCause.DuplicateId,
+        });
+    };
     // Also load a local sharkcraft/scaffold-patterns.ts when present.
     if (inspection.sharkcraftDir) {
         const local = nodePath.join(inspection.sharkcraftDir, 'scaffold-patterns.ts');
         if (existsSync(local)) {
             const r = await loadScaffoldPatternsFromFile(local);
             warnings.push(...r.warnings);
-            for (const p of r.patterns) {
-                if (seen.has(p.id)) {
-                    warnings.push(`scaffold pattern "${p.id}" duplicated — local version skipped`);
-                    continue;
+            rejected.push(...r.rejected);
+            r.patterns.forEach((p, i) => {
+                const prev = seen.get(p.id);
+                if (prev) {
+                    duplicate(p, local, r.indices[i] ?? i, prev);
+                    return;
                 }
                 seen.set(p.id, {
                     pattern: p,
                     source: { type: 'local', file: local },
                 });
-            }
+            });
         }
     }
     for (const pack of inspection.packs.validPacks) {
@@ -83,13 +170,19 @@ export async function loadScaffoldPatternsFromInspection(inspection) {
             const full = nodePath.resolve(pack.packageRoot, rel);
             const r = await loadScaffoldPatternsFromFile(full);
             warnings.push(...r.warnings);
-            for (const p of r.patterns) {
-                if (seen.has(p.id)) {
-                    warnings.push(`scaffold pattern "${p.id}" duplicated — pack version skipped`);
+            rejected.push(...r.rejected);
+            for (const [i, p] of r.patterns.entries()) {
+                const prev = seen.get(p.id);
+                if (prev) {
+                    duplicate(p, full, r.indices[i] ?? i, prev);
                     continue;
                 }
                 seen.set(p.id, {
-                    pattern: p,
+                    // A pack's markers carry the pack (round 13): a pack marker that went
+                    // live is INFO for the consumer, who cannot edit it.
+                    pattern: p.expectEmptyUnits
+                        ? { ...p, expectEmptyUnits: stampUnitMarks(p.expectEmptyUnits, pack.packageName) }
+                        : p,
                     source: {
                         type: 'pack',
                         packageName: pack.packageName,
@@ -104,10 +197,59 @@ export async function loadScaffoldPatternsFromInspection(inspection) {
             }
         }
     }
-    return { patterns: [...seen.values()], warnings };
+    return { patterns: [...seen.values()], warnings, rejected };
 }
-export function doctorScaffoldPatterns(patterns, inspection) {
+/**
+ * `coverage` (optional, from {@link enumerateScaffoldPatternCandidates}) adds
+ * the per-unit dead-selector checks: a `matchPaths` glob matching no file, and
+ * a pattern matching no file after `excludePaths`. Without it only the
+ * definitions are validated (back-compat).
+ */
+export function doctorScaffoldPatterns(patterns, inspection, coverage) {
     const issues = [];
+    if (coverage) {
+        // Every per-unit finding comes from THE settle (round 13): a dead glob or
+        // pattern is a warning; an intended-empty glob and a stale marker are info
+        // (the acceptance rides in coverage; went-live fails only through
+        // `selectorUnitFails` under `--fail-on-dead-units`).
+        const liveness = scaffoldPatternLiveness(patterns, coverage);
+        for (const { pattern: p } of patterns) {
+            if (!coverage.byPattern.has(p.id))
+                continue;
+            for (const u of liveness.globs.units.filter((x) => x.list === qualifyListPath(p.id, MATCH_PATHS))) {
+                if (u.state === UnitLivenessState.Dead) {
+                    issues.push({
+                        patternId: p.id,
+                        field: 'matchPaths',
+                        severity: 'warning',
+                        code: 'matchPaths-matched-nothing',
+                        target: u.unit,
+                        message: `matchPaths glob "${u.unit}" matches no file, so the pattern never sees files through it — ${DEAD_SELECTOR_CAUSES}`,
+                    });
+                }
+                else if (u.state === UnitLivenessState.IntendedEmpty || u.state === UnitLivenessState.WentLive) {
+                    issues.push({
+                        patternId: p.id,
+                        field: 'matchPaths',
+                        severity: 'info',
+                        code: u.state === UnitLivenessState.IntendedEmpty ? 'matchPaths-intended-empty' : 'matchPaths-went-live',
+                        target: u.unit,
+                        // THE settle's sentence; the pattern is already the finding's subject.
+                        message: `matchPaths glob "${u.unit}" — ${u.message}`,
+                    });
+                }
+            }
+            if (liveness.patterns.dead.some((u) => u.unit === p.id)) {
+                issues.push({
+                    patternId: p.id,
+                    field: 'matchPaths',
+                    severity: 'warning',
+                    code: 'pattern-dead',
+                    message: 'matches no file (after excludePaths), so inference can never suggest it',
+                });
+            }
+        }
+    }
     const knownTemplateIds = new Set(inspection.templateRegistry.list().map((t) => t.id));
     for (const { pattern: p } of patterns) {
         if (!p.title) {
@@ -129,7 +271,7 @@ export function doctorScaffoldPatterns(patterns, inspection) {
                 message: 'appliesWhen is empty — pattern will not be consulted by any lifecycle hook',
             });
         }
-        if (p.confidence !== 'high' && p.confidence !== 'medium' && p.confidence !== 'low') {
+        if (!SCAFFOLD_CONFIDENCES.has(String(p.confidence))) {
             issues.push({
                 patternId: p.id,
                 field: 'confidence',
@@ -208,67 +350,216 @@ export function matchScaffoldPattern(pattern, relativePath) {
         if (globToRegExp(x).test(path))
             return false;
     }
-    for (const m of pattern.matchPaths) {
+    for (const m of patternUnits(pattern).units) {
         if (globToRegExp(m).test(path))
             return true;
     }
     return false;
 }
+// ─── Candidate enumeration (the one walker infer and the doctor share) ────────
+/** Directory names the candidate walk never enters. */
+const SCAFFOLD_WALK_SKIP = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    '.sharkcraft',
+    '__tests__',
+]);
+/**
+ * THE scaffold candidate walker: every file under `root` once (skipping
+ * vendor/build/VCS and test dirs), with its project-relative POSIX path.
+ * `infer templates` and the scaffold doctor both read it, so the doctor's
+ * per-pattern counts equal infer's candidates by construction. Returns the
+ * number of files visited.
+ */
+export function walkScaffoldCandidateFiles(root, onFile) {
+    let walked = 0;
+    const visit = (dir) => {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (SCAFFOLD_WALK_SKIP.has(e))
+                continue;
+            const full = nodePath.join(dir, e);
+            let st;
+            try {
+                st = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory())
+                visit(full);
+            else if (st.isFile()) {
+                walked += 1;
+                onFile(full, nodePath.relative(root, full).split(nodePath.sep).join('/'));
+            }
+        }
+    };
+    if (existsSync(root))
+        visit(root);
+    return walked;
+}
+/**
+ * Walk once and count, per pattern, the files it matches (the runtime matcher,
+ * `excludePaths` honoured) and the files each `matchPaths` glob matches on its
+ * own (`globToRegExp` — the pattern's own dialect, not the boundaries one).
+ */
+export function enumerateScaffoldPatternCandidates(projectRoot, patterns) {
+    // Compiled once per walk. A non-string / empty entry compiles to nothing —
+    // exactly what `matchScaffoldPattern` makes of it (`/^$/` or a throw) — and
+    // the doctor reports it as a definition error.
+    const compile = (list) => (list ?? []).map((g) => (typeof g === 'string' && g.length > 0 ? globToRegExp(g) : null));
+    const compiled = patterns.map(({ pattern }) => {
+        const units = patternUnits(pattern).units;
+        return {
+            pattern,
+            units,
+            globs: compile(units),
+            excludes: compile(pattern.excludePaths),
+            counts: units.map(() => 0),
+            files: [],
+        };
+    });
+    const firstMatch = [];
+    const walked = walkScaffoldCandidateFiles(projectRoot, (_abs, rel) => {
+        let first;
+        for (const c of compiled) {
+            let anyGlob = false;
+            c.globs.forEach((re, i) => {
+                if (re && re.test(rel)) {
+                    c.counts[i] = (c.counts[i] ?? 0) + 1;
+                    anyGlob = true;
+                }
+            });
+            // `matchScaffoldPattern`'s semantics: excluded first, then any glob.
+            if (anyGlob && !c.excludes.some((re) => re !== null && re.test(rel))) {
+                c.files.push(rel);
+                first ??= c.pattern.id;
+            }
+        }
+        if (first)
+            firstMatch.push({ file: rel, patternId: first });
+    });
+    const byPattern = new Map();
+    for (const c of compiled) {
+        byPattern.set(c.pattern.id, {
+            patternId: c.pattern.id,
+            files: c.files,
+            perMatchPath: c.units.map((glob, i) => ({ glob, files: c.counts[i] ?? 0 })),
+        });
+    }
+    return { byPattern, firstMatch, walked };
+}
+/**
+ * THE two settles over an enumeration (round 13): every `matchPaths` glob
+ * (markable: exists = live = it matches a file), and the DERIVED pattern-level
+ * unit (does the pattern match a file after `excludePaths`; not authored, so
+ * never marked). A pattern whose every glob is intended-empty is left OUT of
+ * the pattern-level settle — its glob-level acceptance speaks for it: ONE
+ * planned fact is ONE acceptance, not the dead=2 it used to be.
+ */
+function scaffoldPatternLiveness(patterns, enumeration) {
+    const globObservations = [];
+    const marks = [];
+    for (const { pattern } of patterns) {
+        const list = qualifyListPath(pattern.id, MATCH_PATHS);
+        for (const g of enumeration.byPattern.get(pattern.id)?.perMatchPath ?? []) {
+            globObservations.push({
+                list,
+                unit: g.glob,
+                label: `${pattern.id}: ${g.glob}`,
+                exists: g.files > 0,
+                live: g.files > 0,
+                matched: g.files,
+                liveBecause: `matches ${g.files} file(s)`,
+                deadReason: 'matched no file',
+            });
+        }
+        marks.push(...qualifyUnitMarks(patternUnits(pattern).marks, pattern.id));
+    }
+    const globs = settleUnitLiveness({
+        subject: 'scaffold patterns',
+        unitLabel: MARKABLE_UNIT_LISTS[MarkableUnitList.ScaffoldPatternMatchPaths].unitLabel,
+        weight: UnitDeadWeight.Coverage,
+        observations: globObservations,
+        marks,
+        deadSummary: 'matched no file',
+    });
+    const patternObservations = [];
+    for (const { pattern } of patterns) {
+        const own = globs.units.filter((u) => u.list === qualifyListPath(pattern.id, MATCH_PATHS));
+        if (own.length > 0 && own.every((u) => u.state === UnitLivenessState.IntendedEmpty))
+            continue;
+        const files = enumeration.byPattern.get(pattern.id)?.files.length ?? 0;
+        patternObservations.push({
+            list: 'patterns',
+            unit: pattern.id,
+            exists: files > 0,
+            live: files > 0,
+            matched: files,
+            liveBecause: `matches ${files} file(s) after excludePaths`,
+            deadReason: 'match no file after excludePaths',
+        });
+    }
+    const settledPatterns = settleUnitLiveness({
+        subject: 'scaffold patterns',
+        unitLabel: 'patterns',
+        weight: UnitDeadWeight.Coverage,
+        observations: patternObservations,
+        marks: [],
+        deadSummary: 'match no file after excludePaths',
+    });
+    return { globs, patterns: settledPatterns };
+}
+/**
+ * Per-unit coverage over an enumeration, from THE settles
+ * (`scaffoldPatternLiveness`): `matchPaths globs` (examined = globs matching a
+ * file; an intended-empty glob is its own printed acceptance) and `patterns`
+ * (examined = patterns matching a file after `excludePaths`). Empty when there
+ * are no patterns.
+ */
+export function scaffoldPatternCoverage(patterns, enumeration) {
+    if (patterns.length === 0)
+        return { coverage: [], deadUnits: [], liveness: [] };
+    const settled = scaffoldPatternLiveness(patterns, enumeration);
+    return {
+        coverage: [...settled.globs.coverage, ...settled.patterns.coverage],
+        deadUnits: [
+            ...settled.globs.dead.map((u) => `scaffold pattern ${u.label}`),
+            ...settled.patterns.dead.map((u) => `scaffold pattern ${u.unit} (no file)`),
+        ],
+        liveness: [settled.globs, settled.patterns],
+    };
+}
 export function extractVariablesForFile(pattern, filePath, inspection) {
     const warnings = [];
     const values = {};
     const base = nodePath.basename(filePath).replace(/\.(tsx?|jsx?)$/i, '');
     const dirSegments = filePath.split(/[\\/]/).slice(0, -1);
     const dir = dirSegments[dirSegments.length - 1] ?? '';
-    for (const v of pattern.variables) {
+    // THE strategy table (plugin-api `resolveScaffoldStrategy`) — the same one
+    // `isRecognizedScaffoldStrategy` reads, so "recognised" and "implemented"
+    // cannot drift apart.
+    const packageName = inspection.workspace.packageName ?? undefined;
+    for (const v of pattern.variables ?? []) {
         const strat = String(v.from);
-        let value = '';
-        if (strat === 'filename.kebab') {
-            value = base
-                .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-                .replace(/_+/g, '-')
-                .toLowerCase();
-        }
-        else if (strat === 'filename.pascal') {
-            value = base
-                .split(/[-_.]/)
-                .filter(Boolean)
-                .map((s) => s[0].toUpperCase() + s.slice(1))
-                .join('');
-        }
-        else if (strat === 'className') {
-            value = pascal(base);
-        }
-        else if (strat.startsWith('className.stripPrefix:')) {
-            const prefix = strat.slice('className.stripPrefix:'.length);
-            const pascalName = pascal(base);
-            value = pascalName.startsWith(prefix) ? pascalName.slice(prefix.length) : pascalName;
-        }
-        else if (strat === 'functionName') {
-            value = camel(base);
-        }
-        else if (strat === 'directoryName') {
-            value = dir;
-        }
-        else if (strat === 'nearestPackageName') {
-            value = inspection.workspace.packageName ?? '';
-        }
-        else {
+        const r = resolveScaffoldStrategy(strat, {
+            basename: base,
+            directory: dir,
+            ...(packageName ? { packageName } : {}),
+        });
+        if (!r.recognized) {
             warnings.push(`unrecognized extraction strategy "${strat}" for variable "${v.name}"`);
+            continue;
         }
-        if (value)
-            values[v.name] = value;
+        if (r.value)
+            values[v.name] = r.value;
     }
     return { values, warnings };
 }
-function pascal(s) {
-    return s
-        .split(/[-_.]/)
-        .filter(Boolean)
-        .map((p) => p[0].toUpperCase() + p.slice(1))
-        .join('');
-}
-function camel(s) {
-    const p = pascal(s);
-    return p ? p[0].toLowerCase() + p.slice(1) : '';
-}

package/dist/schema-inventory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-inventory.d.ts","sourceRoot":"","sources":["../src/schema-inventory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,eAAO,MAAM,uBAAuB,mCAAmC,CAAC;AAExE,oBAAY,YAAY;IACtB,OAAO,YAAY;IACnB,UAAU,eAAe;IACzB,UAAU,oBAAoB;CAC/B;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,sEAAsE;IACtE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;IACjD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,wDAAwD;IACxD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,6CAA6C;IAC7C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,EAAE,OAAO,uBAAuB,CAAC;IAChD,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,qBAAqB,CAAC,CAAC;IACvD,QAAQ,CAAC,eAAe,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACjD;AAqOD,wBAAgB,oBAAoB,IAAI,sBAAsB,CAQ7D;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAehF;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAiBpF;AAED,4DAA4D;AAC5D,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,MAAM,GAAG,qBAAqB,GAAG,IAAI,CAEjF"}
+{"version":3,"file":"schema-inventory.d.ts","sourceRoot":"","sources":["../src/schema-inventory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,eAAO,MAAM,uBAAuB,mCAAmC,CAAC;AAExE,oBAAY,YAAY;IACtB,OAAO,YAAY;IACnB,UAAU,eAAe;IACzB,UAAU,oBAAoB;CAC/B;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,sEAAsE;IACtE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;IACjD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,wDAAwD;IACxD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,6CAA6C;IAC7C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,EAAE,OAAO,uBAAuB,CAAC;IAChD,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,qBAAqB,CAAC,CAAC;IACvD,QAAQ,CAAC,eAAe,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACjD;AAsOD,wBAAgB,oBAAoB,IAAI,sBAAsB,CAQ7D;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAehF;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAiBpF;AAED,4DAA4D;AAC5D,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,MAAM,GAAG,qBAAqB,GAAG,IAAI,CAEjF"}

package/dist/schema-inventory.js

@@ -101,7 +101,7 @@ const SCHEMA_ENTRIES = [
         ],
         currentVersion: 'v1',
         summary: 'Pack manifest envelope (signed). Consumed by `shrk packs *`.',
-        emittedBy: 'shrk packs build',
+        emittedBy: 'shrk packs sign',
         docs: 'docs/security.md',
     },
     {
@@ -192,8 +192,9 @@ const SCHEMA_ENTRIES = [
             { version: 'v1', status: SchemaStatus.Current },
         ],
         currentVersion: 'v1',
-        summary: 'Compliance profile + check envelope.',
-        emittedBy: 'shrk compliance check',
+        // Its CLI verb was retired; the envelope is emitted by the inspector
+        // library (compliance-profiles.ts), so no command is named here.
+        summary: 'Compliance profile + check envelope (emitted by the inspector library; its CLI verb was retired).',
     },
     {
         id: 'sharkcraft.review-packet',

package/dist/search-document-id.d.ts

@@ -0,0 +1,52 @@
+/**
+ * THE search-document id codec: `<prefix>:<id>`.
+ *
+ * Every search document is keyed `<prefix>:<id>` (`knowledge:auth.login`,
+ * `rule:no-foo`, `facet:<construct>:<facet>`), and search tuning matches a
+ * boost key against that WHOLE id (`boostIds[doc.id]`). The format used to be
+ * hand-written at fourteen sites in the index builder, three in the task ranker
+ * and one in the context re-ranker, while the self-config doctor looked the
+ * whole key up in BARE-id registries. The two readings disagreed exactly: a
+ * correctly prefixed key (which fires) was reported "unknown", and a bare key
+ * (which can never fire) passed. One codec, read by every writer and every
+ * reader, so they cannot disagree again.
+ *
+ * Split on the FIRST `:` — facet ids themselves contain a `:`.
+ */
+import type { ReferenceKind } from './reference-registry.js';
+import type { SearchDocumentPrefix } from './search-document-prefix.js';
+/** Every search-document prefix, in declaration order. */
+export declare const SEARCH_DOCUMENT_PREFIXES: readonly SearchDocumentPrefix[];
+/** Prefix → the id registry its ids resolve against (`null` = none). */
+export declare const SEARCH_DOCUMENT_ID_KINDS: Readonly<Record<SearchDocumentPrefix, ReferenceKind | null>>;
+/** `searchDocumentId('knowledge', 'auth.login')` → `knowledge:auth.login`. */
+export declare function searchDocumentId(prefix: SearchDocumentPrefix, id: string): string;
+/**
+ * `<prefix>:<id>` → `{ prefix, id }`, split on the FIRST `:`. `null` when the
+ * key has no `:` or either side is empty. The prefix is NOT validated — pair
+ * with {@link isSearchDocumentPrefix}.
+ */
+export declare function parseSearchDocumentId(key: string): {
+    readonly prefix: string;
+    readonly id: string;
+} | null;
+/** True when `prefix` is one `buildSearchIndex` emits. */
+export declare function isSearchDocumentPrefix(prefix: string): prefix is SearchDocumentPrefix;
+/** The `SearchKind` value the prefix's documents carry, or `undefined`. */
+export declare function searchKindForPrefix(prefix: string): string | undefined;
+/** The prefix whose documents carry `searchKind` (`construct-facet` → `facet`). */
+export declare function searchDocumentPrefixForKind(searchKind: string): SearchDocumentPrefix | undefined;
+/** The prefix whose ids live in `kind`'s registry (`path-convention` → `path`). */
+export declare function searchDocumentPrefixForReferenceKind(kind: ReferenceKind): SearchDocumentPrefix | undefined;
+/**
+ * The registry entry a search-document id names: `knowledge:gamma.entry` →
+ * `{ referenceKind: 'knowledge', id: 'gamma.entry' }`. `undefined` when the id
+ * does not parse, its prefix is not one the index emits, or its prefix has no
+ * id registry (`doc:`, `preset:`, `facet:`, …) — such a document exists, but
+ * no registry can be asked about it.
+ */
+export declare function searchDocumentReference(docId: string): {
+    readonly referenceKind: ReferenceKind;
+    readonly id: string;
+} | undefined;
+//# sourceMappingURL=search-document-id.d.ts.map

package/dist/search-document-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-document-id.d.ts","sourceRoot":"","sources":["../src/search-document-id.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAiCxE,0DAA0D;AAC1D,eAAO,MAAM,wBAAwB,EAAE,SAAS,oBAAoB,EAEnE,CAAC;AAEF,wEAAwE;AACxE,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,MAAM,CAAC,oBAAoB,EAAE,aAAa,GAAG,IAAI,CAAC,CAK/F,CAAC;AAEJ,8EAA8E;AAC9E,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,oBAAoB,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAEjF;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAI1G;AAED,0DAA0D;AAC1D,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,oBAAoB,CAErF;AAED,2EAA2E;AAC3E,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEtE;AAED,mFAAmF;AACnF,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CAEhG;AAED,mFAAmF;AACnF,wBAAgB,oCAAoC,CAAC,IAAI,EAAE,aAAa,GAAG,oBAAoB,GAAG,SAAS,CAE1G;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,MAAM,GACZ;IAAE,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAK5E"}