@opengsd/gsd-core 1.14.0 → 1.16.0

package/scripts/release-tarball-smoke.cjs

@@ -37,6 +37,12 @@
  *     colon-namespace leaks (WORKFLOW_BODY_COLON_LEAK).
  *   This check populates result.details with counters but does NOT return a
  *   failure code by default; it is informational until enforcement is enabled.
+ *
+ * Configured-entrypoint checks (Cycle 4 — #4154):
+ *   For each runtime in entrypointRuntimes, runs the tarball-installed
+ *   installer into a throwaway HOME, then re-reads that runtime's own written
+ *   config files and asserts every GSD-managed script path they name resolves
+ *   to a file (ENTRYPOINT_UNRESOLVED). Requires fixtureDir.
  */
 
 'use strict';
@@ -47,6 +53,8 @@ const os = require('os');
 const path = require('path');
 const { PACKAGE_NAME } = require('../gsd-core/bin/lib/package-identity.cjs');
 const { ExitError, runMain } = require('./lib/cli-exit.cjs');
+const shellCmdProjection = require('../gsd-core/bin/lib/shell-command-projection.cjs');
+const { escapeRegex } = require('../gsd-core/bin/lib/pattern.cjs');
 // 120 s proved too tight for cold-cache `npm install -g` of a 1499-file tarball:
 // spawnSync fires SIGTERM at the deadline and returns { status: null, stdout: '',
 // stderr: '' } (Node docs: status is null when a subprocess is terminated by a
@@ -86,6 +94,8 @@ const SMOKE = Object.freeze({
   INIT_FAILED: 'init_failed',
   // Cycle 3 code
   WORKFLOW_BODY_COLON_LEAK: 'workflow_body_colon_leak',
+  // Cycle 4 code (#4154)
+  ENTRYPOINT_UNRESOLVED: 'entrypoint_unresolved',
 });
 
 // ---------------------------------------------------------------------------
@@ -274,6 +284,106 @@ function scanWorkflowColonLeak(filePath, cmdNames) {
   return null;
 }
 
+// ---------------------------------------------------------------------------
+// Cycle 4 helpers: configured-entrypoint resolution (#4154)
+// ---------------------------------------------------------------------------
+
+/**
+ * Top-level config files this scan reads. These are the surfaces that carry
+ * every GSD-managed launch path for the runtimes Cycle 4 actually installs
+ * (`entrypointRuntimes`, default claude + codex): claude registers into
+ * settings.json, codex into hooks.json and config.toml.
+ *
+ * This is NOT an exhaustive map of where GSD writes launch paths across all
+ * runtimes, and the scan is top-level only by design. Two known surfaces sit
+ * outside it: Cline registers its hook at `.clinerules/hooks/PreToolUse` (a
+ * subdirectory, and not one of these names — see writeClineArtifacts in
+ * src/runtime-hooks-surface.cts), and Kimi's native `[[hooks]]` config.toml
+ * lives under `resolveKimiHooksTomlDir()` (`~/.kimi`), a directory separate
+ * from Kimi's own GSD configDir. Adding either runtime to entrypointRuntimes
+ * requires teaching scanConfiguredEntrypoints about its surface first,
+ * otherwise the scan reports zero entrypoints and silently proves nothing.
+ */
+const RUNTIME_CONFIG_FILES = Object.freeze(['settings.json', 'hooks.json', 'config.toml']);
+
+/**
+ * Extract every script path `text` names underneath `configDir`.
+ *
+ * #4249 (antigravity review): anchored on the literal, already-known
+ * `configDir` prefix instead of a generic "any absolute path" character
+ * class. The prior version excluded whitespace from the match to avoid
+ * swallowing a shell command's trailing args, which also truncated any
+ * legitimate path containing a space (e.g. `/Users/John Doe/.claude`) —
+ * `scanConfiguredEntrypoints` would then silently report zero checked
+ * paths. Anchoring on `configDir` removes the ambiguity outright: a match
+ * can only start where the known prefix literally occurs in the text, so
+ * an interpreter path concatenated ahead of it (`"/usr/bin/node
+ * /configDir/hooks/foo.js"`) is never swallowed either, and interior
+ * whitespace inside `configDir` or the script's own path segments is safe
+ * to allow. This still scans raw, unparsed config text on purpose (see
+ * scanConfiguredEntrypoints's doc comment) — it catches a writer that
+ * embeds a launch path without registering it, which a structured
+ * JSON.parse of the expected schema would miss entirely.
+ *
+ * Windows configs store paths with backslashes, which JSON/TOML doubles on
+ * write; collapsing `\\` to `\` first makes the raw text scan work on both
+ * platforms without parsing each config format separately (POSIX text has no
+ * backslashes, so the collapse is a no-op there).
+ *
+ * Every writer bakes `configDir` through the same posixNormalize seam
+ * (src/runtime-hooks-surface.cts) before writing it into config text, on
+ * every platform — so the anchor must match that projection, not the
+ * OS-native `configDir` string this function receives.
+ */
+function configuredEntrypointsIn(text, configDir) {
+  const normalizedPrefix = shellCmdProjection.posixNormalize(configDir).replace(/\/+$/, '') + '/';
+  const scriptPathRe = new RegExp(`${escapeRegex(normalizedPrefix)}[^"']{0,400}?\\.(?:js|cjs|mjs|sh|cmd|ps1)`, 'g');
+  const found = new Set();
+  for (const match of text.replace(/\\\\/g, '\\').matchAll(scriptPathRe)) {
+    found.add(path.resolve(match[0]));
+  }
+  return [...found];
+}
+
+/**
+ * Throwaway HOME the Cycle 4 install for `runtime` runs against. Exported so a
+ * test can seed that runtime's config before the install rather than
+ * hard-coding the layout runSmoke picks.
+ */
+function entrypointFixtureHome(fixtureDir, runtime) {
+  return path.join(fixtureDir, `entrypoints-${runtime}`);
+}
+
+/**
+ * Re-derive the configured entrypoints a completed install wrote into a
+ * runtime's own config files and report the ones that do not resolve to a
+ * file. Internal to Cycle 4; the smoke's verdict is the exported contract.
+ *
+ * This deliberately does NOT consult the installer's own entrypoint list (the
+ * assertConfiguredEntrypoints gate in bin/install.js). That gate can only
+ * validate paths a config writer remembered to register; reading the written
+ * config back is what catches a writer that emits a launch path without
+ * registering it, and a stale registration an install left behind.
+ *
+ * @param {string} configDir - Absolute path to the runtime config dir.
+ * @returns {{ checked: string[], unresolved: { configPath: string, scriptPath: string }[] }}
+ */
+function scanConfiguredEntrypoints(configDir) {
+  const checked = [];
+  const unresolved = [];
+  for (const name of RUNTIME_CONFIG_FILES) {
+    const configPath = path.join(configDir, name);
+    if (!fs.existsSync(configPath) || !fs.statSync(configPath).isFile()) continue;
+    const text = fs.readFileSync(configPath, 'utf-8');
+    for (const scriptPath of configuredEntrypointsIn(text, configDir)) {
+      checked.push(scriptPath);
+      if (fs.existsSync(scriptPath) && fs.statSync(scriptPath).isFile()) continue;
+      unresolved.push({ configPath, scriptPath });
+    }
+  }
+  return { checked, unresolved };
+}
+
 // ---------------------------------------------------------------------------
 // Pure function: runSmoke
 // ---------------------------------------------------------------------------
@@ -285,6 +395,8 @@ function scanWorkflowColonLeak(filePath, cmdNames) {
  * @param {string}   opts.expectedVersion    - semver string to assert (e.g. "1.50.0")
  * @param {string}   [opts.fixtureDir]       - Temp dir to run `init` into (must NOT be HOME)
  * @param {string[]} [opts.lifecycleCommands] - Commands to file-check (default: see below)
+ * @param {string[]} [opts.entrypointRuntimes] - Runtime profiles whose configured entrypoints are
+ *   re-checked after a real install (default: see below). Requires fixtureDir; pass [] to skip.
  * @param {boolean}  [opts.dryRun=false]     - If true, skip actual npm install; validate input only
  * @param {object}   [opts.npmEnv]           - Optional env dict for the internal npm install
  *   spawnSync call. Pass an isolated HOME env (e.g. from isolatedNpmEnv() in tests/helpers.cjs)
@@ -298,6 +410,11 @@ function runSmoke({
   expectedVersion,
   fixtureDir,
   lifecycleCommands = ['init', 'discuss-phase', 'plan-phase', 'execute-phase'],
+  // claude and codex cover the two top-level config surfaces this scan knows
+  // how to read (settings.json, and hooks.json + config.toml). Most other
+  // runtimes reuse one of those two shapes; Cline and Kimi do not (see
+  // RUNTIME_CONFIG_FILES), so they are out of scope here rather than covered.
+  entrypointRuntimes = ['claude', 'codex'],
   dryRun = false,
   npmEnv = undefined,
 }) {
@@ -551,6 +668,75 @@ function runSmoke({
   // NOTE: colonLeakCount is informational here. Once the backlog is fixed,
   // a future enforcement mode can fail on non-zero counts.
 
+  // ─────────────────────────────────────────────────────────────────────────
+  // Cycle 4: configured-entrypoint resolution (#4154)
+  // ─────────────────────────────────────────────────────────────────────────
+
+  // The installer's own gate (assertConfiguredEntrypoints) runs in-process and
+  // only sees the paths a config writer registered with it. Installing the
+  // packed tarball for real and reading each runtime's written config back is
+  // what proves the launch paths a user's runtime will actually invoke exist
+  // in the shipped layout.
+  const entrypointProfiles = [];
+  if (fixtureDir && entrypointRuntimes.length > 0) {
+    for (const runtime of entrypointRuntimes) {
+      // Own HOME per runtime so a --global install cannot reach the real one.
+      const runtimeHome = entrypointFixtureHome(fixtureDir, runtime);
+      const configDir = path.join(runtimeHome, `.${runtime}`);
+      fs.mkdirSync(runtimeHome, { recursive: true });
+
+      const installResult = spawnSync(
+        process.execPath,
+        [path.join(pkg, 'bin', 'install.js'), `--${runtime}`, '--global', '--config-dir', configDir],
+        {
+          encoding: 'utf-8',
+          cwd: runtimeHome,
+          stdio: ['pipe', 'pipe', 'pipe'],
+          env: {
+            ...effectiveNpmEnv,
+            HOME: runtimeHome,
+            USERPROFILE: runtimeHome,
+            // Same reason as the init check above: install.js skips its main()
+            // block when GSD_TEST_MODE is set and would exit 0 writing nothing.
+            GSD_TEST_MODE: '',
+            NO_UPDATE_NOTIFIER: '1',
+          },
+          timeout: CHILD_TIMEOUT_MS,
+        },
+      );
+
+      if (installResult.status !== 0) {
+        // #4249 (antigravity review): this is the Cycle 4 per-runtime install,
+        // not Cycle 1's `gsd init` — SMOKE.INSTALL_FAILED is the code Cycle 2's
+        // identical spawnSync-failure check already uses for the same failure
+        // class; reusing SMOKE.INIT_FAILED here conflated the two lifecycle
+        // stages in the reported code.
+        return {
+          code: SMOKE.INSTALL_FAILED,
+          details: {
+            ...details,
+            runtime,
+            configDir,
+            stderr: installResult.stderr,
+            stdout: installResult.stdout,
+          },
+        };
+      }
+
+      const scan = scanConfiguredEntrypoints(configDir);
+      if (scan.unresolved.length > 0) {
+        return {
+          code: SMOKE.ENTRYPOINT_UNRESOLVED,
+          details: { ...details, runtime, configDir, unresolved: scan.unresolved },
+        };
+      }
+
+      entrypointProfiles.push({ runtime, configDir, entrypointsChecked: scan.checked.length });
+    }
+  }
+
+  details.entrypointProfiles = entrypointProfiles;
+
   return { code: SMOKE.OK, details };
 }
 
@@ -635,7 +821,14 @@ function cleanup(...dirs) {
 // Exports
 // ---------------------------------------------------------------------------
 
-module.exports = { SMOKE, runSmoke, binInvocation, CHILD_TIMEOUT_MS };
+module.exports = {
+  SMOKE,
+  runSmoke,
+  binInvocation,
+  entrypointFixtureHome,
+  CHILD_TIMEOUT_MS,
+  configuredEntrypointsIn,
+};
 
 if (require.main === module) {
   runMain(cliMain);

package/scripts/require-issue-link-policy.cjs

@@ -53,7 +53,10 @@ const DEPENDABOT_LOGIN = 'dependabot[bot]';
 // A follow-up-only PR (references an issue without closing it) is only
 // allowed to skip the closing keyword when every changed file is a test or
 // doc file — i.e. it cannot be the PR that actually implements the fix.
-const EXEMPT_PATH_PREFIXES = ['tests/', 'docs/'];
+// #5061: .out-of-scope/ knowledge-base entries are informational documents,
+// already doc-only in pre-pr-gate.sh's DOC_ONLY_RE. Only `*.md` entries
+// qualify there (see allPathsAreTestsOrDocs): the KB holds nothing else.
+const EXEMPT_PATH_PREFIXES = ['tests/', 'docs/', '.out-of-scope/'];
 
 // Root-level markdown is documentation — this mirrors the repo's own doc-only
 // classifier (.claude/hooks/pre-pr-gate.sh:111), whose `[^/]+\.md` anchor is
@@ -115,7 +118,7 @@ function normalizePath(p) {
 /**
  * Returns true iff every changed file qualifies as a test/doc file, i.e. each
  * one is one of:
- *   1. under one of EXEMPT_PATH_PREFIXES (`tests/`, `docs/`) — the trailing
+ *   1. under one of EXEMPT_PATH_PREFIXES (`tests/`, `docs/`, `.out-of-scope/`) — the trailing
  *      slash on each prefix makes this directory-boundary aware, so
  *      lookalikes like `tests-e2e/`, `testsuite/`, or `docsite/` are
  *      correctly rejected (they are not `tests/` or `docs/`); or
@@ -126,6 +129,7 @@ function allPathsAreTestsOrDocs(changedFiles) {
   if (!Array.isArray(changedFiles) || changedFiles.length === 0) return false;
   return changedFiles.every((file) => {
     const normalized = normalizePath(file);
+    if (normalized.startsWith('.out-of-scope/')) return /\.md$/i.test(normalized);
     if (EXEMPT_PATH_PREFIXES.some((prefix) => normalized.startsWith(prefix))) return true;
     return isRootLevelDoc(normalized);
   });

package/scripts/sync-runtime-launcher.cjs

@@ -272,6 +272,49 @@ function insertPreamble(lines, preamble) {
   return [...before, ...preamble, ...after];
 }
 
+/**
+ * The first two statements EVERY version of the launcher preamble opens with
+ * (`_GSD_SHIM_NAME="gsd-tools.cjs"; _GSD_RUNTIME_ROOT=`). Matching the pair, not
+ * the bare `_GSD_SHIM_NAME=` prefix, means a prose sample or an intentionally
+ * different resolver that happens to start a line with the variable name is never
+ * mistaken for the preamble and never rewritten (#5169 review).
+ */
+const PREAMBLE_LINE_RE = /^_GSD_SHIM_NAME="gsd-tools\.cjs"; _GSD_RUNTIME_ROOT=/;
+
+/**
+ * Index of the line that starts a launcher preamble inside `lines`, or -1.
+ *
+ * Matched by the marker every version of the preamble opens with
+ * (`_GSD_SHIM_NAME=`), NOT by equality with the CURRENT text: the sync runs
+ * precisely when the snippet changed, so the copy in the file is by definition an
+ * older version, and an exact match never found it — which hoisted a guard-fronted
+ * preamble to the top of its block on every snippet change (#5169; caught by the
+ * #3861 guard-only extraction in tests/code-review-pipeline-regression.test.cjs).
+ */
+function findPreambleStart(lines) {
+  return lines.findIndex((l) => PREAMBLE_LINE_RE.test(l));
+}
+
+/**
+ * Place the preamble in a block that ALREADY carried it. A block that opens
+ * with a guard (a status check that must run before any launcher resolution,
+ * e.g. execute-phase/steps/code-review-disposition.md, #3861) keeps the preamble
+ * BEHIND that guard: hoisting it to the top would put the resolver ahead of the
+ * guard and change what the guard-only extraction in the tests runs. A block
+ * whose preamble already sits at the top (after blank lines), or that had none,
+ * takes the ordinary top insertion.
+ *
+ * The position is kept in STRIPPED coordinates: the lines before the preamble
+ * are stripped on their own and their length is the insertion point.
+ */
+function insertPreambleKeepingGuard(original, stripped, preamble) {
+  const k = findPreambleStart(original);
+  const firstContent = original.findIndex((l) => l.trim() !== '');
+  if (k <= firstContent) return insertPreamble(stripped, preamble);
+  const at = stripAndReplace(original.slice(0, k), preamble).length;
+  return [...stripped.slice(0, at), ...preamble, ...stripped.slice(at)];
+}
+
 /**
  * Transform a single markdown file's content.
  * Returns new content string, or null if no changes needed.
@@ -366,7 +409,9 @@ function transformFile(content, preamble) {
   const delegates = delegatesToResolverReference(content);
   const finalBlocks = strippedBlocks.map((stripped, bi) => {
     if (!delegates && bi === preambleTargetIdx) {
-      return insertPreamble(stripped, preamble);
+      const range = shellBlockRanges[bi];
+      const original = allLines.slice(range.contentStart, range.contentEnd);
+      return insertPreambleKeepingGuard(original, stripped, preamble);
     }
     return stripped;
   });
@@ -405,9 +450,137 @@ function delegatesToResolverReference(content) {
   return content.includes('references/gsd-run-resolver.md');
 }
 
+// ---------------------------------------------------------------------------
+// `_gsd_homes` — the launcher's runtime-home candidate list, DERIVED from the
+// runtime descriptors (#5169, ADR-5057 §5 "one resolver", #4347).
+//
+// The JS resolver (src/runtime-homes.cts) resolves a runtime's home from its
+// `configHome` descriptor. The shell launcher used to carry a hand-written copy
+// of that list and drifted (it still probed GEMINI_CONFIG_DIR after the runtime
+// was retired, and omitted zcode/pi/kimi). Both now read the same registry:
+// this renderer is the only producer of the `_gsd_homes` text in the snippet,
+// and tests/runtime-launcher-parity.test.cjs fails when the snippet differs
+// from it.
+// ---------------------------------------------------------------------------
+
+const HOMES_START = '_gsd_homes() { ';
+const HOMES_END = '; }; if _gsd_at';
+
+function shellHomeExpr(configHome) {
+  const dotHome = (rel) => `$HOME/${rel}`;
+  const withEnvs = (envs, fallback) => envs.reduceRight((acc, name) => `\${${name}:-${acc}}`, fallback);
+  switch (configHome.kind) {
+    case 'dot-home':
+      return [withEnvs(configHome.env, dotHome(configHome.name))];
+    case 'dot-home-nested': {
+      const probes = configHome.probe && configHome.probe.length > 0 ? configHome.probe : [configHome.name];
+      const first = withEnvs(configHome.env.slice(0, 1), dotHome(`${configHome.parent}/${probes[0]}`));
+      return [first, ...probes.slice(1).map((p) => dotHome(`${configHome.parent}/${p}`))];
+    }
+    case 'xdg': {
+      const xdgVar = configHome.env[2];
+      const base = xdgVar ? `\${${xdgVar}:-$HOME/.config}` : '$HOME/.config';
+      return [withEnvs(configHome.env.slice(0, 1), `${base}/${configHome.name}`)];
+    }
+    case 'generic-agents-root': {
+      const probes = configHome.probe.map((p) => p.replace(/^~/, '$HOME'));
+      return [withEnvs(configHome.env.slice(0, 1), probes[0]), ...probes.slice(1)];
+    }
+    default:
+      return []; // kind "none": no file-projected home, nothing to probe
+  }
+}
+
+/** The `_gsd_homes() { _gsd_at ...; }` text for a registry + legacy-home table. */
+function renderHomesFunction(registry, legacyHomes) {
+  const ids = Object.keys(registry.runtimes).sort((a, b) =>
+    a === 'claude' ? -1 : b === 'claude' ? 1 : a < b ? -1 : a > b ? 1 : 0);
+  const exprs = [];
+  for (const id of ids) {
+    const configHome = registry.runtimes[id].runtime && registry.runtimes[id].runtime.configHome;
+    if (configHome) exprs.push(...shellHomeExpr(configHome));
+  }
+  for (const id of Object.keys(legacyHomes).sort()) {
+    const legacy = legacyHomes[id];
+    exprs.push(`\${${legacy.env}:-$HOME/${legacy.dir.join('/')}}`);
+  }
+  // One loop over the homes, the `/gsd-core/bin/<shim>` suffix written once: the
+  // preamble is inlined into ~240 prompt files, several of which sit at a size cap.
+  // The homes are loaded into the FUNCTION's own positional parameters (`set --`
+  // is scoped to the function) and walked with `for _h; do`, not `for _h in <list>`:
+  // lint-workflow-shellcheck's #4109 structural check flags any `for x in` list that
+  // contains a `$`, without parsing the quoting around it.
+  const homes = [...new Set(exprs)].map((e) => `"${e}"`).join(' ');
+  return `${HOMES_START}set -- ${homes}; for _h; do _gsd_at "$_h/gsd-core/bin/\${_GSD_SHIM_NAME}" && return 0; done; return 1; }`;
+}
+
+/** Locate the `_gsd_homes` function text inside the snippet's single line. */
+function extractHomesFunction(snippetText) {
+  const start = snippetText.indexOf(HOMES_START);
+  const end = snippetText.indexOf(HOMES_END, start);
+  if (start === -1 || end === -1) return null;
+  return { start, end: end + '; }'.length, text: snippetText.slice(start, end + '; }'.length) };
+}
+
+function loadDerivedHomes() {
+  const registry = require('../gsd-core/bin/lib/capability-registry.cjs');
+  const { LEGACY_NON_REGISTRY_RUNTIME_HOMES } = require('../gsd-core/bin/lib/runtime-name-policy.cjs');
+  return renderHomesFunction(registry, LEGACY_NON_REGISTRY_RUNTIME_HOMES);
+}
+
+/** Rewrite the snippet's `_gsd_homes` from the descriptors. Returns true when it changed. */
+function refreshSnippetHomes() {
+  const raw = fs.readFileSync(SNIPPET_FILE, 'utf8');
+  const found = extractHomesFunction(raw);
+  if (!found) throw new Error('_runtime-launcher.snippet.sh has no _gsd_homes function to refresh');
+  const derived = loadDerivedHomes();
+  if (found.text === derived) return false;
+  fs.writeFileSync(SNIPPET_FILE, raw.slice(0, found.start) + derived + raw.slice(found.end), 'utf8');
+  return true;
+}
+
+// ---------------------------------------------------------------------------
+// Files that carry the preamble as ONE line but are not transformed by
+// `transformFile` (it would move a per-block definition into the first block):
+//   - gsd-core/references/gsd-run-resolver.md — the @-included canonical copy,
+//     asserted byte-equal to the snippet;
+//   - commands/**/*.md — slash-command templates whose every bash block carries
+//     its own definition (each block is a separate shell), originally copied from
+//     an older fixed-list resolver that still probed the retired gemini home.
+// Every line that starts a resolver (PREAMBLE_LINE_RE) is replaced by the
+// canonical preamble line, so these copies are generated, not hand-kept (#5169).
+// ---------------------------------------------------------------------------
+const RESOLVER_REFERENCE = path.join(__dirname, '..', 'gsd-core', 'references', 'gsd-run-resolver.md');
+const COMMANDS_DIR = path.join(__dirname, '..', 'commands');
+
+function replaceResolverLines(content, preambleLine) {
+  return content
+    .split('\n')
+    .map((line) => (PREAMBLE_LINE_RE.test(line) && line !== preambleLine ? preambleLine : line))
+    .join('\n');
+}
+
+function syncSingleLinePreambleFiles(preamble) {
+  if (preamble.length !== 1) throw new Error('the launcher preamble must be a single line to be inlined per block');
+  const files = [RESOLVER_REFERENCE, ...collectFiles(COMMANDS_DIR)];
+  let changed = 0;
+  for (const f of files) {
+    const content = fs.readFileSync(f, 'utf8');
+    const next = replaceResolverLines(content, preamble[0]);
+    if (next !== content) {
+      fs.writeFileSync(f, next, 'utf8');
+      changed++;
+      console.log(`transformed (preamble line): ${path.relative(path.join(__dirname, '..'), f)}`);
+    }
+  }
+  return changed;
+}
+
 // Main
 function main() {
+  if (refreshSnippetHomes()) console.log('refreshed _gsd_homes in _runtime-launcher.snippet.sh from the runtime descriptors');
   const preamble = loadPreamble();
+  syncSingleLinePreambleFiles(preamble);
 
   let transformedCount = 0;
   let unchangedCount = 0;
@@ -447,4 +620,13 @@ if (require.main === module) {
   main();
 }
 
-module.exports = { transformFile };
+module.exports = {
+  transformFile,
+  loadPreamble,
+  renderHomesFunction,
+  extractHomesFunction,
+  loadDerivedHomes,
+  refreshSnippetHomes,
+  replaceResolverLines,
+  PREAMBLE_LINE_RE,
+};