simt-dev 0.6.2 → 0.7.0

package/src/hooks/shim.mjs

@@ -48,14 +48,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 +68,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 +107,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,9 @@ 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;
 }

package/src/ignore.mjs

@@ -0,0 +1,133 @@
+// One ignore list, four readers' dialects (plan 0003 R52).
+//
+// Cursor, Aider, Gemini and Claude each want the same fact — "the agent must
+// not load these paths" — in a different place: three gitignore-style files and
+// one array inside a JSON settings object. Hand-maintaining four copies is four
+// chances to forget one, and a forget is silent: the agent reads the file that
+// did get updated and confidently loads the path the other three excluded. So
+// the list lives in exactly one file (`.simtignore`, at the repository root,
+// where a gitignore-syntax list already belongs) and everything else is
+// rendered from it.
+//
+// Two ownership rules, because the four targets are not equally ours:
+//
+//   - The three ignore files are GENERATED: whatever they held is what the list
+//     says after `simt ignore --yes`. A line that is in one and not in the list
+//     is drift between four files that claim to agree, and the plan prints it
+//     as a removal before anything is written.
+//   - `.claude/settings.json` is the READER'S file that merely contains our
+//     entries. We merge: every key, every permission and every deny entry that
+//     was already there survives byte-for-byte, and we only add `Read(...)`
+//     lines. In particular we never REMOVE a deny entry, because deleting a
+//     permission is a security decision that belongs to whoever wrote it — an
+//     entry dropped from `.simtignore` leaves a stale deny in Claude (safe
+//     direction) while the three generated files converge immediately.
+
+/** The one list. gitignore syntax: one path or glob per line, `#` comments. */
+export const IGNORE_FILE = '.simtignore';
+
+/** The three readers that take the list verbatim. */
+const TEXT_TARGETS = ['.cursorignore', '.aiderignore', '.geminiignore'];
+
+/** The reader that takes it as `permissions.deny` `Read(...)` entries. */
+export const CLAUDE_SETTINGS = '.claude/settings.json';
+
+/**
+ * Parse the list: trim, drop blanks and `#` comments, keep entries verbatim.
+ *
+ * Verbatim matters — `.env.local` and `secrets/` and `*.pem` are the reader's
+ * globs, and normalising them would be this tool guessing at another tool's
+ * pattern language.
+ */
+export function parseIgnoreList(text) {
+  return String(text)
+    .split('\n')
+    .map((line) => line.replace(/\r$/, '').trim())
+    .filter((line) => line !== '' && !line.startsWith('#'));
+}
+
+/** The bytes of one of the three generated ignore files. */
+export function renderTextIgnore(entries) {
+  return entries.length === 0 ? '' : `${entries.join('\n')}\n`;
+}
+
+/** The list as Claude deny entries: `Read(.env)`, `Read(secrets/**)`, … */
+export function denyEntries(entries) {
+  return entries.map((entry) => `Read(${entry})`);
+}
+
+/**
+ * Merge the list into `.claude/settings.json`, preserving everything else.
+ *
+ * @param {string|null} existingText current bytes, or null when absent
+ * @param {string[]} entries the parsed list
+ * @returns {{ok: true, text: string} | {ok: false, error: string}} — a settings
+ *   file that is not valid JSON OBJECT is refused rather than replaced: the one
+ *   failure that loses a reader's whole Claude configuration is a renderer that
+ *   "repairs" what it could not parse.
+ */
+export function renderClaudeSettings(existingText, entries) {
+  let settings = {};
+  if (existingText !== null) {
+    try {
+      settings = JSON.parse(existingText);
+    } catch (error) {
+      return { ok: false, error: `${CLAUDE_SETTINGS} is not valid JSON: ${error.message}` };
+    }
+    if (settings === null || typeof settings !== 'object' || Array.isArray(settings)) {
+      return { ok: false, error: `${CLAUDE_SETTINGS} is not a JSON object; it cannot hold permissions` };
+    }
+  }
+
+  const current =
+    settings.permissions !== null &&
+    typeof settings.permissions === 'object' &&
+    !Array.isArray(settings.permissions)
+      ? { ...settings.permissions }
+      : {};
+  const existing = Array.isArray(current.deny)
+    ? current.deny.filter((entry) => typeof entry === 'string')
+    : [];
+  const wanted = denyEntries(entries);
+  // Existing entries keep their order and their bytes; ours append in list
+  // order, deduplicated so a re-run is byte-idempotent.
+  current.deny = [...existing, ...wanted.filter((entry) => !existing.includes(entry))];
+  settings.permissions = current;
+
+  return { ok: true, text: `${JSON.stringify(settings, null, 2)}\n` };
+}
+
+/**
+ * The four targets with their desired bytes, from the current bytes of each.
+ *
+ * @param {string[]} entries the parsed list
+ * @param {(path: string) => Promise<string|null>} read current bytes or null
+ * @returns {Promise<{ok: true, targets: {path: string, action: 'create'|'update'|'unchanged',
+ *   before: string|null, after: string}[]} | {ok: false, error: string}>}
+ */
+export async function planIgnore(entries, read) {
+  const text = renderTextIgnore(entries);
+  const targets = [];
+
+  for (const path of TEXT_TARGETS) {
+    const before = await read(path);
+    targets.push({
+      path,
+      action: before === null ? 'create' : before === text ? 'unchanged' : 'update',
+      before,
+      after: text,
+    });
+  }
+
+  const claudeBefore = await read(CLAUDE_SETTINGS);
+  const merged = renderClaudeSettings(claudeBefore, entries);
+  if (!merged.ok) return { ok: false, error: merged.error };
+  targets.push({
+    path: CLAUDE_SETTINGS,
+    action: claudeBefore === null ? 'create' : claudeBefore === merged.text ? 'unchanged' : 'update',
+    before: claudeBefore,
+    after: merged.text,
+  });
+
+  return { ok: true, targets };
+}

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)';