simt-dev 0.6.3 → 0.7.1

package/src/hooks/gates.mjs

@@ -105,49 +105,6 @@ export function getGate(name) {
   return GATES[name] ?? null;
 }
 
-/**
- * A gate a repo cannot run is a FAILURE, never a skip.
- *
- * This is the load-bearing decision of the whole dispatcher. A gate that
- * silently does nothing is indistinguishable from a gate that passed, and the
- * documented consequence in this estate is an agent reaching for
- * `--no-verify` - a repository removed its tests from pre-commit precisely
- * because they were slow, and slow-plus-silent is what teaches everyone that
- * hooks are advisory.
- */
-export function unresolved(name, { hasScript, binary, command, stack }) {
-  const gate = getGate(name);
-  if (gate === null) {
-    return {
-      gate: name,
-      reason: `unknown gate; the shared dispatcher knows: ${Object.keys(GATES).sort().join(', ')}`,
-      remedy: `remove "${name}" from ${MANIFEST_FILE} gates`,
-    };
-  }
-  if (gate.kind === 'script' && !hasScript(gate.script)) {
-    return {
-      gate: name,
-      reason: `no "${gate.script}" script in package.json`,
-      remedy: `add the script, or remove "${name}" from ${MANIFEST_FILE} gates`,
-    };
-  }
-  if (gate.kind === 'command' && !command) {
-    return {
-      gate: name,
-      reason: `no command declared for this gate in ${MANIFEST_FILE}`,
-      remedy: `set gates.commands["${name}"] to the command that proves it, or remove "${name}" from ${MANIFEST_FILE} gates`,
-    };
-  }
-  if (gate.kind === 'staged' && !binary) {
-    return {
-      gate: name,
-      reason: `${gate.tools.join('/')} is not installed in node_modules/.bin`,
-      remedy: `run the repo install command, or remove "format" from ${MANIFEST_FILE} gates`,
-    };
-  }
-  return null;
-}
-
 export function gateNames() {
   return Object.keys(GATES).sort();
 }

package/src/hooks/resolve.mjs

@@ -14,14 +14,9 @@ import { access } from 'node:fs/promises';
 import { constants } from 'node:fs';
 import { join } from 'node:path';
 
-import { FORMATTABLE, GATES } from './gates.mjs';
+import { FORMATTABLE, GATES, gateNames } from './gates.mjs';
 import { MANIFEST_FILE } from '../name.mjs';
 
-/** Gate names the shared dispatcher knows, sorted. */
-export function knownGates() {
-  return Object.keys(GATES).sort();
-}
-
 /** Is this path an executable file? */
 async function isExecutable(path) {
   try {
@@ -68,7 +63,7 @@ export function hasScript(pkg, script) {
  * @returns {Promise<{ok: true, argv: string[], kind: string, detail: string}
  *                  | {ok: false, gate: string, kind: string, reason: string, remedy: string}>}
  */
-export async function resolveGate(gate, { root, pkg, staged, commands }) {
+export async function resolveGate(gate, { root, pkg, staged, commands, runner = null }) {
   const name = gate.name;
   const declared = commands?.[name];
 
@@ -172,11 +167,17 @@ export async function resolveGate(gate, { root, pkg, staged, commands }) {
         remedy: `add "${script}" to scripts, or remove "${name}" from ${MANIFEST_FILE} gates`,
       };
     }
+    // Q31: script gates run through the repo's own manager — `pnpm run`, not
+    // `npm run`, in a pnpm checkout. The default stays npm for callers that do
+    // not report one (older capabilities, hand-built contexts).
+    const { runScriptArgv, runScript } = await import('../ecosystem/node-runner.mjs');
+    const manager = runner ?? pkg?.packageManager?.split('@')?.[0] ?? 'npm';
+    const known = ['npm', 'pnpm', 'yarn', 'bun'].includes(manager) ? manager : 'npm';
     return {
       ok: true,
       kind: gate.kind,
-      argv: ['npm', 'run', '--silent', script],
-      detail: `npm run ${script}`,
+      argv: runScriptArgv(known, script),
+      detail: runScript(known, script),
     };
   }
 
@@ -197,7 +198,7 @@ export async function resolveGate(gate, { root, pkg, staged, commands }) {
     gate: name,
     kind: 'unknown',
     reason: `unknown gate kind "${gate.kind}"`,
-    remedy: `this is a bug in simt-dev; known gates: ${knownGates().join(', ')}`,
+    remedy: `this is a bug in simt-dev; )}', ')}`,
   };
 }
 

package/src/hooks/shim.mjs

@@ -36,8 +36,11 @@ export const SHIM_MARKER = '# Generated by simt-dev. Do not edit.';
 /** Events the shared dispatcher knows how to run. */
 export const EVENTS = ['pre-commit', 'pre-push'];
 
-/** Directory the shims are written to inside a repo. */
-export const HOOKS_DIR = '.simt-hooks';
+/** Directory the shims are written to inside a repo, inside the state directory (ADR-122). */
+export const HOOKS_DIR = '.simt/hooks';
+
+/** The top-level shim directory that preceded the move into the state directory (ADR-122). */
+export const HOOKS_DIR_LEGACY = '.simt-hooks';
 
 /** Name of the git config key that points at the shim directory. */
 export const HOOKS_PATH_KEY = 'core.hooksPath';
@@ -48,14 +51,17 @@ export function fileFor(event) {
 
 /**
  * @param {string} event one of EVENTS
- * @param {{npm?: boolean, version?: string}} [opts]
+ * @param {{npm?: boolean, manager?: string|null, version?: string}} [opts]
  *   `npm` is whether the repository has a package.json: it decides the remedy's install
  *   (a devDependency where one exists, the release binary into the repository where
- *   there is no node_modules to pin in). `version` defaults to the running package's own version,
- *   so a shim generated by 0.2.0 names 0.2.0 in its remedy and CI install.
+ *   there is no node_modules to pin in). `manager` names the Node manager when one
+ *   was resolved (Q31: `pnpm add -D`, not `npm i -D`, in a pnpm checkout); it wins
+ *   over the legacy `npm` boolean so old callers keep their bytes. `version`
+ *   defaults to the running package's own version, so a shim generated by 0.2.0
+ *   names 0.2.0 in its remedy and CI install.
  * @returns {string} POSIX sh source, LF-terminated, executable
  */
-export function renderShim(event, { npm = true, version } = {}) {
+export function renderShim(event, { npm = true, manager = null, version } = {}) {
   if (!EVENTS.includes(event)) {
     throw new Error(`unknown hook event ${event}; known: ${EVENTS.join(', ')}`);
   }
@@ -65,7 +71,8 @@ export function renderShim(event, { npm = true, version } = {}) {
   // installs it there; one without (Gradle, Connect IQ) has no node_modules to pin in,
   // so the remedy downloads the release binary into the repository - the same pinned
   // bytes CI gets, and one that needs no npm and no node on the machine (ADR-098).
-  const install = npm ? `npm i -D ${PACKAGE_NAME}@${v}` : localInstall(v);
+  const addDev = { npm: `npm i -D ${PACKAGE_NAME}@${v}`, pnpm: `pnpm add -D ${PACKAGE_NAME}@${v}`, yarn: `yarn add -D ${PACKAGE_NAME}@${v}`, bun: `bun add -d ${PACKAGE_NAME}@${v}` }[manager ?? (npm ? 'npm' : '')];
+  const install = addDev ?? (npm && !manager ? `npm i -D ${PACKAGE_NAME}@${v}` : localInstall(v));
   const D = '$';
   return `#!/bin/sh
 ${SHIM_MARKER}
@@ -103,11 +110,12 @@ ${renderLocator(`hooks run ${event} --root "${D}ROOT"`, {
  * @param {{npm?: boolean, version?: string}} [opts]
  * @returns {string} POSIX sh source, LF-terminated
  */
-export function renderEvidenceShim({ npm = true, version } = {}) {
+export function renderEvidenceShim({ npm = true, manager = null, version } = {}) {
   const v = version ?? packageVersion();
   // The same split as renderShim: a devDependency where one exists, the release
   // binary into the repository where there is no node_modules to pin in.
-  const install = npm ? `npm i -D ${PACKAGE_NAME}@${v}` : localInstall(v);
+  const addDev = { npm: `npm i -D ${PACKAGE_NAME}@${v}`, pnpm: `pnpm add -D ${PACKAGE_NAME}@${v}`, yarn: `yarn add -D ${PACKAGE_NAME}@${v}`, bun: `bun add -d ${PACKAGE_NAME}@${v}` }[manager ?? (npm ? 'npm' : '')];
+  const install = addDev ?? (npm && !manager ? `npm i -D ${PACKAGE_NAME}@${v}` : localInstall(v));
   const D = '$';
   return `#!/bin/sh
 ${SHIM_MARKER}

package/src/identity.mjs

@@ -25,10 +25,12 @@
 // tracked file is not something an adopting command should do silently.
 
 import { execFile } from 'node:child_process';
-import { readFile, stat } from 'node:fs/promises';
+import { readFile, stat, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { promisify } from 'node:util';
 
+import { journaledGitConfig, journaledWriteFile } from './journal.mjs';
+
 const exec = promisify(execFile);
 
 /** The file, at the repository root. Named for what it is: a git config fragment. */
@@ -166,13 +168,67 @@ export async function includesOwnIdentity(root) {
  * break. Two of the repositories here had exactly that, and both worked only because
  * the sibling checkout happened to exist at the expected relative path.
  *
+ * A caller-supplied journal records the key so `undo` restores the routing (R49);
+ * without one the write stays unrecorded, as `commitJournal` needs it (review 0003
+ * Q30). The journaled path sets through `journaledGitConfig`, which records one
+ * key's before and after - the single-value case, and the only shape this tool
+ * writes.
+ *
  * @param {string} root
+ * @param {Array} [journal]
  * @returns {Promise<void>}
  */
-export async function includeOwnIdentity(root) {
+export async function includeOwnIdentity(root, journal = null) {
+  // A directory that is not a git work tree has no config to route. The lenient
+  // `git()` used to swallow the failure here, and an adoption of a plain directory
+  // must keep working: there is simply nothing to point at.
+  if ((await git(root, ['rev-parse', '--is-inside-work-tree'])) !== 'true') return;
+  if (journal) {
+    await journaledGitConfig(root, journal, INCLUDE_KEY, `../${IDENTITY_FILE}`);
+    return;
+  }
   await git(root, ['config', '--local', '--replace-all', INCLUDE_KEY, `../${IDENTITY_FILE}`]);
 }
 
+/**
+ * Whether .gitignore already names the identity file. The plan needs the answer
+ * before anything is written: a line the run does not print is a write the reader
+ * approves from the diff afterwards (review 0003 Q30).
+ *
+ * @param {string} root
+ * @returns {Promise<boolean>}
+ */
+export async function identityIgnored(root) {
+  let text;
+  try {
+    text = await readFile(join(root, '.gitignore'), 'utf8');
+  } catch {
+    return false;
+  }
+  return text.split('\n').map((l) => l.trim()).includes(IDENTITY_FILE);
+}
+
+/**
+ * The .gitignore bytes with the identity entry appended, or null when it is
+ * already there. One owner for the edit's shape: `ignoreIdentity` writes it and
+ * `init --diff` previews it, so the two cannot disagree about the bytes (review
+ * 0003 Q30).
+ *
+ * @param {string} text the current bytes, '' when the file is absent
+ * @returns {string|null}
+ */
+export function gitignoreWithIdentity(text) {
+  if (text.split('\n').map((l) => l.trim()).includes(IDENTITY_FILE)) return null;
+  const prefix = text === '' || text.endsWith('\n') ? '' : '\n';
+  return (
+    `${text}${prefix}\n` +
+    '# Per-developer git identity, written by `simt init`. Not a file to share:\n' +
+    '# it carries whoever is committing into the tree, and a repository has more than\n' +
+    '# one of those.\n' +
+    `${IDENTITY_FILE}\n`
+  );
+}
+
 /**
  * Add the identity file to .gitignore, if it is not already there.
  *
@@ -181,10 +237,14 @@ export async function includeOwnIdentity(root) {
  * it means nothing, and appending a duplicate of an entry that is already present
  * is how a file ends up listed twice.
  *
+ * A caller-supplied journal records the edit so `undo` restores it (R49); without
+ * one the write stays unrecorded, as `commitJournal` needs it (review 0003 Q30).
+ *
  * @param {string} root
+ * @param {Array} [journal]
  * @returns {Promise<boolean>} whether the file was changed
  */
-export async function ignoreIdentity(root) {
+export async function ignoreIdentity(root, journal = null) {
   const path = join(root, '.gitignore');
   let text;
   try {
@@ -192,16 +252,37 @@ export async function ignoreIdentity(root) {
   } catch {
     text = '';
   }
-  const already = text.split('\n').map((l) => l.trim()).includes(IDENTITY_FILE);
-  if (already) return false;
-  const prefix = text === '' || text.endsWith('\n') ? '' : '\n';
-  const block =
-    `${prefix}\n` +
-    '# Per-developer git identity, written by `simt init`. Not a file to share:\n' +
-    '# it carries whoever is committing into the tree, and a repository has more than\n' +
-    '# one of those.\n' +
-    `${IDENTITY_FILE}\n`;
-  const { writeFile } = await import('node:fs/promises');
-  await writeFile(path, text + block);
+  const next = gitignoreWithIdentity(text);
+  if (next === null) return false;
+  if (journal) await journaledWriteFile(root, journal, path, next);
+  else await writeFile(path, next);
   return true;
-}
+}
+/**
+ * The `user.*` keys the repository's own config sets, which is the one place an
+ * identity can be overridden without a trace in the tracked tree.
+ *
+ * A repo-local `[user]` block wins over both the `git.config` include and the
+ * machine's own identity, so every commit made here inherits it silently - including
+ * the commits this tool makes on the reader's behalf (`slice finish`, `plan done`).
+ * That is not a hypothetical: 34 commits in this repository were authored as
+ * `t <t@t.t>` because `.git/config` carried that block and nothing reported it. The
+ * helper exists so `test/repo-identity.test.mjs` can fail loudly instead.
+ *
+ * `--local` rather than `--get`: the question is what THIS config adds, not what the
+ * resolved identity happens to be.
+ *
+ * @param {string} root
+ * @returns {Promise<{key: string, value: string}[]>}
+ */
+export async function localIdentityOverrides(root) {
+  const out = await git(root, ['config', '--local', '--get-regexp', '^user\\.']);
+  if (!out) return [];
+  return out
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => {
+      const space = line.indexOf(' ');
+      return { key: line.slice(0, space), value: line.slice(space + 1) };
+    });
+}

package/src/index/extract.mjs

@@ -51,13 +51,19 @@ export function extract(filePath, text, lang) {
   return { symbols, imports: found.imports };
 }
 
-/** Import specifiers become edges. A relative one points at a tracked file when one matches. */
+/**
+ * Import specifiers become edges. A relative one points at a tracked file when
+ * one matches; a non-relative one goes through the language's namespace
+ * strategy below (review 0003 Q40).
+ */
 export function resolveImports(filePath, imports, files, lang) {
   const have = files instanceof Set ? files : new Set(files);
+  const stems = indexByStem(have);
+  const dirs = lang === 'go' || lang === 'csharp' ? indexDirs(have, lang === 'go' ? '.go' : '.cs') : null;
   const edges = [];
   const seen = new Set();
   for (const spec of imports) {
-    const dst = resolveOne(filePath, spec, have, lang);
+    const dst = resolveOne(filePath, spec, have, stems, dirs, lang);
     if (seen.has(dst)) continue;
     seen.add(dst);
     edges.push({ src: filePath, dst, kind: 'import', weight: 1 });
@@ -66,9 +72,142 @@ export function resolveImports(filePath, imports, files, lang) {
   return edges;
 }
 
-function resolveOne(filePath, spec, files, lang) {
+/** Stem (basename) to tracked paths, so a namespace lookup touches its stem group, not the tree. */
+function indexByStem(have) {
+  const map = new Map();
+  for (const file of have) {
+    const stem = file.slice(file.lastIndexOf('/') + 1);
+    const list = map.get(stem);
+    if (list) list.push(file);
+    else map.set(stem, [file]);
+  }
+  return map;
+}
+
+/** Directory to files of one extension, for the languages whose imports name a package, not a file. */
+function indexDirs(have, ext) {
+  const map = new Map();
+  for (const file of have) {
+    if (!file.endsWith(ext)) continue;
+    const dir = file.includes('/') ? file.slice(0, file.lastIndexOf('/')) : '';
+    const list = map.get(dir);
+    if (list) list.push(file);
+    else map.set(dir, [file]);
+  }
+  return map;
+}
+
+/**
+ * One strategy per namespace language (review 0003 Q40).
+ *
+ * Outside JS/TS, imports name namespaces: `com.foo.Bar`, `pkg.mod`,
+ * `example.com/mod/pkg`, `crate::a::b`, `A.B.C`. Each builder maps the spec
+ * to ordered path candidates; the first candidate with exactly one tracked hit
+ * wins, several hits stay the raw specifier (ambiguous is not resolved), and
+ * none keeps the old behaviour. Languages whose imports cannot name a file -
+ * a C# `using` names a namespace shared by many files, a Go import names a
+ * package - resolve only the single-file case and keep the rest as specs.
+ */
+function nonRelativeCandidates(spec, lang) {
+  if (lang === 'kotlin' || lang === 'java') {
+    const parts = spec.split('.');
+    if (parts.length < 2 || parts.some((p) => p === '')) return null;
+    return dottedFileCandidates(parts, lang === 'kotlin' ? ['.kt', '.kts'] : ['.java'], null);
+  }
+  if (lang === 'python') {
+    const parts = spec.split('.');
+    if (parts.some((p) => p === '')) return null;
+    const base = parts.join('/');
+    return [`${base}.py`, `${base}/__init__.py`];
+  }
+  if (lang === 'rust') {
+    const parts = spec.split('::');
+    if (parts[0] === 'crate' || parts[0] === 'self' || parts[0] === 'super') parts.shift();
+    else if (parts[0] === '') return null;
+    if (parts.length === 0 || parts.some((p) => p === '')) return null;
+    return dottedFileCandidates(parts, ['.rs'], 'mod.rs');
+  }
+  return null;
+}
+
+/**
+ * Full dotted path first, then dropping a trailing Uppercase segment: a nested
+ * type lives in its outer file (`com.foo.Outer.Inner` → `Outer.kt`). The drop
+ * stops at a lowercase segment, so `java.util.List` never becomes `util.java` -
+ * a stdlib import must not resolve to a coincidental file of that name.
+ */
+function dottedFileCandidates(parts, exts, modFile) {
+  const out = [];
+  const segs = [...parts];
+  for (;;) {
+    const base = segs.join('/');
+    for (const ext of exts) out.push(`${base}${ext}`);
+    if (modFile) out.push(`${base}/${modFile}`);
+    const last = segs[segs.length - 1] ?? '';
+    const outer = segs[segs.length - 2] ?? '';
+    if (segs.length < 2 || !/^[A-Z]/.test(last) || (segs.length > 2 && !/^[A-Z]/.test(outer))) break;
+    segs.pop();
+  }
+  return out;
+}
+
+/** First candidate with exactly one tracked hit wins; several hits are ambiguous, not resolved. */
+function suffixHit(candidates, have, stems) {
+  for (const candidate of candidates) {
+    if (have.has(candidate)) return candidate;
+    const stem = candidate.slice(candidate.lastIndexOf('/') + 1);
+    const hits = (stems.get(stem) ?? []).filter((f) => f === candidate || f.endsWith(`/${candidate}`));
+    if (hits.length === 1) return hits[0];
+    if (hits.length > 1) return null;
+  }
+  return null;
+}
+
+/**
+ * A package import resolves to its directory's single file, and only then.
+ *
+ * Stripping from the left is the go.mod-prefix strategy without reading go.mod:
+ * whatever the module prefix is, it is the part that does not match. A package
+ * of several files has no single answer a file edge could name, so it stays a
+ * specifier rather than pointing at an arbitrary member.
+ */
+function dirHit(spec, dirs) {
+  const parts = spec.replace(/\\/g, '/').replace(/^\.\//, '').split('/').filter((p) => p !== '');
+  for (let i = 0; i < parts.length; i += 1) {
+    const suffix = parts.slice(i).join('/');
+    const found = [];
+    for (const [dir, members] of dirs) {
+      if (dir === suffix || (suffix !== '' && dir.endsWith(`/${suffix}`))) found.push(...members);
+    }
+    if (found.length === 1) return found[0];
+    if (found.length > 1) return null;
+  }
+  return null;
+}
+
+/**
+ * An explicit extension that names the sibling language (review 0003 Q41).
+ *
+ * TypeScript sources import their compiled shape (`./b.js` for `b.ts`), and
+ * Node's ESM resolution requires it; the tracked tree holds the source, so
+ * the edge must try the source extension before giving up and storing the
+ * specifier raw.
+ */
+const EXT_SWAPS = { '.js': ['.ts', '.tsx'], '.mjs': ['.mts'], '.cjs': ['.cts'] };
+
+function resolveOne(filePath, spec, files, stems, dirs, lang) {
   const rel = relativeSpec(spec);
-  if (rel === null) return spec;
+  if (rel === null) {
+    if (lang === 'go' || lang === 'csharp') {
+      // Namespace-as-directory: `A.B.C` and `example.com/mod/pkg` use dots and
+      // slashes interchangeably for what is a directory on disk.
+      const dotted = lang === 'csharp' ? String(spec).replace(/\\/g, '/').split('.').join('/') : String(spec);
+      return dirHit(dotted, dirs) ?? spec;
+    }
+    const candidates = nonRelativeCandidates(String(spec), lang);
+    if (candidates === null) return spec;
+    return suffixHit(candidates, files, stems) ?? spec;
+  }
   const dir = filePath.includes('/') ? filePath.slice(0, filePath.lastIndexOf('/')) : '';
   const base = slash(dir, rel);
   const candidates = [base];
@@ -82,6 +221,13 @@ function resolveOne(filePath, spec, files, lang) {
   for (const candidate of candidates) {
     if (files.has(candidate)) return candidate;
   }
+  for (const [from, tos] of Object.entries(EXT_SWAPS)) {
+    if (!base.endsWith(from)) continue;
+    for (const to of tos) {
+      const swapped = base.slice(0, -from.length) + to;
+      if (files.has(swapped)) return swapped;
+    }
+  }
   return spec;
 }
 
@@ -146,14 +292,48 @@ function scan(text, onLine) {
   return { symbols, imports };
 }
 
+/**
+ * Import specifiers in a script, including an import that spans lines.
+ *
+ * Single-line regexes missed the case the review caught (Q41): an import whose
+ * `from` lands several lines below the `import`. Buffering until the closing
+ * quote (or `;`) sees the whole statement before deciding what it names.
+ * Moved here from `tests.mjs` so the index and the test mapping read the same
+ * bytes; `tests.mjs` re-exports it, so its importers do not move.
+ */
+export function scriptSpecifiers(text) {
+  const specs = [];
+  const lines = String(text).split('\n');
+  let buf = '';
+  let open = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!open) {
+      if (!/^(?:import|export)\b/.test(trimmed)) continue;
+      // A declaration is not an import. Capturing it would swallow the next
+      // import's `from` and report a specifier the file does not have.
+      if (/^export\s+(?:default\s+)?(?:async\s+)?(?:function|class|const|let|var)\b/.test(trimmed) && !trimmed.includes(' from ')) continue;
+      buf = trimmed;
+      open = true;
+    } else {
+      buf += `\n${trimmed}`;
+    }
+    const done = /\bfrom\s+['"][^'"]+['"]/.test(buf) || /^import\s+['"][^'"]+['"]/.test(buf) || buf.includes(';') || buf.length > 2000;
+    if (!done) continue;
+    const from = buf.match(/\bfrom\s+['"]([^'"]+)['"]/);
+    const side = buf.match(/^import\s+['"]([^'"]+)['"]/);
+    if (from) specs.push(from[1]);
+    else if (side) specs.push(side[1]);
+    buf = '';
+    open = false;
+  }
+  for (const match of String(text).matchAll(/require\(\s*['"]([^'"]+)['"]\s*\)/g)) specs.push(match[1]);
+  for (const match of String(text).matchAll(/\bimport\(\s*['"]([^'"]+)['"]\s*\)/g)) specs.push(match[1]);
+  return [...new Set(specs)];
+}
+
 function script(text) {
-  return scan(text, (line, raw, lineNo, symbols, imports) => {
-    const from = line.match(/^(?:import|export)\s[\s\S]*?\sfrom\s+['"]([^'"]+)['"]/);
-    const side = line.match(/^import\s+['"]([^'"]+)['"]/);
-    const req = line.match(/\brequire\(\s*['"]([^'"]+)['"]\s*\)/);
-    if (from) imports.push(from[1]);
-    else if (side) imports.push(side[1]);
-    else if (req) imports.push(req[1]);
+  const { symbols } = scan(text, (line, raw, lineNo, symbols) => {
     let m;
     if ((m = line.match(new RegExp(`^export\\s+(?:default\\s+)?(?:async\\s+)?function\\s*\\*?\\s*(${IDENT})`)))) {
       add(symbols, m[1], 'function', lineNo, raw, 1);
@@ -179,6 +359,7 @@ function script(text) {
       add(symbols, m[1], 'class', lineNo, raw, line.startsWith('export ') ? 1 : 0);
     }
   });
+  return { symbols, imports: scriptSpecifiers(text) };
 }
 
 const KT_MOD = '(?:public|private|internal|protected|open|data|sealed|abstract|enum|inner|value|annotation|suspend|override|operator|inline)';