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

package/dist/knowledge-stale.js

@@ -13,6 +13,7 @@
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import * as nodePath from 'node:path';
 import { HELPERS } from "./helper-registry.js";
+import { referenceIdExists } from "./reference-registry.js";
 import { resolveSymbolInFile, SymbolResolution } from "./symbol-index.js";
 export const KNOWLEDGE_STALE_SCHEMA = 'sharkcraft.knowledge-stale/v1';
 export var ReferenceCheckOutcome;
@@ -64,59 +65,39 @@ function dirExists(projectRoot, rel) {
         return false;
     }
 }
+/*
+ * Existence checks delegate to the SHARED reference registry.
+ *
+ * They used to be private copies here, each reading a differently-shaped
+ * structural cast off the inspection (`playbookRegistry`, `constructRegistry`,
+ * `policyChecks`) — properties nothing ever attached, so those kinds answered
+ * "does not exist" for every id including correct ones. An unchecked cast to a
+ * hoped-for shape compiles perfectly and fails silently forever; the registry
+ * imports the real accessors so the compiler can see a rename.
+ */
 function commandExistsInInspection(inspection, id) {
-    // Both `shrk` commands and pack-contributed commands live on the
-    // inspection. We do a permissive lookup against the recommendation
-    // catalog if available.
-    const commands = inspection.commandCatalog;
-    if (Array.isArray(commands)) {
-        if (commands.some((c) => c.id === id))
-            return true;
-    }
-    // Fallback — accept anything that looks like a valid `shrk` command.
-    return id.startsWith('shrk ') || id.startsWith('bun ');
+    return referenceIdExists(inspection, 'command', id);
 }
 function templateExists(inspection, id) {
-    return inspection.templates.some((t) => t.id === id);
+    return referenceIdExists(inspection, 'template', id);
 }
 function playbookExists(inspection, id) {
-    const inspectionAny = inspection;
-    const reg = inspectionAny.playbookRegistry;
-    if (reg && typeof reg.list === 'function') {
-        return (reg.list() ?? []).some((p) => p.id === id);
-    }
-    return false;
+    return referenceIdExists(inspection, 'playbook', id);
 }
 function constructExists(inspection, id) {
-    const inspectionAny = inspection;
-    const reg = inspectionAny.constructRegistry;
-    if (reg && typeof reg.list === 'function') {
-        return (reg.list() ?? []).some((c) => c.id === id);
-    }
-    return false;
+    return referenceIdExists(inspection, 'construct', id);
 }
 function helperExists(id) {
     return HELPERS.some((h) => h.id === id);
 }
 function policyExists(inspection, id) {
-    const inspectionAny = inspection;
-    const checks = inspectionAny.policyChecks;
-    if (Array.isArray(checks))
-        return checks.some((c) => c.id === id);
-    return false;
+    return referenceIdExists(inspection, 'policy', id);
 }
 function boundaryRuleExists(inspection, id) {
-    const reg = inspection.boundaryRegistry;
-    if (reg && typeof reg.list === 'function')
-        return reg.list().some((b) => b.id === id);
-    return false;
+    return referenceIdExists(inspection, 'boundary-rule', id);
 }
 function pathConventionExists(inspection, id) {
-    const svc = inspection.pathService;
-    if (svc && typeof svc.list === 'function') {
-        return svc.list().some((p) => p.id === id);
-    }
-    return false;
+    return referenceIdExists(inspection, 'path-convention', id);
 }
 function packageExists(inspection, id) {
     // Project packages live under `packages/<name>` for SharkCraft + many

package/dist/nearest-id.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Nearest-id "did you mean" over an arbitrary id set.
+ *
+ * The command suggester already had a Levenshtein and a fuzzy ranker, but both
+ * were shaped around a command CATALOG (command paths, aliases, descriptions).
+ * A stale `nge.angular-renderer` in a doc needs the same help against a flat
+ * list of template ids, so the distance function moves here and both consume
+ * it — a second implementation would drift, and then two surfaces would
+ * disagree about what "close" means.
+ *
+ * A suggestion is only offered when it is actually close. Printing the
+ * alphabetically-first id next to every typo trains people to ignore the line.
+ */
+/** Levenshtein edit distance. Iterative, one row of state. */
+export declare function levenshtein(a: string, b: string): number;
+/** One candidate the query might have meant. */
+export interface INearestId {
+    readonly id: string;
+    readonly distance: number;
+}
+/**
+ * The closest ids to `query`, nearest first.
+ *
+ * The cutoff scales with the query's length — one edit is a lot in `foo` and
+ * very little in `nge.angular-renderer` — and is capped so a long id cannot
+ * drag in something unrelated. Ties break lexically so the output is stable
+ * across runs, which matters when it lands in a committed diff.
+ */
+export declare function nearestIds(query: string, candidates: readonly string[], limit?: number): readonly INearestId[];
+//# sourceMappingURL=nearest-id.d.ts.map

package/dist/nearest-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nearest-id.d.ts","sourceRoot":"","sources":["../src/nearest-id.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,8DAA8D;AAC9D,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAiBxD;AAED,gDAAgD;AAChD,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,KAAK,SAAI,GACR,SAAS,UAAU,EAAE,CAiBvB"}

package/dist/nearest-id.js

@@ -0,0 +1,62 @@
+/**
+ * Nearest-id "did you mean" over an arbitrary id set.
+ *
+ * The command suggester already had a Levenshtein and a fuzzy ranker, but both
+ * were shaped around a command CATALOG (command paths, aliases, descriptions).
+ * A stale `nge.angular-renderer` in a doc needs the same help against a flat
+ * list of template ids, so the distance function moves here and both consume
+ * it — a second implementation would drift, and then two surfaces would
+ * disagree about what "close" means.
+ *
+ * A suggestion is only offered when it is actually close. Printing the
+ * alphabetically-first id next to every typo trains people to ignore the line.
+ */
+/** Levenshtein edit distance. Iterative, one row of state. */
+export function levenshtein(a, b) {
+    const m = a.length;
+    const n = b.length;
+    if (m === 0)
+        return n;
+    if (n === 0)
+        return m;
+    const dp = Array.from({ length: n + 1 }, (_, j) => j);
+    for (let i = 1; i <= m; i += 1) {
+        let prev = dp[0];
+        dp[0] = i;
+        for (let j = 1; j <= n; j += 1) {
+            const tmp = dp[j];
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            dp[j] = Math.min(dp[j] + 1, dp[j - 1] + 1, prev + cost);
+            prev = tmp;
+        }
+    }
+    return dp[n];
+}
+/**
+ * The closest ids to `query`, nearest first.
+ *
+ * The cutoff scales with the query's length — one edit is a lot in `foo` and
+ * very little in `nge.angular-renderer` — and is capped so a long id cannot
+ * drag in something unrelated. Ties break lexically so the output is stable
+ * across runs, which matters when it lands in a committed diff.
+ */
+export function nearestIds(query, candidates, limit = 3) {
+    const q = query.toLowerCase();
+    const cutoff = Math.min(6, Math.max(2, Math.floor(q.length * 0.4)));
+    const scored = [];
+    for (const candidate of candidates) {
+        const c = candidate.toLowerCase();
+        if (c === q)
+            continue;
+        // A shared prefix or suffix is the common real-world shape (`nge.foo-view`
+        // vs `nge.foo-viewer`), and raw edit distance under-rates it.
+        const affinity = c.startsWith(q) || q.startsWith(c) || c.includes(q) || q.includes(c) ? 0 : 1;
+        const distance = affinity === 0 ? 0 : levenshtein(q, c);
+        if (distance > cutoff)
+            continue;
+        scored.push({ id: candidate, distance });
+    }
+    return scored
+        .sort((x, y) => x.distance - y.distance || x.id.localeCompare(y.id))
+        .slice(0, limit);
+}

package/dist/policy-registry.d.ts

@@ -0,0 +1,15 @@
+import type { ISharkcraftInspection } from './sharkcraft-inspector.js';
+/** Load every declared policy id — local files first, then pack contributions. */
+export declare function loadPolicyIds(inspection: ISharkcraftInspection): Promise<readonly string[]>;
+/**
+ * The cached policy ids.
+ *
+ * Synchronous by design, so sync consumers (the reference resolver, the query
+ * ranker) can use it. Returns `[]` until {@link warmPolicyCache} has run — the
+ * reference registry's empty-kind guard is what stops that reading as "no such
+ * policy" for every id.
+ */
+export declare function listPolicyIds(inspection: ISharkcraftInspection): readonly string[];
+/** Pre-warm the cache so subsequent sync reads see a populated list. */
+export declare function warmPolicyCache(inspection: ISharkcraftInspection): Promise<void>;
+//# sourceMappingURL=policy-registry.d.ts.map

package/dist/policy-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy-registry.d.ts","sourceRoot":"","sources":["../src/policy-registry.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAoDvE,kFAAkF;AAClF,wBAAsB,aAAa,CAAC,UAAU,EAAE,qBAAqB,GAAG,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CA6BjG;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,qBAAqB,GAAG,SAAS,MAAM,EAAE,CAElF;AAED,wEAAwE;AACxE,wBAAsB,eAAe,CAAC,UAAU,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAEtF"}

package/dist/policy-registry.js

@@ -0,0 +1,64 @@
+import { existsSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { importModuleViaLoader } from '@shrkcrft/core';
+const CACHE = new Map();
+async function idsFrom(file, namespace) {
+    try {
+        const mod = (await importModuleViaLoader(file));
+        const decls = mod.default ?? mod.policyChecks ?? [];
+        return decls
+            .filter((d) => typeof d?.id === 'string')
+            .flatMap((d) => [d.id, namespace(d.id)]);
+    }
+    catch {
+        // A policy file that will not load is `evaluatePolicy`'s problem to report
+        // (it emits a load-failed check). Listing must not turn that into a crash.
+        return [];
+    }
+}
+/** Load every declared policy id — local files first, then pack contributions. */
+export async function loadPolicyIds(inspection) {
+    const validPacks = inspection.packs?.validPacks ?? [];
+    const cacheKey = `${inspection.projectRoot}:${validPacks
+        .map((p) => p.packageName + '@' + p.packageVersion)
+        .join(',')}`;
+    const cached = CACHE.get(inspection.projectRoot);
+    if (cached && cached.cacheKey === cacheKey)
+        return cached.list;
+    const out = [];
+    const cfg = inspection.config;
+    for (const rel of cfg?.localPolicyFiles ?? ['sharkcraft/policies.ts']) {
+        const full = nodePath.isAbsolute(rel) ? rel : nodePath.join(inspection.projectRoot, rel);
+        if (!existsSync(full))
+            continue;
+        out.push(...(await idsFrom(full, (id) => `local:${id}`)));
+    }
+    for (const pack of validPacks) {
+        const contributions = pack.manifest?.contributions;
+        if (!pack.packageRoot)
+            continue;
+        for (const rel of contributions?.policyCheckFiles ?? []) {
+            const full = nodePath.resolve(pack.packageRoot, rel);
+            if (!existsSync(full))
+                continue;
+            out.push(...(await idsFrom(full, (id) => `pack:${pack.packageName}:${id}`)));
+        }
+    }
+    CACHE.set(inspection.projectRoot, { cacheKey, list: out });
+    return out;
+}
+/**
+ * The cached policy ids.
+ *
+ * Synchronous by design, so sync consumers (the reference resolver, the query
+ * ranker) can use it. Returns `[]` until {@link warmPolicyCache} has run — the
+ * reference registry's empty-kind guard is what stops that reading as "no such
+ * policy" for every id.
+ */
+export function listPolicyIds(inspection) {
+    return CACHE.get(inspection.projectRoot)?.list ?? [];
+}
+/** Pre-warm the cache so subsequent sync reads see a populated list. */
+export async function warmPolicyCache(inspection) {
+    await loadPolicyIds(inspection);
+}

package/dist/query-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query-resolver.d.ts","sourceRoot":"","sources":["../src/query-resolver.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAGvE,eAAO,MAAM,uBAAuB,mCAAmC,CAAC;AAExE,oBAAY,cAAc;IACxB,IAAI,SAAS;IACb,SAAS,cAAc;IACvB,SAAS,cAAc;IACvB,QAAQ,aAAa;IACrB,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,MAAM,WAAW;IACjB,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,SAAS,eAAe;IACxB,UAAU,gBAAgB;IAC1B,OAAO,aAAa;CACrB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,cAAc,CAAC;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,OAAO,uBAAuB,CAAC;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,WAAW,CAAC;IACxB,YAAY,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IACzC,UAAU,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,SAAS,CAAC;CAC7D;AAED,MAAM,WAAW,oBAAoB;IACnC,6CAA6C;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2CAA2C;IAC3C,KAAK,CAAC,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;CACvC;AAoID,wBAAgB,YAAY,CAC1B,UAAU,EAAE,qBAAqB,EACjC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,oBAAyB,GACjC,gBAAgB,CA8BlB"}
+{"version":3,"file":"query-resolver.d.ts","sourceRoot":"","sources":["../src/query-resolver.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAMvE,eAAO,MAAM,uBAAuB,mCAAmC,CAAC;AAExE,oBAAY,cAAc;IACxB,IAAI,SAAS;IACb,SAAS,cAAc;IACvB,SAAS,cAAc;IACvB,QAAQ,aAAa;IACrB,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,MAAM,WAAW;IACjB,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,SAAS,eAAe;IACxB,UAAU,gBAAgB;IAC1B,OAAO,aAAa;CACrB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,cAAc,CAAC;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,OAAO,uBAAuB,CAAC;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,WAAW,CAAC;IACxB,YAAY,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IACzC,UAAU,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,SAAS,CAAC;CAC7D;AAED,MAAM,WAAW,oBAAoB;IACnC,6CAA6C;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2CAA2C;IAC3C,KAAK,CAAC,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;CACvC;AAqID,wBAAgB,YAAY,CAC1B,UAAU,EAAE,qBAAqB,EACjC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,oBAAyB,GACjC,gBAAgB,CA8BlB"}

package/dist/query-resolver.js

@@ -12,6 +12,9 @@
 import { existsSync } from 'node:fs';
 import * as nodePath from 'node:path';
 import { HELPERS } from "./helper-registry.js";
+import { listConstructs } from "./construct-registry.js";
+import { listPlaybooks } from "./playbook-registry.js";
+import { listPolicyIds } from "./policy-registry.js";
 export const QUERY_RESOLUTION_SCHEMA = 'sharkcraft.query-resolution/v1';
 export var QueryMatchKind;
 (function (QueryMatchKind) {
@@ -103,9 +106,9 @@ function rankList(list, query, kind, reason = (t) => `${kind} id matched`) {
     return out;
 }
 function rankConstructs(inspection, query) {
-    const reg = inspection.constructRegistry;
-    const list = getList(reg, 'list');
-    return rankList(list, query, QueryMatchKind.Construct);
+    // The registry accessor, not a structural cast at a property nothing sets —
+    // the latter compiles and then silently ranks nothing forever.
+    return rankList(listConstructs(inspection), query, QueryMatchKind.Construct);
 }
 function rankKnowledge(inspection, query) {
     return rankList(inspection.knowledgeEntries.map((e) => ({ id: e.id, title: e.title })), query, QueryMatchKind.Knowledge);
@@ -117,13 +120,10 @@ function rankHelpers(query) {
     return rankList(HELPERS, query, QueryMatchKind.Helper);
 }
 function rankPlaybooks(inspection, query) {
-    const reg = inspection.playbookRegistry;
-    const list = getList(reg, 'list');
-    return rankList(list, query, QueryMatchKind.Playbook);
+    return rankList(listPlaybooks(inspection), query, QueryMatchKind.Playbook);
 }
 function rankPolicies(inspection, query) {
-    const checks = inspection.policyChecks ?? [];
-    return rankList(checks, query, QueryMatchKind.Policy);
+    return rankList(listPolicyIds(inspection).map((id) => ({ id })), query, QueryMatchKind.Policy);
 }
 function rankCommands(inspection, query) {
     const cat = inspection.commandCatalog ?? [];

package/dist/reference-registry.d.ts

@@ -0,0 +1,112 @@
+import type { KnowledgeReferenceKind } from '@shrkcrft/knowledge';
+import type { ISharkcraftInspection } from './sharkcraft-inspector.js';
+/**
+ * The id sets a knowledge/doc reference can resolve against.
+ *
+ * `knowledge-stale` already answered "does this id exist?" per kind, one
+ * private `*Exists` helper at a time. The doc-reference linter needs the same
+ * answer AND the candidate LIST (to suggest what the author meant), so the
+ * lookup moves here and both consume it. Two implementations of "which
+ * template ids exist" would eventually disagree, and the one nobody runs would
+ * be the wrong one.
+ *
+ * Every list is read defensively off the inspection: these registries are
+ * populated by different layers and a repo may legitimately have none of a
+ * given kind, which must read as "no candidates", never as a crash.
+ */
+/**
+ * Kinds a DOC reference may resolve against.
+ *
+ * A superset of `KnowledgeReferenceKind`: `pipeline` is a real registry that
+ * prose cites constantly (`the spine pipelines (engine.feature-dev, …)`) but
+ * that a knowledge entry has never had a structured reference kind for. The
+ * doc plane owns its own list rather than widening the knowledge contract for
+ * a need only this surface has.
+ */
+export type DocReferenceKind = KnowledgeReferenceKind | 'pipeline';
+/**
+ * EVERY kind this engine can answer "does this id exist?" for.
+ *
+ * A superset of `DocReferenceKind`: the self-config doctor cross-references
+ * kinds prose never cites (a decision record, a scaffold pattern, a routing
+ * hint). It used to answer for them from its OWN lookup sets, built from its
+ * own sources — so "one definition of does-this-id-exist" was a doc claim, not
+ * a property of the code, and the two answers agreed only by coincidence. They
+ * did not always: `sharkcraft.mcp-read-only` is a declared policy that the
+ * doctor's pack-only policy set reported as unknown.
+ *
+ * `docReferences[].resolvesAs` is unchanged — it still accepts exactly the
+ * `DocReferenceKind`s. Widening the RESOLVER is not widening the config.
+ */
+export type ReferenceKind = DocReferenceKind | 'knowledge' | 'rule' | 'decision' | 'convention' | 'contract-template' | 'migration-profile' | 'routing-hint' | 'registration-hint' | 'scaffold-pattern';
+/**
+ * Every kind that resolves against a registry of ids.
+ *
+ * `command` is deliberately absent: the catalog lives in the CLI package,
+ * ABOVE this layer, so it resolves by shape instead of by list. `file` /
+ * `directory` / `symbol` / `package` / `url` are not id registries at all.
+ */
+export declare const ALL_ID_REFERENCE_KINDS: readonly ReferenceKind[];
+/**
+ * Populate the snapshot the synchronous accessors read.
+ *
+ * Call this once, from the async layer that owns the inspection, before
+ * resolving anything. Without it a correct playbook — or convention, or
+ * scaffold pattern — resolves to nothing, which is exactly how a correct id got
+ * reported as an error twice.
+ */
+export declare function warmReferenceRegistries(inspection: ISharkcraftInspection): Promise<void>;
+/**
+ * Every registered id of `kind`, for existence checks and for suggesting what
+ * an unresolved token might have meant.
+ *
+ * **The invariant:** each kind reads the SAME source its `list` verb reads.
+ * `template` goes through `templateRegistry` because that is what `shrk
+ * templates list` prints — not the `templates` array it happens to be built
+ * from today, which would agree only until someone filters one of them.
+ */
+export declare function referenceIdsFor(inspection: ISharkcraftInspection, kind: ReferenceKind): readonly string[];
+/**
+ * Kinds among `kinds` whose registry is EMPTY in this repo.
+ *
+ * This is the generalisation of the bug that prompted it: resolving against an
+ * empty registry cannot succeed, so every id checked against it is reported
+ * wrong — a gate confidently flagging CORRECT usage, which is the fastest way
+ * to get a gate switched off. Emptiness is repo-dependent (a project may simply
+ * have no playbooks), so it cannot be a config-time error; the caller surfaces
+ * it as a loud refusal at run time instead.
+ */
+export declare function emptyReferenceKinds(inspection: ISharkcraftInspection, kinds: readonly ReferenceKind[]): readonly ReferenceKind[];
+/** True when `kind`'s ids come from an async-populated cache. */
+export declare function isCacheBackedKind(kind: ReferenceKind): boolean;
+/**
+ * Whether `id` is registered under `kind`.
+ *
+ * `command` keeps its historical permissiveness: the catalog is not always
+ * populated, and a repo citing `shrk gen …` should not be told its own CLI
+ * does not exist because an optional catalog was absent.
+ */
+export declare function referenceIdExists(inspection: ISharkcraftInspection, kind: ReferenceKind, id: string): boolean;
+/**
+ * The union of candidate ids across `kinds`, deduped and sorted.
+ *
+ * A doc token is checked against several registries at once (a `nge.foo` might
+ * be a template OR a playbook), so the suggester needs one pool rather than
+ * per-kind lists that would each propose their own nearest miss.
+ */
+export declare function referenceIdPool(inspection: ISharkcraftInspection, kinds: readonly ReferenceKind[]): readonly string[];
+/**
+ * Whether `id` is registered under ANY kind.
+ *
+ * For cross-references that do not name a kind — a search-tuning entry boosts
+ * "some id", a decision record relates to "some id". That union used to be
+ * hand-written as a chain of `lookups.x.has(id) || lookups.y.has(id) || …`,
+ * which is a list that silently goes stale: it omitted policies, decisions and
+ * scaffold patterns, so seven of shrk's own correctly-registered ids were
+ * reported unknown. Reading the kind list means adding a kind widens the union
+ * automatically.
+ */
+export declare function referenceIdExistsInAnyKind(inspection: ISharkcraftInspection, id: string): boolean;
+/** The kind that accepted `id`, or `undefined` — for "resolved as what?" output. */
+export declare function referenceKindOf(inspection: ISharkcraftInspection, id: string): ReferenceKind | undefined;
+//# sourceMappingURL=reference-registry.d.ts.map

package/dist/reference-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference-registry.d.ts","sourceRoot":"","sources":["../src/reference-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAalE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAEvE;;;;;;;;;;;;;GAaG;AAEH;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAAG,sBAAsB,GAAG,UAAU,CAAC;AAEnE;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,aAAa,GACrB,gBAAgB,GAChB,WAAW,GACX,MAAM,GACN,UAAU,GACV,YAAY,GACZ,mBAAmB,GACnB,mBAAmB,GACnB,cAAc,GACd,mBAAmB,GACnB,kBAAkB,CAAC;AAEvB;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,EAAE,SAAS,aAAa,EAkB1D,CAAC;AAiDF;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAAC,UAAU,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAwC9F;AAMD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,qBAAqB,EACjC,IAAI,EAAE,aAAa,GAClB,SAAS,MAAM,EAAE,CA6CnB;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,qBAAqB,EACjC,KAAK,EAAE,SAAS,aAAa,EAAE,GAC9B,SAAS,aAAa,EAAE,CAI1B;AAED,iEAAiE;AACjE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAE9D;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,qBAAqB,EACjC,IAAI,EAAE,aAAa,EACnB,EAAE,EAAE,MAAM,GACT,OAAO,CAOT;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,qBAAqB,EACjC,KAAK,EAAE,SAAS,aAAa,EAAE,GAC9B,SAAS,MAAM,EAAE,CAMnB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,qBAAqB,EACjC,EAAE,EAAE,MAAM,GACT,OAAO,CAET;AAED,oFAAoF;AACpF,wBAAgB,eAAe,CAC7B,UAAU,EAAE,qBAAqB,EACjC,EAAE,EAAE,MAAM,GACT,aAAa,GAAG,SAAS,CAE3B"}