mandrel 2.65.0 → 2.67.0

package/.agents/scripts/lib/orchestration/ticket-validator.js

@@ -60,49 +60,32 @@ function collectTaskPathReferences(task) {
  */
 function collectTaskChangesPaths(task) {
   const paths = new Set();
-  const body = task.body;
+  const source = resolveChangesSource(task);
+  if (source === null) return paths;
+  for (const arrName of ['changes', 'references']) {
+    const arr = source[arrName];
+    if (!Array.isArray(arr)) continue;
+    for (const item of arr) collectChangesItem(item, paths);
+  }
+  return paths;
+}
 
+function resolveChangesSource(task) {
+  const body = task.body;
   // A parse failure throws rather than yielding an empty whitelist, which
   // would misreport every declared path as missing.
   if (typeof body === 'string' && body.trim().length > 0) {
-    const parsed = parseStoryBodyOrThrow(task);
-    for (const arrName of ['changes', 'references']) {
-      const arr = parsed[arrName];
-      if (!Array.isArray(arr)) continue;
-      for (const item of arr) {
-        if (typeof item === 'string') {
-          collectPathsFromText(item, paths);
-        } else if (
-          item !== null &&
-          typeof item === 'object' &&
-          typeof item.path === 'string' &&
-          item.path.length > 0
-        ) {
-          paths.add(item.path);
-        }
-      }
-    }
-    return paths;
+    return parseStoryBodyOrThrow(task);
   }
+  return body !== null && typeof body === 'object' ? body : null;
+}
 
-  if (body === null || typeof body !== 'object') return paths;
-  for (const arrName of ['changes', 'references']) {
-    const arr = body[arrName];
-    if (!Array.isArray(arr)) continue;
-    for (const item of arr) {
-      if (typeof item === 'string') {
-        collectPathsFromText(item, paths);
-      } else if (
-        item !== null &&
-        typeof item === 'object' &&
-        typeof item.path === 'string' &&
-        item.path.length > 0
-      ) {
-        paths.add(item.path);
-      }
-    }
+function collectChangesItem(item, paths) {
+  if (typeof item === 'string') {
+    collectPathsFromText(item, paths);
+  } else if (typeof item?.path === 'string' && item.path.length > 0) {
+    paths.add(item.path);
   }
-  return paths;
 }
 
 function defaultGitRunner({ baseBranchRef, path, cwd }) {

package/.agents/scripts/lib/signals/detectors/common.js

@@ -51,9 +51,12 @@ export function extractTool(rec) {
  */
 export function validateDetectorArgs(args, opts) {
   const { fnName } = opts;
-  const requireTracesPath = opts.requireTracesPath ?? true;
-  const requireStoryId = opts.requireStoryId ?? true;
-  const requireThreshold = opts.requireThreshold ?? true;
+  const gates = {
+    always: true,
+    requireTracesPath: opts.requireTracesPath ?? true,
+    requireStoryId: opts.requireStoryId ?? true,
+    requireThreshold: opts.requireThreshold ?? true,
+  };
 
   if (args == null || typeof args !== 'object') {
     throw new TypeError(
@@ -61,57 +64,66 @@ export function validateDetectorArgs(args, opts) {
     );
   }
 
-  const { tracesPath, epicId, storyId, threshold } = args;
-  const taskId = args.taskId ?? null;
-
-  if (args.nowFn != null && typeof args.nowFn !== 'function') {
-    throw new TypeError(
-      `${fnName}: nowFn, when provided, must be a function (got ${typeof args.nowFn})`,
-    );
-  }
-  const nowFn = args.nowFn ?? (() => new Date().toISOString());
-
-  if (requireTracesPath) {
-    if (typeof tracesPath !== 'string' || tracesPath.length === 0) {
-      throw new TypeError(
-        `${fnName}: tracesPath must be a non-empty string (got ${tracesPath})`,
-      );
-    }
-  }
-
-  if (!isPositiveInt(epicId)) {
-    throw new RangeError(
-      `${fnName}: epicId must be a positive integer (got ${epicId})`,
-    );
-  }
-
-  if (requireStoryId) {
-    if (!isPositiveInt(storyId)) {
-      throw new RangeError(
-        `${fnName}: storyId must be a positive integer (got ${storyId})`,
-      );
-    }
-    if (taskId !== null && !isPositiveInt(taskId)) {
-      throw new RangeError(
-        `${fnName}: taskId must be a positive integer or null (got ${taskId})`,
-      );
-    }
-  }
-
-  if (requireThreshold) {
-    if (!Number.isInteger(threshold) || threshold < 0) {
-      throw new RangeError(
-        `${fnName}: threshold must be a non-negative integer (got ${threshold})`,
-      );
+  const values = { ...args, taskId: args.taskId ?? null };
+  for (const rule of DETECTOR_ARG_RULES) {
+    const value = values[rule.field];
+    if (gates[rule.gate] && rule.invalid(value)) {
+      throw new rule.Error(`${fnName}: ${rule.message(value)}`);
     }
   }
 
   return {
-    tracesPath: requireTracesPath ? tracesPath : undefined,
-    epicId,
-    storyId: requireStoryId ? storyId : undefined,
-    taskId: requireStoryId ? taskId : undefined,
-    threshold: requireThreshold ? threshold : undefined,
-    nowFn,
+    tracesPath: gates.requireTracesPath ? values.tracesPath : undefined,
+    epicId: values.epicId,
+    storyId: gates.requireStoryId ? values.storyId : undefined,
+    taskId: gates.requireStoryId ? values.taskId : undefined,
+    threshold: gates.requireThreshold ? values.threshold : undefined,
+    nowFn: args.nowFn ?? (() => new Date().toISOString()),
   };
 }
+
+const DETECTOR_ARG_RULES = [
+  {
+    field: 'nowFn',
+    gate: 'always',
+    invalid: (v) => v != null && typeof v !== 'function',
+    Error: TypeError,
+    message: (v) =>
+      `nowFn, when provided, must be a function (got ${typeof v})`,
+  },
+  {
+    field: 'tracesPath',
+    gate: 'requireTracesPath',
+    invalid: (v) => typeof v !== 'string' || v.length === 0,
+    Error: TypeError,
+    message: (v) => `tracesPath must be a non-empty string (got ${v})`,
+  },
+  {
+    field: 'epicId',
+    gate: 'always',
+    invalid: (v) => !isPositiveInt(v),
+    Error: RangeError,
+    message: (v) => `epicId must be a positive integer (got ${v})`,
+  },
+  {
+    field: 'storyId',
+    gate: 'requireStoryId',
+    invalid: (v) => !isPositiveInt(v),
+    Error: RangeError,
+    message: (v) => `storyId must be a positive integer (got ${v})`,
+  },
+  {
+    field: 'taskId',
+    gate: 'requireStoryId',
+    invalid: (v) => v !== null && !isPositiveInt(v),
+    Error: RangeError,
+    message: (v) => `taskId must be a positive integer or null (got ${v})`,
+  },
+  {
+    field: 'threshold',
+    gate: 'requireThreshold',
+    invalid: (v) => !Number.isInteger(v) || v < 0,
+    Error: RangeError,
+    message: (v) => `threshold must be a non-negative integer (got ${v})`,
+  },
+];

package/.agents/scripts/lib/single-story-sweep.js

@@ -11,7 +11,7 @@ import {
   executeFastForward as defaultExecuteFastForward,
   planCleanup as defaultPlanCleanup,
   planFastForward as defaultPlanFastForward,
-} from '../git-cleanup.js';
+} from '../clean-git.js';
 import { evaluateProtection as defaultEvaluateProtection } from './single-story-sweep/protection.js';
 import { acquireSweepLock as defaultAcquireSweepLock } from './single-story-sweep/sweep-lock.js';
 
@@ -175,7 +175,7 @@ export function sweepMergedStoryBranches(args = {}) {
 
 /**
  * Content-merged candidates are report-only: content equivalence is weaker
- * than a merged PR or ancestry, so only an operator-confirmed `/git-cleanup`
+ * than a merged PR or ancestry, so only an operator-confirmed `/clean-git`
  * may reap them.
  */
 function partitionContentMerged(candidates) {

package/.agents/scripts/lib/temp-removal.js

@@ -0,0 +1,110 @@
+/**
+ * Filesystem primitives for the temp-retention engine: sizing a tree and
+ * deleting one while sparing the never-purged basenames at any depth.
+ */
+
+import path from 'node:path';
+
+/**
+ * Never deleted, re-checked at the deletion site: `signals.ndjson` is read
+ * long after merge and its loss is silent and unrecoverable.
+ */
+export const KEEP_BASENAMES = Object.freeze(['signals.ndjson']);
+
+/**
+ * `readdir` yielding `[]` for an absent or unreadable directory.
+ *
+ * @param {typeof import('node:fs/promises')} fsp
+ * @param {string} dir
+ * @returns {Promise<import('node:fs').Dirent[]>}
+ */
+export async function safeReaddir(fsp, dir) {
+  try {
+    return await fsp.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Recursive byte total; a vanished child is skipped.
+ *
+ * @param {typeof import('node:fs/promises')} fsp
+ * @param {string} target
+ * @returns {Promise<number>}
+ */
+export async function sizeOf(fsp, target) {
+  let total = 0;
+  const stack = [target];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    let stats;
+    try {
+      stats = await fsp.stat(current);
+    } catch {
+      continue;
+    }
+    if (!stats.isDirectory()) {
+      total += stats.size;
+      continue;
+    }
+    for (const child of await safeReaddir(fsp, current)) {
+      stack.push(path.join(current, child.name));
+    }
+  }
+  return total;
+}
+
+/**
+ * Paths of every never-purged basename at any depth under `target`.
+ *
+ * @param {typeof import('node:fs/promises')} fsp
+ * @param {string} target
+ * @returns {Promise<string[]>}
+ */
+async function findKeptDescendants(fsp, target) {
+  const kept = [];
+  const stack = [target];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    for (const child of await safeReaddir(fsp, current)) {
+      const childPath = path.join(current, child.name);
+      if (child.isDirectory()) stack.push(childPath);
+      else if (KEEP_BASENAMES.includes(child.name)) kept.push(childPath);
+    }
+  }
+  return kept;
+}
+
+/**
+ * Delete `target` while sparing every never-purged basename beneath it: a
+ * tree holding none goes in one `rm`; otherwise its children are removed
+ * one by one and the kept files (with their parent dirs) stay.
+ *
+ * @param {typeof import('node:fs/promises')} fsp
+ * @param {string} target
+ * @param {number} [knownBytes] Pre-computed size, spared a second walk.
+ * @returns {Promise<{ bytes: number, kept: string[] }>}
+ */
+export async function removeSparingKept(fsp, target, knownBytes) {
+  const stats = await fsp.stat(target);
+  if (!stats.isDirectory()) {
+    if (KEEP_BASENAMES.includes(path.basename(target))) {
+      return { bytes: 0, kept: [target] };
+    }
+    await fsp.rm(target, { force: true });
+    return { bytes: stats.size, kept: [] };
+  }
+  const kept = await findKeptDescendants(fsp, target);
+  if (kept.length === 0) {
+    const bytes = knownBytes ?? (await sizeOf(fsp, target));
+    await fsp.rm(target, { recursive: true, force: true });
+    return { bytes, kept };
+  }
+  let bytes = 0;
+  for (const child of await safeReaddir(fsp, target)) {
+    bytes += (await removeSparingKept(fsp, path.join(target, child.name)))
+      .bytes;
+  }
+  return { bytes, kept };
+}

package/.agents/scripts/lib/temp-retention.js

@@ -1,6 +1,7 @@
 /**
  * Allowlisted auto-purge of spent temp artifacts: only a declared class's
- * entries are candidates; the rest are reported, never touched. Never throws
+ * entries are candidates; the rest are reported, never touched by the
+ * auto-purge (only `/clean-temp`'s operator-confirmed path). Never throws
  * — a failed purge must not fail a land, boot, or persist.
  */
 
@@ -13,6 +14,14 @@ import {
   tempRootFrom,
 } from './config/temp-paths.js';
 import { Logger } from './Logger.js';
+import {
+  KEEP_BASENAMES,
+  removeSparingKept,
+  safeReaddir,
+  sizeOf,
+} from './temp-removal.js';
+
+export { KEEP_BASENAMES };
 
 /**
  * Defaults for `delivery.tempRetention`; purge is on unless turned off.
@@ -26,6 +35,7 @@ export const TEMP_RETENTION_DEFAULTS = Object.freeze({
     validationEvidence: true,
     auditResults: true,
     planDirs: true,
+    scratch: true,
   }),
 });
 
@@ -33,12 +43,6 @@ export const PURGE_CLASS_NAMES = Object.freeze(
   Object.keys(TEMP_RETENTION_DEFAULTS.classes),
 );
 
-/**
- * Never deleted, re-checked at the deletion site: `signals.ndjson` is read
- * long after merge and its loss is silent and unrecoverable.
- */
-export const KEEP_BASENAMES = Object.freeze(['signals.ndjson']);
-
 /** Explicit allowlist: an untaught file in a Story dir is kept. */
 const STORY_EVIDENCE_BASENAMES = Object.freeze([
   'validation-evidence.json',
@@ -49,6 +53,9 @@ const STORY_EVIDENCE_BASENAMES = Object.freeze([
 /** Framework-owned, never purged (`*.lock` files are also skipped). */
 const RESERVED_TOP_LEVEL = Object.freeze(['qa', 'cache']);
 
+/** Agent-authored scratch: `scratch/story-<id>/` or any other child. */
+const SCRATCH_DIRNAME = 'scratch';
+
 const MS_PER_DAY = 24 * 60 * 60 * 1000;
 
 const STORY_DIR_PATTERN = /^story-(\d+)$/;
@@ -77,50 +84,6 @@ export function resolveTempRetention(config) {
   };
 }
 
-/**
- * `readdir` yielding `[]` for an absent or unreadable directory.
- *
- * @param {typeof fsPromises} fsp
- * @param {string} dir
- * @returns {Promise<import('node:fs').Dirent[]>}
- */
-async function safeReaddir(fsp, dir) {
-  try {
-    return await fsp.readdir(dir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Recursive byte total; a vanished child is skipped.
- *
- * @param {typeof fsPromises} fsp
- * @param {string} target
- * @returns {Promise<number>}
- */
-async function sizeOf(fsp, target) {
-  let total = 0;
-  const stack = [target];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    let stats;
-    try {
-      stats = await fsp.stat(current);
-    } catch {
-      continue;
-    }
-    if (!stats.isDirectory()) {
-      total += stats.size;
-      continue;
-    }
-    for (const child of await safeReaddir(fsp, current)) {
-      stack.push(path.join(current, child.name));
-    }
-  }
-  return total;
-}
-
 /**
  * One classified entry. `mtimeMs` is the entry's own mtime, not the newest
  * beneath it; widening it would change when an abandoned dir becomes eligible.
@@ -257,13 +220,44 @@ async function scanPlanDirs(tempRoot, fsp) {
   return entries;
 }
 
+/**
+ * `<tempRoot>/scratch/*`: `story-<id>/` is Story-keyed, anything else is
+ * age-floored — the one place an agent's ad-hoc files are reapable.
+ */
+async function scanScratch(tempRoot, fsp) {
+  const dir = path.join(tempRoot, SCRATCH_DIRNAME);
+  const entries = [];
+  for (const dirent of await safeReaddir(fsp, dir)) {
+    const match = dirent.isDirectory()
+      ? STORY_DIR_PATTERN.exec(dirent.name)
+      : null;
+    const entry = await makeEntry(
+      fsp,
+      path.join(dir, dirent.name),
+      'scratch',
+      match ? Number(match[1]) : null,
+    );
+    if (entry) entries.push(entry);
+  }
+  return entries;
+}
+
 const SCANNERS = Object.freeze({
   orchestrationLogs: scanOrchestrationLogs,
   validationEvidence: scanValidationEvidence,
   auditResults: scanAuditResults,
   planDirs: scanPlanDirs,
+  scratch: scanScratch,
 });
 
+/** Fixed top-level dirs a class scanner walks. */
+const CLASS_OWNED_DIRNAMES = Object.freeze([
+  ORCHESTRATION_DIRNAME,
+  'standalone',
+  'audits',
+  SCRATCH_DIRNAME,
+]);
+
 /**
  * Keep in lockstep with the scanners: an entry no class walks must surface
  * as unrecognized.
@@ -273,29 +267,49 @@ const SCANNERS = Object.freeze({
  */
 function isClassOwnedTopLevel(name) {
   return (
-    name === ORCHESTRATION_DIRNAME ||
-    name === 'standalone' ||
-    name === 'audits' ||
+    CLASS_OWNED_DIRNAMES.includes(name) ||
     name.startsWith('plan-') ||
     RUN_DIR_PATTERN.test(name)
   );
 }
 
 /**
- * Unclaimed, non-reserved top-level entries: reported with sizes, never deleted.
+ * Top-level names no path may ever delete: the reserved trees, lock files,
+ * and the never-purged basenames.
+ *
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function isReservedTopLevel(name) {
+  return (
+    RESERVED_TOP_LEVEL.includes(name) ||
+    name.endsWith('.lock') ||
+    KEEP_BASENAMES.includes(name)
+  );
+}
+
+/**
+ * Unclaimed, non-reserved top-level entries: reported with sizes and the
+ * entry's own mtime. The auto-purge never deletes one; only an operator-
+ * confirmed `purgeUnrecognizedEntries` call does.
  *
  * @param {string} tempRoot
  * @param {typeof fsPromises} fsp
- * @returns {Promise<Array<{ path: string, bytes: number }>>}
+ * @returns {Promise<Array<{ path: string, bytes: number, mtimeMs: number }>>}
  */
 async function collectUnrecognized(tempRoot, fsp) {
   const found = [];
   for (const dirent of await safeReaddir(fsp, tempRoot)) {
     const { name } = dirent;
-    if (isClassOwnedTopLevel(name)) continue;
-    if (RESERVED_TOP_LEVEL.includes(name) || name.endsWith('.lock')) continue;
-    const target = path.join(tempRoot, name);
-    found.push({ path: target, bytes: await sizeOf(fsp, target) });
+    if (isClassOwnedTopLevel(name) || isReservedTopLevel(name)) continue;
+    const entry = await makeEntry(fsp, path.join(tempRoot, name), null, null);
+    if (entry) {
+      found.push({
+        path: entry.path,
+        bytes: entry.bytes,
+        mtimeMs: entry.mtimeMs,
+      });
+    }
   }
   return found;
 }
@@ -304,7 +318,7 @@ async function collectUnrecognized(tempRoot, fsp) {
  * Classify a temp tree without deleting anything.
  *
  * @param {{ config?: object, tempRoot?: string, fsp?: typeof fsPromises }} [args]
- * @returns {Promise<{ tempRoot: string, entries: object[], unrecognized: Array<{ path: string, bytes: number }> }>}
+ * @returns {Promise<{ tempRoot: string, entries: object[], unrecognized: Array<{ path: string, bytes: number, mtimeMs: number }> }>}
  */
 export async function collectTempEntries({
   config,
@@ -353,6 +367,7 @@ function isPurgeable(entry, ctx) {
  * @param {typeof fsPromises} [args.fsp]
  * @param {{ info: Function }} [args.logger]
  * @param {string} [args.label]
+ * @param {boolean} [args.dryRun] Report what would go; delete nothing.
  * @returns {Promise<object>} Result envelope; never throws.
  */
 async function purgeTempArtifacts({
@@ -366,6 +381,7 @@ async function purgeTempArtifacts({
   fsp = fsPromises,
   logger = Logger,
   label = 'temp-retention',
+  dryRun = false,
 } = {}) {
   const policy = resolveTempRetention(config);
   const base = {
@@ -402,22 +418,55 @@ async function purgeTempArtifacts({
       if (entry.keep) result.kept.push(entry.path);
       continue;
     }
-    try {
-      await fsp.rm(entry.path, { recursive: true, force: true });
-      result.purged.push({ path: entry.path, bytes: entry.bytes });
-      result.bytesReclaimed += entry.bytes;
-    } catch (err) {
-      result.errors.push(`${entry.path}: ${String(err?.message ?? err)}`);
-    }
+    await purgeOne(fsp, entry, result, dryRun);
   }
 
-  if (result.purged.length > 0) {
-    logger?.info?.(
-      `[${label}] purged ${result.purged.length} spent temp artifact(s), ` +
-        `reclaimed ${formatBytes(result.bytesReclaimed)} under ${result.tempRoot}.`,
+  if (!dryRun) reportPurge(logger, label, result);
+  return result;
+}
+
+/**
+ * One summary line for a purge that deleted something.
+ *
+ * @param {{ info?: Function }|undefined} logger
+ * @param {string} label
+ * @param {object} result
+ */
+function reportPurge(logger, label, result) {
+  if (result.purged.length === 0) return;
+  logger?.info?.(
+    `[${label}] purged ${result.purged.length} spent temp artifact(s), ` +
+      `reclaimed ${formatBytes(result.bytesReclaimed)} under ${result.tempRoot}.`,
+  );
+}
+
+/**
+ * Remove (or, on a dry run, only record) one purgeable entry into `result`.
+ *
+ * @param {typeof fsPromises} fsp
+ * @param {{ path: string, bytes: number }} entry
+ * @param {object} result Mutated in place.
+ * @param {boolean} dryRun
+ * @returns {Promise<void>}
+ */
+async function purgeOne(fsp, entry, result, dryRun) {
+  if (dryRun) {
+    result.purged.push({ path: entry.path, bytes: entry.bytes });
+    result.bytesReclaimed += entry.bytes;
+    return;
+  }
+  try {
+    const { bytes, kept } = await removeSparingKept(
+      fsp,
+      entry.path,
+      entry.bytes,
     );
+    result.kept.push(...kept);
+    result.purged.push({ path: entry.path, bytes });
+    result.bytesReclaimed += bytes;
+  } catch (err) {
+    result.errors.push(`${entry.path}: ${String(err?.message ?? err)}`);
   }
-  return result;
 }
 
 /**

package/.agents/scripts/lib/transpile.js

@@ -8,6 +8,9 @@ const require = createRequire(import.meta.url);
 
 const TS_EXTS = new Set(['.ts', '.tsx', '.mts', '.cts']);
 
+/** TS 7 moved `transpileModule` under `unstable/*`; mirrors the peer range. */
+const SUPPORTED_TS_RANGE = '>=5.0.0 <7';
+
 let _ts = null;
 let _tsLoadFailed = false;
 
@@ -23,6 +26,27 @@ function loadTypeScript() {
   }
 }
 
+/** Compiler modules already diagnosed as API-less — one warning per module. */
+const _unsupportedDiagnosed = new WeakSet();
+
+/**
+ * Warn once per API-less module rather than once per file.
+ *
+ * @param {object} ts
+ * @returns {boolean}
+ */
+function isUsableCompiler(ts) {
+  if (typeof ts.transpileModule === 'function') return true;
+  if (!_unsupportedDiagnosed.has(ts)) {
+    _unsupportedDiagnosed.add(ts);
+    Logger.warn(
+      `[Maintainability] ⚠ typescript ${ts.version ?? 'unknown'} exposes no transpileModule API; ` +
+        `TypeScript files are not scored. Supported range: ${SUPPORTED_TS_RANGE}.`,
+    );
+  }
+  return false;
+}
+
 let _tsVersion = null;
 
 /**
@@ -100,7 +124,7 @@ function buildLineMapper(sourceMapText, code) {
  *
  * @param {string} filePath
  * @param {string} source
- * @param {{withLineMap?: boolean}} [opts]
+ * @param {{withLineMap?: boolean, typescript?: object}} [opts]
  * @returns {string|null|{code: string, mapLine: ((line: number) => number|null)|null}}
  */
 export function transpileIfNeeded(filePath, source, opts = {}) {
@@ -108,14 +132,15 @@ export function transpileIfNeeded(filePath, source, opts = {}) {
   if (!isTypeScriptPath(filePath)) {
     return withLineMap ? { code: source, mapLine: null } : source;
   }
-  const ts = loadTypeScript();
+  const ts = opts?.typescript ?? loadTypeScript();
   if (!ts) {
     Logger.warn(
       `[Maintainability] ⚠ typescript package not resolvable; cannot score ${filePath}. ` +
-        "Install with 'npm install --save-dev typescript' (peer dep, >=5.0.0).",
+        `Install with 'npm install --save-dev typescript' (peer dep, ${SUPPORTED_TS_RANGE}).`,
     );
     return null;
   }
+  if (!isUsableCompiler(ts)) return null;
   try {
     const result = ts.transpileModule(source, {
       compilerOptions: {