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

package/dist/split-identifier.d.ts

@@ -0,0 +1,21 @@
+/**
+ * THE identifier tokenizer.
+ *
+ * Splits an identifier (or a free-text phrase) into lowercase tokens across
+ * camelCase, PascalCase, acronym runs, snake_case, kebab-case, whitespace and
+ * lower/digit→Upper boundaries:
+ *
+ *   DateRangePicker          → [date, range, picker]
+ *   IDateRangePickerOptions  → [i, date, range, picker, options]
+ *   HTTPServer               → [http, server]
+ *   date_range-picker        → [date, range, picker]
+ *
+ * One splitter for every "does this name match these words?" question —
+ * reuse name matching, spec evidence and the recommender's term matcher all
+ * read it — so two callers can never disagree about where a word boundary is.
+ * Do not write another. Order is preserved and duplicates are kept (callers
+ * that need a set build one); empty fragments are dropped. No stop-word or
+ * length filtering happens here — that is a caller's policy, not a boundary.
+ */
+export declare function splitIdentifierTokens(name: string): string[];
+//# sourceMappingURL=split-identifier.d.ts.map

package/dist/split-identifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-identifier.d.ts","sourceRoot":"","sources":["../src/split-identifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAO5D"}

package/dist/split-identifier.js

@@ -0,0 +1,27 @@
+/**
+ * THE identifier tokenizer.
+ *
+ * Splits an identifier (or a free-text phrase) into lowercase tokens across
+ * camelCase, PascalCase, acronym runs, snake_case, kebab-case, whitespace and
+ * lower/digit→Upper boundaries:
+ *
+ *   DateRangePicker          → [date, range, picker]
+ *   IDateRangePickerOptions  → [i, date, range, picker, options]
+ *   HTTPServer               → [http, server]
+ *   date_range-picker        → [date, range, picker]
+ *
+ * One splitter for every "does this name match these words?" question —
+ * reuse name matching, spec evidence and the recommender's term matcher all
+ * read it — so two callers can never disagree about where a word boundary is.
+ * Do not write another. Order is preserved and duplicates are kept (callers
+ * that need a set build one); empty fragments are dropped. No stop-word or
+ * length filtering happens here — that is a caller's policy, not a boundary.
+ */
+export function splitIdentifierTokens(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        .split(/[^A-Za-z0-9]+/)
+        .map((t) => t.toLowerCase())
+        .filter((t) => t.length > 0);
+}

package/dist/stale-path-hint.d.ts

@@ -0,0 +1,3 @@
+import type { IStalePathHintInput } from './i-stale-path-hint-input.js';
+export declare function stalePathHint(h: IStalePathHintInput): string | undefined;
+//# sourceMappingURL=stale-path-hint.d.ts.map

package/dist/stale-path-hint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stale-path-hint.d.ts","sourceRoot":"","sources":["../src/stale-path-hint.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAIxE,wBAAgB,aAAa,CAAC,CAAC,EAAE,mBAAmB,GAAG,MAAM,GAAG,SAAS,CAwBxE"}

package/dist/stale-path-hint.js

@@ -0,0 +1,47 @@
+/**
+ * THE hint for a reference whose path is missing (round 15 closing, A3) — the
+ * stale-check row's `suggestion`, and through it the gate violation's hint,
+ * the fix preview's draft and the MCP report. It branches on who can fix the
+ * reference:
+ *
+ *   - a pack's reference is fixed in the pack: a `root: pack` path missing
+ *     from the pack is shipped (or fixed) there; a project-rooted path the pack
+ *     DOES ship names `root: pack`;
+ *   - a Markdown entry's reference is edited in its `references:` frontmatter —
+ *     `shrk fix --knowledge-stale --apply`, which lands a `shrk knowledge
+ *     rename-file` plan, edits TypeScript entries only;
+ *   - anything else gets the restore-or-rename hint.
+ *
+ * It used to be three string forks — the generic hint set where the path was
+ * checked, two pack overrides layered on after — and a Markdown entry was told
+ * to preview a rename that `--apply` then refuses to land.
+ */
+import { existsSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { KnowledgeSourceFormat } from '@shrkcrft/knowledge';
+import { knowledgeRenameCommand } from "./knowledge-rename-command.js";
+import { KnowledgeRenameVerb } from "./knowledge-rename-verb.js";
+export function stalePathHint(h) {
+    if (h.pack !== undefined) {
+        if (h.packRooted) {
+            return `The path is missing from pack ${h.pack.packageName} (${h.pack.displayRoot}) — ship the file, or fix the reference, in the pack.`;
+        }
+        return existsSync(nodePath.join(h.pack.packageRoot, h.path))
+            ? `${h.path} is shipped inside pack ${h.pack.packageName} (${h.pack.displayRoot}/${h.path}), but a pack's path resolves against the consuming project's root — declare root: pack on this reference, in the pack, to resolve it against the pack's directory.`
+            : `A pack's path resolves against the consuming project's root, not against pack ${h.pack.packageName}'s directory — declare root: pack for a file the pack ships; fix the reference in the pack.`;
+    }
+    const what = h.kind === 'directory' ? 'directory' : 'file';
+    if (h.sourceFormat === KnowledgeSourceFormat.Markdown) {
+        return (`Restore the ${what}, or edit this reference's path in the references: frontmatter of ${h.source ?? 'its Markdown file'} — ` +
+            '`shrk fix --knowledge-stale --apply` (which lands a `shrk knowledge rename-file` plan) edits TypeScript entries only.');
+    }
+    // `rename-file` is a read-only preview already — it takes no `--dry-run`,
+    // and the dispatcher refuses the flag (round 15 follow-up, F4). Built by THE
+    // rename-command helper, the missing path filled in (lane B, B1).
+    if (h.kind === 'file') {
+        return `Restore the file, or preview the rename with \`${knowledgeRenameCommand(KnowledgeRenameVerb.RenameFile, h.path)}\`.`;
+    }
+    if (h.kind === 'directory')
+        return 'Move the directory or update the knowledge reference.';
+    return undefined;
+}

package/dist/start-here.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"start-here.d.ts","sourceRoot":"","sources":["../src/start-here.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,eAAO,MAAM,iBAAiB,6BAA6B,CAAC;AAC5D,eAAO,MAAM,uBAAuB,mCAAmC,CAAC;AAExE,MAAM,MAAM,aAAa,GACrB,SAAS,GACT,aAAa,GACb,OAAO,GACP,KAAK,GACL,QAAQ,GACR,YAAY,GACZ,OAAO,GACP,SAAS,CAAC;AAEd,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,eAAe,GAAG,eAAe,CAAC;AAE1E,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,aAAa,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,wBAAwB;IACxB,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,OAAO,iBAAiB,CAAC;IACjC,uBAAuB,EAAE,MAAM,CAAC;IAChC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,YAAY,EAAE,SAAS,cAAc,EAAE,CAAC;IACxC,aAAa,EAAE,SAAS,cAAc,EAAE,CAAC;IACzC,uBAAuB,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,OAAO,uBAAuB,CAAC;IACvC,OAAO,EAAE,SAAS,eAAe,EAAE,CAAC;CACrC;AAwMD,wBAAgB,oBAAoB,CAAC,IAAI,CAAC,EAAE,aAAa,GAAG,IAAI,GAAG,gBAAgB,CAiBlF;AAED,wBAAgB,0BAA0B,IAAI,sBAAsB,CAEnE;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAkCpE;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAQhF"}
+{"version":3,"file":"start-here.d.ts","sourceRoot":"","sources":["../src/start-here.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,eAAO,MAAM,iBAAiB,6BAA6B,CAAC;AAC5D,eAAO,MAAM,uBAAuB,mCAAmC,CAAC;AAExE,MAAM,MAAM,aAAa,GACrB,SAAS,GACT,aAAa,GACb,OAAO,GACP,KAAK,GACL,QAAQ,GACR,YAAY,GACZ,OAAO,GACP,SAAS,CAAC;AAEd,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,eAAe,GAAG,eAAe,CAAC;AAE1E,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,aAAa,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,wBAAwB;IACxB,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,OAAO,iBAAiB,CAAC;IACjC,uBAAuB,EAAE,MAAM,CAAC;IAChC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,YAAY,EAAE,SAAS,cAAc,EAAE,CAAC;IACxC,aAAa,EAAE,SAAS,cAAc,EAAE,CAAC;IACzC,uBAAuB,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,OAAO,uBAAuB,CAAC;IACvC,OAAO,EAAE,SAAS,eAAe,EAAE,CAAC;CACrC;AAuMD,wBAAgB,oBAAoB,CAAC,IAAI,CAAC,EAAE,aAAa,GAAG,IAAI,GAAG,gBAAgB,CAiBlF;AAED,wBAAgB,0BAA0B,IAAI,sBAAsB,CAEnE;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAkCpE;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAQhF"}

package/dist/start-here.js

@@ -64,7 +64,7 @@ const FLOWS_PRIMARY = [
             'shrk dev start "<task>" --brief',
             'shrk dev status <id>',
             'shrk dev report <id>',
-            'shrk handoff --session <id>',
+            'shrk brief "<task>" --session <id> --mode handoff',
         ],
         safety: 'writes-drafts',
         docsLink: 'docs/dev-workflow.md',
@@ -121,7 +121,6 @@ const FLOWS_OPTIONAL = [
         whenToUse: 'You are about to tag.',
         commands: [
             'shrk release readiness',
-            'shrk demo package --validate',
             'shrk release smoke',
             'bun run release:preflight',
             'shrk release readiness --strict --preflight auto',

package/dist/substitute-placeholders.d.ts

@@ -0,0 +1,8 @@
+/**
+ * THE `{{var}}` placeholder substitution for declarative snippets — used by
+ * registration-hint previews and pack-helper plans. An unknown placeholder is
+ * left verbatim (never blanked), so a missing variable is visible in the
+ * rendered snippet instead of silently producing an empty string.
+ */
+export declare function substitutePlaceholders(snippet: string, vars: Readonly<Record<string, string>>): string;
+//# sourceMappingURL=substitute-placeholders.d.ts.map

package/dist/substitute-placeholders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"substitute-placeholders.d.ts","sourceRoot":"","sources":["../src/substitute-placeholders.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,MAAM,CAItG"}

package/dist/substitute-placeholders.js

@@ -0,0 +1,9 @@
+/**
+ * THE `{{var}}` placeholder substitution for declarative snippets — used by
+ * registration-hint previews and pack-helper plans. An unknown placeholder is
+ * left verbatim (never blanked), so a missing variable is visible in the
+ * rendered snippet instead of silently producing an empty string.
+ */
+export function substitutePlaceholders(snippet, vars) {
+    return snippet.replace(/\{\{\s*([A-Za-z0-9_]+)\s*\}\}/g, (_m, key) => vars[key] !== undefined ? vars[key] : `{{${key}}}`);
+}

package/dist/symbol-index.d.ts

@@ -1,3 +1,4 @@
+import type { ISymbolMemberEntry } from './symbol-member-entry.js';
 export declare const SYMBOL_INDEX_SCHEMA = "sharkcraft.symbol-index/v1";
 export declare enum SymbolDeclarationKind {
     Class = "class",
@@ -22,6 +23,10 @@ export declare enum SymbolResolution {
     ExactExport = "exact-export",
     ExactLocal = "exact-local",
     ExactReExport = "exact-reexport",
+    /** `Owner.member` where the owner is exported from this file. */
+    ExactMember = "exact-member",
+    /** `Owner.member` where the owner is declared here but not exported. */
+    ExactLocalMember = "exact-local-member",
     ProbableText = "probable-text",
     Missing = "missing",
     Unknown = "unknown"
@@ -32,6 +37,13 @@ export interface ISymbolEntry {
     visibility: SymbolVisibility;
     /** Line (1-based) where the declaration starts. */
     line: number;
+    /**
+     * Character span of the declaration, when it is one (a bare `export { x }`
+     * has none). A reference's `contains` / `matches` reads this span, so a claim
+     * about a function is checked against the function, not the whole file.
+     */
+    start?: number;
+    end?: number;
 }
 export interface IReExportEntry {
     /** Symbol name as exposed (the "name" half of `export { foo } from`). */
@@ -49,6 +61,12 @@ export interface IReExportEntry {
     from: string;
     /** If true, this is `export * from "..."`. */
     star: boolean;
+    /**
+     * If true, this is a NAMESPACE re-export, `export * as ns from "..."`: `name`
+     * (`ns`) binds the whole target module, not a declaration inside it. `star`
+     * is false — the target's names are NOT forwarded one by one.
+     */
+    namespace?: boolean;
     line: number;
 }
 export interface ISymbolIndex {
@@ -59,6 +77,12 @@ export interface ISymbolIndex {
     exports: readonly ISymbolEntry[];
     locals: readonly ISymbolEntry[];
     reExports: readonly IReExportEntry[];
+    /**
+     * Members of top-level declarations, one level deep (class / interface / enum
+     * / namespace / `const x = { … }`). Additive and optional: the graph indexer
+     * reads only `exports` / `locals` / `reExports`, so its node set is unchanged.
+     */
+    members?: readonly ISymbolMemberEntry[];
     /** True when a default export exists. */
     hasDefaultExport: boolean;
     /** Default export name where identifiable (`export default function foo()` → "foo"). */
@@ -77,6 +101,15 @@ export declare function resolveSymbolInFile(fileAbsPath: string, symbol: string)
     resolution: SymbolResolution;
     message: string;
     entry?: ISymbolEntry;
+    /** Set for an `Owner.member` resolution. */
+    member?: ISymbolMemberEntry;
+    /** A qualified spelling that WOULD resolve — `Foo.bar` for a bare member name. */
+    suggestedSymbol?: string;
+    /** The resolved declaration's character span, for content assertions. */
+    span?: {
+        start: number;
+        end: number;
+    };
 };
 export interface ISymbolMatch {
     /** Absolute file path. */

package/dist/symbol-index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"symbol-index.d.ts","sourceRoot":"","sources":["../src/symbol-index.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,mBAAmB,+BAA+B,CAAC;AAEhE,oBAAY,qBAAqB;IAC/B,KAAK,UAAU;IACf,QAAQ,aAAa;IACrB,SAAS,cAAc;IACvB,SAAS,eAAe;IACxB,IAAI,SAAS;IACb,KAAK,UAAU;IACf,GAAG,QAAQ;IACX,GAAG,QAAQ;IACX,MAAM,WAAW;IACjB,SAAS,cAAc;IACvB,OAAO,YAAY;CACpB;AAED,oBAAY,gBAAgB;IAC1B,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,QAAQ,cAAc;IACtB,OAAO,YAAY;CACpB;AAED,oBAAY,gBAAgB;IAC1B,WAAW,iBAAiB;IAC5B,UAAU,gBAAgB;IAC1B,aAAa,mBAAmB;IAChC,YAAY,kBAAkB;IAC9B,OAAO,YAAY;IACnB,OAAO,YAAY;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,qBAAqB,CAAC;IAC5B,UAAU,EAAE,gBAAgB,CAAC;IAC7B,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,cAAc;IAC7B,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,8CAA8C;IAC9C,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,OAAO,mBAAmB,CAAC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,SAAS,YAAY,EAAE,CAAC;IACjC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAC;IAChC,SAAS,EAAE,SAAS,cAAc,EAAE,CAAC;IACrC,yCAAyC;IACzC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,wFAAwF;IACxF,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,UAAU,kBAAkB;IAC1B,kEAAkE;IAClE,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAqCD,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,MAAM,EAChB,OAAO,GAAE,kBAAuB,GAC/B,YAAY,CA0Ld;AAiBD;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM,GACb;IAAE,UAAU,EAAE,gBAAgB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,YAAY,CAAA;CAAE,CA+CzE;AAMD,MAAM,WAAW,YAAY;IAC3B,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,gBAAgB,CAAC;IAC7B,iCAAiC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,IAAI,CAAC,EAAE,qBAAqB,CAAC;IAC7B,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,sDAAsD;IACtD,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,6BAA6B,CAAC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,YAAY,EAAE,SAAS,YAAY,EAAE,CAAC;IACtC,iEAAiE;IACjE,WAAW,EAAE,SAAS,YAAY,EAAE,CAAC;IACrC;mDAC+C;IAC/C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6BAA6B;IAC7B,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC;AAoCD,MAAM,WAAW,kBAAkB;IACjC,iDAAiD;IACjD,QAAQ,CAAC,EAAE,YAAY,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,IAAI,GAAG,MAAM,GAAG,MAAM,CAAC;IAChF,uCAAuC;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,kBAAuB,GAC/B,mBAAmB,CAsGrB"}
+{"version":3,"file":"symbol-index.d.ts","sourceRoot":"","sources":["../src/symbol-index.ts"],"names":[],"mappings":"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"}

package/dist/symbol-index.js

@@ -14,6 +14,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import * as nodePath from 'node:path';
 import * as ts from 'typescript';
+import { SymbolMemberKind } from "./symbol-member-kind.js";
 export const SYMBOL_INDEX_SCHEMA = 'sharkcraft.symbol-index/v1';
 export var SymbolDeclarationKind;
 (function (SymbolDeclarationKind) {
@@ -41,10 +42,139 @@ export var SymbolResolution;
     SymbolResolution["ExactExport"] = "exact-export";
     SymbolResolution["ExactLocal"] = "exact-local";
     SymbolResolution["ExactReExport"] = "exact-reexport";
+    /** `Owner.member` where the owner is exported from this file. */
+    SymbolResolution["ExactMember"] = "exact-member";
+    /** `Owner.member` where the owner is declared here but not exported. */
+    SymbolResolution["ExactLocalMember"] = "exact-local-member";
     SymbolResolution["ProbableText"] = "probable-text";
     SymbolResolution["Missing"] = "missing";
     SymbolResolution["Unknown"] = "unknown";
 })(SymbolResolution || (SymbolResolution = {}));
+/** A name that can address a member statically (computed names cannot). */
+function staticMemberName(name) {
+    if (!name)
+        return undefined;
+    if (ts.isIdentifier(name) ||
+        ts.isPrivateIdentifier(name) ||
+        ts.isStringLiteral(name) ||
+        ts.isNumericLiteral(name)) {
+        return name.text;
+    }
+    return undefined;
+}
+function hasStaticModifier(node) {
+    if (!ts.canHaveModifiers(node))
+        return false;
+    return !!ts.getModifiers(node)?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword);
+}
+/** Strip `as const` / `satisfies X` / parentheses around an initializer. */
+function unwrapInitializer(e) {
+    let cur = e;
+    while (ts.isAsExpression(cur) ||
+        ts.isSatisfiesExpression(cur) ||
+        ts.isParenthesizedExpression(cur) ||
+        ts.isTypeAssertionExpression(cur)) {
+        cur = cur.expression;
+    }
+    return cur;
+}
+/** Collect the one-level members of a top-level statement into `out`. */
+function collectMembers(sf, stmt, out) {
+    const push = (owner, node, name, kind, isStatic = false) => {
+        if (!name)
+            return;
+        out.push({
+            owner,
+            name,
+            kind,
+            static: isStatic,
+            line: sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1,
+            start: node.getStart(sf),
+            end: node.getEnd(),
+        });
+    };
+    if (ts.isClassDeclaration(stmt) && stmt.name) {
+        const owner = stmt.name.text;
+        for (const m of stmt.members) {
+            if (ts.isMethodDeclaration(m)) {
+                push(owner, m, staticMemberName(m.name), SymbolMemberKind.Method, hasStaticModifier(m));
+            }
+            else if (ts.isPropertyDeclaration(m)) {
+                push(owner, m, staticMemberName(m.name), SymbolMemberKind.Property, hasStaticModifier(m));
+            }
+            else if (ts.isGetAccessorDeclaration(m) || ts.isSetAccessorDeclaration(m)) {
+                push(owner, m, staticMemberName(m.name), SymbolMemberKind.Accessor, hasStaticModifier(m));
+            }
+        }
+        return;
+    }
+    if (ts.isInterfaceDeclaration(stmt)) {
+        for (const m of stmt.members) {
+            if (ts.isPropertySignature(m) || ts.isMethodSignature(m)) {
+                push(stmt.name.text, m, staticMemberName(m.name), SymbolMemberKind.InterfaceMember);
+            }
+        }
+        return;
+    }
+    if (ts.isEnumDeclaration(stmt)) {
+        for (const m of stmt.members) {
+            push(stmt.name.text, m, staticMemberName(m.name), SymbolMemberKind.EnumMember);
+        }
+        return;
+    }
+    if (ts.isModuleDeclaration(stmt) &&
+        ts.isIdentifier(stmt.name) &&
+        stmt.body !== undefined &&
+        ts.isModuleBlock(stmt.body)) {
+        const owner = stmt.name.text;
+        for (const s of stmt.body.statements) {
+            if (ts.isVariableStatement(s)) {
+                for (const d of s.declarationList.declarations) {
+                    if (ts.isIdentifier(d.name))
+                        push(owner, d, d.name.text, SymbolMemberKind.NamespaceMember);
+                }
+            }
+            else if ((ts.isFunctionDeclaration(s) ||
+                ts.isClassDeclaration(s) ||
+                ts.isInterfaceDeclaration(s) ||
+                ts.isTypeAliasDeclaration(s) ||
+                ts.isEnumDeclaration(s)) &&
+                s.name) {
+                push(owner, s, s.name.text, SymbolMemberKind.NamespaceMember);
+            }
+        }
+        return;
+    }
+    if (ts.isVariableStatement(stmt)) {
+        for (const d of stmt.declarationList.declarations) {
+            if (!ts.isIdentifier(d.name) || !d.initializer)
+                continue;
+            const init = unwrapInitializer(d.initializer);
+            if (!ts.isObjectLiteralExpression(init))
+                continue;
+            for (const p of init.properties) {
+                if (ts.isPropertyAssignment(p) ||
+                    ts.isShorthandPropertyAssignment(p) ||
+                    ts.isMethodDeclaration(p) ||
+                    ts.isGetAccessorDeclaration(p) ||
+                    ts.isSetAccessorDeclaration(p)) {
+                    push(d.name.text, p, staticMemberName(p.name), SymbolMemberKind.ObjectKey);
+                }
+            }
+        }
+    }
+}
+/** `Owner.member` → its halves (`.prototype.` is stripped); null for a bare name. */
+function splitQualifiedSymbol(symbol) {
+    const cleaned = symbol.replace(/\.prototype\./g, '.');
+    const dot = cleaned.indexOf('.');
+    if (dot <= 0 || dot === cleaned.length - 1)
+        return null;
+    return { owner: cleaned.slice(0, dot), member: cleaned.slice(dot + 1) };
+}
+function spanOf(e) {
+    return e.start !== undefined && e.end !== undefined ? { start: e.start, end: e.end } : undefined;
+}
 function pickKindFromNode(node) {
     if (ts.isClassDeclaration(node))
         return SymbolDeclarationKind.Class;
@@ -144,7 +274,11 @@ export function buildSymbolIndex(fileAbsPath, content, options = {}) {
     const reExportsList = [];
     let hasDefaultExport = false;
     let defaultExportName;
+    const membersList = [];
     for (const stmt of sf.statements) {
+        // One level of members under each top-level owner — additive; nothing
+        // below reads them, so the export/local/re-export sets are unchanged.
+        collectMembers(sf, stmt, membersList);
         // export { foo, bar } from "./mod"  /  export * from "./mod"
         if (ts.isExportDeclaration(stmt)) {
             const fromSpec = stmt.moduleSpecifier && ts.isStringLiteral(stmt.moduleSpecifier)
@@ -160,6 +294,18 @@ export function buildSymbolIndex(fileAbsPath, content, options = {}) {
                 });
                 continue;
             }
+            // `export * as ns from "./mod"` — one name bound to the whole module.
+            // Recorded (it used to fall through silently, so `ns` was on no surface).
+            if (stmt.exportClause && ts.isNamespaceExport(stmt.exportClause) && fromSpec) {
+                reExportsList.push({
+                    name: stmt.exportClause.name.text,
+                    from: fromSpec,
+                    star: false,
+                    namespace: true,
+                    line: lineOf(sf, stmt),
+                });
+                continue;
+            }
             if (stmt.exportClause && ts.isNamedExports(stmt.exportClause)) {
                 for (const spec of stmt.exportClause.elements) {
                     const name = spec.name.text;
@@ -212,6 +358,8 @@ export function buildSymbolIndex(fileAbsPath, content, options = {}) {
                     kind: pickKindFromNode(stmt),
                     visibility: SymbolVisibility.Default,
                     line: lineOf(sf, stmt),
+                    start: stmt.getStart(sf),
+                    end: stmt.getEnd(),
                 });
             }
             continue;
@@ -228,6 +376,8 @@ export function buildSymbolIndex(fileAbsPath, content, options = {}) {
                     kind,
                     visibility: exported ? SymbolVisibility.Export : SymbolVisibility.Local,
                     line: lineOf(sf, d),
+                    start: d.getStart(sf),
+                    end: d.getEnd(),
                 };
                 (exported ? exportsList : localsList).push(entry);
             }
@@ -246,6 +396,8 @@ export function buildSymbolIndex(fileAbsPath, content, options = {}) {
                 kind: pickKindFromNode(stmt),
                 visibility: exported ? SymbolVisibility.Export : SymbolVisibility.Local,
                 line: lineOf(sf, stmt),
+                start: stmt.getStart(sf),
+                end: stmt.getEnd(),
             };
             (exported ? exportsList : localsList).push(entry);
             continue;
@@ -256,6 +408,8 @@ export function buildSymbolIndex(fileAbsPath, content, options = {}) {
                 kind: pickKindFromNode(stmt),
                 visibility: exported ? SymbolVisibility.Export : SymbolVisibility.Local,
                 line: lineOf(sf, stmt),
+                start: stmt.getStart(sf),
+                end: stmt.getEnd(),
             };
             (exported ? exportsList : localsList).push(entry);
         }
@@ -267,6 +421,7 @@ export function buildSymbolIndex(fileAbsPath, content, options = {}) {
         exports: exportsList,
         locals: localsList,
         reExports: reExportsList,
+        members: membersList,
         hasDefaultExport,
         ...(defaultExportName ? { defaultExportName } : {}),
     };
@@ -294,11 +449,14 @@ export function resolveSymbolInFile(fileAbsPath, symbol) {
         return { resolution: SymbolResolution.Unknown, message: 'No symbol provided.' };
     }
     const idx = buildSymbolIndex(fileAbsPath);
+    const qualified = splitQualifiedSymbol(symbol);
     if (!idx.parsed) {
-        // Text-scan fallback.
+        // Text-scan fallback. A qualified name rarely appears literally, so look
+        // for the member token.
+        const token = qualified ? qualified.member : symbol;
         try {
             const text = readFileSync(fileAbsPath, 'utf8');
-            if (text.includes(symbol)) {
+            if (text.includes(token)) {
                 return {
                     resolution: SymbolResolution.ProbableText,
                     message: `\`${symbol}\` appears in the file text but the AST could not be parsed.`,
@@ -310,27 +468,57 @@ export function resolveSymbolInFile(fileAbsPath, symbol) {
             return { resolution: SymbolResolution.Unknown, message: 'Could not read file.' };
         }
     }
+    if (qualified)
+        return resolveMemberInIndex(idx, qualified.owner, qualified.member, symbol);
     const exp = idx.exports.find((e) => e.name === symbol);
     if (exp) {
+        const span = spanOf(exp);
         return {
             resolution: SymbolResolution.ExactExport,
             message: `Exact exported declaration of \`${symbol}\` (${exp.kind}) at line ${exp.line}.`,
             entry: exp,
+            ...(span ? { span } : {}),
         };
     }
     const local = idx.locals.find((e) => e.name === symbol);
     if (local) {
+        const span = spanOf(local);
         return {
             resolution: SymbolResolution.ExactLocal,
             message: `Local (non-exported) declaration of \`${symbol}\` (${local.kind}) at line ${local.line}.`,
             entry: local,
+            ...(span ? { span } : {}),
         };
     }
     const re = idx.reExports.find((r) => r.name === symbol || (r.star && r.from.length > 0));
     if (re) {
         return {
             resolution: SymbolResolution.ExactReExport,
-            message: `Re-exported via \`export${re.star ? ' *' : ` { ${symbol} }`} from "${re.from}"\` at line ${re.line}.`,
+            message: `Re-exported via \`export${re.star ? ' *' : re.namespace ? ` * as ${symbol}` : ` { ${symbol} }`} from "${re.from}"\` at line ${re.line}.`,
+        };
+    }
+    // Not a top-level name — but it may be a MEMBER. That stays Missing (a bare
+    // name never silently widens to members), but with a route forward instead
+    // of telling the author a true statement is false.
+    const asMember = (idx.members ?? []).filter((m) => m.name === symbol);
+    if (asMember.length > 0) {
+        const owners = [...new Set(asMember.map((m) => m.owner))];
+        if (owners.length === 1) {
+            const m = asMember[0];
+            // `object-key` → "an object key" (the article follows the word, not the enum spelling).
+            const kindWords = String(m.kind).replace(/-/g, ' ');
+            const article = /^[aeiou]/i.test(kindWords) ? 'an' : 'a';
+            return {
+                resolution: SymbolResolution.Missing,
+                message: `\`${symbol}\` is ${article} ${kindWords} of \`${m.owner}\` (line ${m.line}), not a top-level declaration — pin it as \`${m.owner}.${symbol}\`.`,
+                suggestedSymbol: `${m.owner}.${symbol}`,
+            };
+        }
+        return {
+            resolution: SymbolResolution.Missing,
+            message: `\`${symbol}\` is not a top-level declaration; it is a member of ${owners
+                .map((o) => `\`${o}\``)
+                .join(', ')} — pin it as \`<Owner>.${symbol}\`.`,
         };
     }
     return {
@@ -338,6 +526,56 @@ export function resolveSymbolInFile(fileAbsPath, symbol) {
         message: `Symbol \`${symbol}\` not declared or re-exported in this file.`,
     };
 }
+/** Resolve `owner.member` against one parsed file's index. */
+function resolveMemberInIndex(idx, owner, member, original) {
+    const ownerExp = idx.exports.find((e) => e.name === owner);
+    const ownerEntry = ownerExp ?? idx.locals.find((e) => e.name === owner);
+    if (!ownerEntry) {
+        const re = idx.reExports.find((r) => r.name === owner || r.star);
+        if (re) {
+            // Its members are declared in another file — never a false Ok.
+            return {
+                resolution: SymbolResolution.Unknown,
+                message: `\`${owner}\` is re-exported here from "${re.from}", so its members live elsewhere — pin the declaring file to check \`${original}\`.`,
+            };
+        }
+        return {
+            resolution: SymbolResolution.Missing,
+            message: `Owner \`${owner}\` of \`${original}\` is not declared in this file.`,
+        };
+    }
+    if (member.includes('.')) {
+        return {
+            resolution: SymbolResolution.Unknown,
+            message: `\`${original}\` is nested more than one level; only direct members (\`${owner}.<member>\`) are indexed.`,
+        };
+    }
+    const members = (idx.members ?? []).filter((m) => m.owner === owner);
+    const hit = members.find((m) => m.name === member);
+    if (hit) {
+        return {
+            resolution: ownerExp ? SymbolResolution.ExactMember : SymbolResolution.ExactLocalMember,
+            message: `\`${original}\` resolves to the ${hit.kind} \`${member}\` of \`${owner}\` at line ${hit.line}.`,
+            entry: ownerEntry,
+            member: hit,
+            span: { start: hit.start, end: hit.end },
+        };
+    }
+    if (ownerEntry.kind === SymbolDeclarationKind.Unknown && members.length === 0) {
+        // `export { Foo }` of an imported name — declared in another file.
+        return {
+            resolution: SymbolResolution.Unknown,
+            message: `\`${owner}\` is only re-exported here (\`export { ${owner} }\`) — pin its declaring file to check \`${original}\`.`,
+        };
+    }
+    const shown = members.slice(0, 12).map((m) => m.name);
+    const more = members.length > shown.length ? `, … (+${members.length - shown.length})` : '';
+    return {
+        resolution: SymbolResolution.Missing,
+        message: `\`${owner}\` (${ownerEntry.kind}, line ${ownerEntry.line}) has no member \`${member}\`` +
+            (shown.length > 0 ? ` — its members: ${shown.join(', ')}${more}.` : ' — it declares no indexed members.'),
+    };
+}
 // ── Project-wide symbol resolution ──────────────────────────────────────
 import { readdirSync, statSync } from 'node:fs';
 const DEFAULT_SKIP_DIRS = new Set([

package/dist/symbol-member-entry.d.ts

@@ -0,0 +1,26 @@
+import type { SymbolMemberKind } from './symbol-member-kind.js';
+/**
+ * One member of a top-level declaration: a class method / property / accessor,
+ * an interface member, an enum member, a namespace declaration, or a key of a
+ * `const x = { … }` object literal.
+ *
+ * The symbol index used to walk top-level statements only, so a reference to a
+ * method that plainly exists reported "not declared" forever and the only
+ * escape was coarsening it to the whole file — losing exactly the precision a
+ * symbol reference exists for. Members make `Owner.member` addressable.
+ */
+export interface ISymbolMemberEntry {
+    /** The enclosing top-level declaration's name (`Foo` for `Foo.bar`). */
+    owner: string;
+    name: string;
+    kind: SymbolMemberKind;
+    /** True for a `static` class member. */
+    static: boolean;
+    /** Line (1-based) where the member starts. */
+    line: number;
+    /** Character offset of the member's first token. */
+    start: number;
+    /** Character offset just past the member's last token. */
+    end: number;
+}
+//# sourceMappingURL=symbol-member-entry.d.ts.map

package/dist/symbol-member-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-member-entry.d.ts","sourceRoot":"","sources":["../src/symbol-member-entry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;;;;;GASG;AACH,MAAM,WAAW,kBAAkB;IACjC,wEAAwE;IACxE,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,gBAAgB,CAAC;IACvB,wCAAwC;IACxC,MAAM,EAAE,OAAO,CAAC;IAChB,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,oDAAoD;IACpD,KAAK,EAAE,MAAM,CAAC;IACd,0DAA0D;IAC1D,GAAG,EAAE,MAAM,CAAC;CACb"}

package/dist/symbol-member-entry.js

@@ -0,0 +1 @@
+export {};

package/dist/symbol-member-kind.d.ts

@@ -0,0 +1,14 @@
+/**
+ * What kind of member {@link ISymbolMemberEntry} indexes — one level deep
+ * under a top-level owner.
+ */
+export declare enum SymbolMemberKind {
+    Method = "method",
+    Property = "property",
+    Accessor = "accessor",
+    EnumMember = "enum-member",
+    InterfaceMember = "interface-member",
+    NamespaceMember = "namespace-member",
+    ObjectKey = "object-key"
+}
+//# sourceMappingURL=symbol-member-kind.d.ts.map

package/dist/symbol-member-kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-member-kind.d.ts","sourceRoot":"","sources":["../src/symbol-member-kind.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,gBAAgB;IAC1B,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,QAAQ,aAAa;IACrB,UAAU,gBAAgB;IAC1B,eAAe,qBAAqB;IACpC,eAAe,qBAAqB;IACpC,SAAS,eAAe;CACzB"}