@gurulu/cli 0.4.7 → 1.0.0

package/scripts/patches/auto-instrument/astro.cjs

@@ -1,273 +0,0 @@
-// scripts/patches/auto-instrument/astro.cjs — Phase 20 W1 A3.
-//
-// Astro API endpoints live at `src/pages/api/**.{ts,js}` and export HTTP
-// verb functions (`GET`, `POST`, ...). `.astro` components with a server
-// frontmatter block (between `---` fences) are also supported: the patcher
-// extracts the frontmatter JS/TS, detects server-side fetch/data-loading
-// patterns, and injects `gurulu.track()` calls.
-
-const fs = require('fs');
-const path = require('path');
-
-const ast = require('./ast-helper.cjs');
-const singleton = require('./singleton-helper.cjs');
-
-const NAME = 'auto-instrument-astro';
-const SUPPORTED = ['astro'];
-
-function parseEventRoute(routeStr) {
-  if (!routeStr || typeof routeStr !== 'string') return null;
-  const m = routeStr.trim().match(/^([A-Z]+)\s+(\/.*)$/);
-  if (!m) return null;
-  return { method: m[1].toUpperCase(), urlPath: m[2].replace(/\/+$/, '') || '/' };
-}
-
-function routeToCandidates(urlPath) {
-  const cleaned = urlPath.replace(/^\//, '').replace(/\/+$/, '');
-  const segments = cleaned.split('/').filter(Boolean);
-  const exts = ['ts', 'js', 'mjs'];
-  const out = [];
-  for (const ext of exts) {
-    out.push(path.posix.join('src', 'pages', ...segments) + `.${ext}`);
-    out.push(path.posix.join('src', 'pages', ...segments, `index.${ext}`));
-  }
-  // .astro component files (page routes, not API endpoints)
-  out.push(path.posix.join('src', 'pages', ...segments) + '.astro');
-  out.push(path.posix.join('src', 'pages', ...segments, 'index.astro'));
-  return out;
-}
-
-// ---------------------------------------------------------------------------
-// .astro frontmatter support
-// ---------------------------------------------------------------------------
-
-const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
-
-/**
- * Server-side data-loading patterns we look for inside .astro frontmatter.
- * If any match, we consider the frontmatter instrumentable.
- */
-const DATA_LOADING_PATTERNS = [
-  /\bfetch\s*\(/,
-  /\bawait\b/,
-  /\bgetCollection\s*\(/,
-  /\bgetEntryBySlug\s*\(/,
-  /\bAstro\s*\.\s*glob\s*\(/,
-  /\bimport\s*\(/, // dynamic import
-  /\.findMany\s*\(/,
-  /\.find\s*\(/,
-  /\.query\s*\(/,
-  /\.select\s*\(/,
-];
-
-function hasDataLoadingPattern(frontmatterSource) {
-  return DATA_LOADING_PATTERNS.some((re) => re.test(frontmatterSource));
-}
-
-/**
- * Instrument an .astro file's frontmatter block. Parses the JS/TS inside the
- * `---` fences via the shared AST helper, injects gurulu.track() calls, and
- * reconstructs the full .astro file.
- */
-function astInstrumentFrontmatter(source, events, opts = {}) {
-  const fmMatch = source.match(FRONTMATTER_RE);
-  if (!fmMatch) return { ok: false, reason: 'no-frontmatter' };
-
-  const frontmatter = fmMatch[1];
-  if (!hasDataLoadingPattern(frontmatter)) {
-    return { ok: false, reason: 'no-data-loading-pattern' };
-  }
-
-  // Check idempotency — if the frontmatter already has the marker, skip.
-  if (frontmatter.includes(ast.MARKER)) {
-    return {
-      ok: true,
-      after: source,
-      instrumented: [],
-      skipped: events.map((e) => ({ event: e.name, reason: 'already-instrumented' })),
-      changed: false,
-    };
-  }
-
-  // Parse the frontmatter as a standalone JS/TS module.
-  const tree = ast.parseSource(frontmatter);
-
-  // Build track statements for all events.
-  const stmts = events.map((e) => ast.buildTrackStatement(e.name, e.autoProperties));
-
-  // Inject before last return or at end of program body.
-  const body = tree.program;
-  let lastReturnIdx = -1;
-  for (let i = body.body.length - 1; i >= 0; i--) {
-    if (ast.t.isReturnStatement(body.body[i])) {
-      lastReturnIdx = i;
-      break;
-    }
-  }
-
-  // Add marker comment to first track statement
-  if (stmts.length > 0) {
-    // Tag the program itself with a comment (will appear in generated source)
-    const markerComment = ast.t.addComment(
-      body.body[0] || stmts[0],
-      'leading',
-      ` @gurulu-instrumented`,
-      true,
-    );
-  }
-
-  if (lastReturnIdx >= 0) {
-    body.body.splice(lastReturnIdx, 0, ...stmts);
-  } else {
-    // Append at end of frontmatter
-    body.body.push(...stmts);
-  }
-
-  // Sprint D / D4 — alias-aware import.
-  const fmSpecifier = ast.resolveGuruluImportSpecifier(opts.repoRoot, opts.relPath);
-  ast.ensureGuruluImport(tree, fmSpecifier);
-  const newFrontmatter = ast.generateSource(tree, frontmatter);
-
-  // Reconstruct the full .astro file
-  const beforeFm = source.substring(0, fmMatch.index);
-  const afterFm = source.substring(fmMatch.index + fmMatch[0].length);
-  const after = `${beforeFm}---\n${newFrontmatter}\n---${afterFm}`;
-
-  return {
-    ok: true,
-    after,
-    instrumented: events.map((e) => e.name),
-    skipped: [],
-    changed: true,
-  };
-}
-
-function astInstrumentFile(source, method, events, opts = {}) {
-  const tree = ast.parseSource(source);
-  const fns = ast.findExportedFunction(tree, method);
-  if (fns.length === 0) return { ok: false, reason: `${method}-not-found` };
-  const target = fns[0];
-  if (ast.hasInstrumentedMarker(target.fn)) {
-    return {
-      ok: true,
-      after: source,
-      instrumented: [],
-      skipped: events.map((e) => ({ event: e.name, reason: 'already-instrumented' })),
-      changed: false,
-    };
-  }
-  const stmts = events.map((e) => ast.buildTrackStatement(e.name, e.autoProperties));
-  ast.injectTrackBeforeLastReturn(target.fn, target.body, stmts);
-  // Sprint D / D4 — alias-aware import.
-  const specifier = ast.resolveGuruluImportSpecifier(opts.repoRoot, opts.relPath);
-  ast.ensureGuruluImport(tree, specifier);
-  const after = ast.generateSource(tree, source);
-  return {
-    ok: true,
-    after,
-    instrumented: events.map((e) => e.name),
-    skipped: [],
-    changed: true,
-  };
-}
-
-function instrumentEvents(ctx, events) {
-  const helper = singleton.ensureSingletonHelper(ctx, 'astro');
-  const changes = [...helper.changes];
-  const notes = [...helper.notes];
-  let eventsInstrumented = 0;
-  let eventsSkipped = 0;
-
-  if (helper.collision) {
-    return {
-      changes: [],
-      notes,
-      filesModified: 0,
-      eventsInstrumented: 0,
-      eventsSkipped: events ? events.length : 0,
-      collision: true,
-    };
-  }
-
-  const groups = new Map();
-  for (const e of events || []) {
-    const parsed = parseEventRoute(e && e.source && e.source.route);
-    if (!parsed) {
-      notes.push(`skip:${e && e.name}:no-source-route`);
-      eventsSkipped++;
-      continue;
-    }
-    const candidates = routeToCandidates(parsed.urlPath);
-    const found = candidates.find((rel) => fs.existsSync(path.join(ctx.repoRoot, rel)));
-    if (!found) {
-      notes.push(`skip:${e.name}:route-file-not-found`);
-      eventsSkipped++;
-      continue;
-    }
-    const key = `${found}::${parsed.method}`;
-    if (!groups.has(key)) groups.set(key, { relPath: found, method: parsed.method, events: [] });
-    groups.get(key).events.push(e);
-  }
-
-  for (const group of groups.values()) {
-    const abs = path.join(ctx.repoRoot, group.relPath);
-    const before = fs.readFileSync(abs, 'utf8');
-    // Sprint D / D4 — pass repoRoot + relPath to the import resolver.
-    const fileOpts = { repoRoot: (ctx && ctx.repoRoot) || null, relPath: group.relPath };
-    let res;
-    try {
-      const isAstroComponent = group.relPath.endsWith('.astro');
-      res = isAstroComponent
-        ? astInstrumentFrontmatter(before, group.events, fileOpts)
-        : astInstrumentFile(before, group.method, group.events, fileOpts);
-    } catch (err) {
-      const msg = (err && err.message) || String(err);
-      // eslint-disable-next-line no-console
-      console.warn(`[auto-instrument] patch.fallback ${group.relPath}: ${msg}`);
-      notes.push(`patch.fallback:${group.relPath}:${msg}`);
-      continue;
-    }
-    if (!res.ok) {
-      for (const e of group.events) {
-        notes.push(`skip:${e.name}:${res.reason}`);
-        eventsSkipped++;
-      }
-      continue;
-    }
-    for (const s of res.skipped || []) {
-      notes.push(`skip:${s.event}:${s.reason}`);
-      eventsSkipped++;
-    }
-    if (res.changed) {
-      changes.push({
-        relPath: group.relPath,
-        before,
-        after: res.after,
-        reason: `auto-instrument-astro`,
-        type: 'auto-instrument',
-      });
-      eventsInstrumented += (res.instrumented || []).length;
-    }
-  }
-
-  const filesModified = changes.filter((c) => c.type === 'auto-instrument').length;
-  return { changes, notes, filesModified, eventsInstrumented, eventsSkipped, collision: false };
-}
-
-function ensureSingletonHelper(ctx) {
-  return singleton.ensureSingletonHelper(ctx, 'astro');
-}
-
-module.exports = {
-  name: NAME,
-  supportedFrameworks: SUPPORTED,
-  ensureSingletonHelper,
-  instrumentEvents,
-  _internals: {
-    parseEventRoute,
-    routeToCandidates,
-    astInstrumentFile,
-    astInstrumentFrontmatter,
-    hasDataLoadingPattern,
-  },
-};

package/scripts/patches/auto-instrument/express.cjs

@@ -1,383 +0,0 @@
-// scripts/patches/auto-instrument/express.cjs — Phase 20 W1 A1.
-//
-// AST-based auto-instrumentation for Express route files. We walk common
-// entry files + `routes/**` and search for `app.<method>('/path', handler)`
-// or `router.<method>('/path', handler)` call expressions. Once we locate
-// the matching call we inject `gurulu.track(...)` inside the handler body
-// (last argument, arrow or function expression).
-//
-// Regex fallback is retained for graceful degradation on parse failure.
-
-const fs = require('fs');
-const path = require('path');
-
-const ast = require('./ast-helper.cjs');
-const singleton = require('./singleton-helper.cjs');
-
-const NAME = 'auto-instrument-express';
-const SUPPORTED = ['express'];
-const MARKER = '// @gurulu-instrumented';
-const IMPORT_LINE_ESM = "import { gurulu } from '@/lib/gurulu';";
-const IMPORT_LINE_CJS = "const { gurulu } = require('./lib/gurulu');";
-
-const CANDIDATE_ENTRIES = [
-  'app.js',
-  'server.js',
-  'index.js',
-  'src/app.js',
-  'src/server.js',
-  'src/index.js',
-  'src/app.ts',
-  'src/server.ts',
-  'src/index.ts',
-];
-
-function walkRoutes(repoRoot) {
-  const results = [];
-  const dirs = ['routes', 'src/routes', 'api', 'src/api'];
-  for (const d of dirs) {
-    const abs = path.join(repoRoot, d);
-    if (!fs.existsSync(abs)) continue;
-    for (const entry of fs.readdirSync(abs, { withFileTypes: true })) {
-      if (entry.isFile() && /\.(js|ts|mjs|cjs)$/.test(entry.name)) {
-        results.push(path.posix.join(d, entry.name));
-      }
-    }
-  }
-  return results;
-}
-
-function parseRoute(routeStr) {
-  if (!routeStr || typeof routeStr !== 'string') return null;
-  const m = routeStr.trim().match(/^([A-Z]+)\s+(\/.*)$/);
-  if (!m) return null;
-  return { method: m[1].toUpperCase(), urlPath: m[2].replace(/\/+$/, '') || '/' };
-}
-
-// ---------------------------------------------------------------------------
-// AST path
-// ---------------------------------------------------------------------------
-
-/**
- * Find all `app.<method>('path', ..., handler)` or `router.<method>(...)`
- * call expressions matching the given method + urlPath. Returns an array of
- * `{ fn, body }` entries (the handler arrow/function bodies).
- */
-function findRouteHandlers(tree, method, urlPath) {
-  const t = ast.t;
-  const results = [];
-  const lowerMethod = method.toLowerCase();
-  ast.traverse(tree, {
-    CallExpression(p) {
-      const callee = p.node.callee;
-      if (!t.isMemberExpression(callee)) return;
-      if (!t.isIdentifier(callee.property) || callee.property.name !== lowerMethod) return;
-      if (!t.isIdentifier(callee.object)) return;
-      const obj = callee.object.name;
-      if (obj !== 'app' && obj !== 'router') return;
-      const args = p.node.arguments;
-      if (args.length < 2) return;
-      if (!t.isStringLiteral(args[0]) || args[0].value !== urlPath) return;
-      // The final argument should be the handler function.
-      const handler = args[args.length - 1];
-      if (
-        (t.isArrowFunctionExpression(handler) || t.isFunctionExpression(handler)) &&
-        t.isBlockStatement(handler.body)
-      ) {
-        results.push({ fn: handler, body: handler.body });
-      }
-    },
-  });
-  return results;
-}
-
-function astInstrumentFile(source, method, urlPath, events, opts = {}) {
-  const tree = ast.parseSource(source);
-  const handlers = findRouteHandlers(tree, method, urlPath);
-  if (handlers.length === 0) {
-    return { ok: false, reason: 'handler-not-found' };
-  }
-  const target = handlers[0];
-  if (ast.hasInstrumentedMarker(target.fn)) {
-    return {
-      ok: true,
-      after: source,
-      instrumented: [],
-      skipped: events.map((e) => ({ event: e.name, reason: 'already-instrumented' })),
-      changed: false,
-    };
-  }
-  const stmts = events.map((e) => ast.buildTrackStatement(e.name, e.autoProperties));
-  ast.injectTrackBeforeLastReturn(target.fn, target.body, stmts);
-  // Sprint D / D4 — alias-aware import (Express usually has no `@/*` alias).
-  const specifier = ast.resolveGuruluImportSpecifier(opts.repoRoot, opts.relPath);
-  ast.ensureGuruluImport(tree, specifier);
-  const after = ast.generateSource(tree, source);
-  return {
-    ok: true,
-    after,
-    instrumented: events.map((e) => e.name),
-    skipped: [],
-    changed: true,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Regex fallback
-// ---------------------------------------------------------------------------
-
-function regexFindHandlerStart(source, method, urlPath) {
-  const lower = method.toLowerCase();
-  const escapedPath = urlPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const re = new RegExp(
-    `(?:app|router)\\.${lower}\\s*\\(\\s*['"\`]${escapedPath}['"\`]\\s*,`,
-  );
-  const m = re.exec(source);
-  if (!m) return null;
-  let i = m.index + m[0].length;
-  const tail = source.slice(i);
-  const arrowIdx = tail.search(/=>\s*\{/);
-  const funcIdx = tail.search(/function\s*[^(]*\([^)]*\)\s*\{/);
-  let bodyOpen = -1;
-  if (arrowIdx !== -1 && (funcIdx === -1 || arrowIdx < funcIdx)) {
-    bodyOpen = i + tail.indexOf('{', arrowIdx);
-  } else if (funcIdx !== -1) {
-    bodyOpen = i + tail.indexOf('{', funcIdx);
-  }
-  if (bodyOpen === -1) return null;
-  let depth = 0;
-  for (let j = bodyOpen; j < source.length; j++) {
-    const c = source[j];
-    if (c === '{') depth++;
-    else if (c === '}') {
-      depth--;
-      if (depth === 0) return { start: bodyOpen, end: j };
-    }
-  }
-  return null;
-}
-
-function regexFindLastResponseCall(source, start, end) {
-  const snippet = source.slice(start, end);
-  const patterns = [
-    /res\.status\s*\([^)]*\)\s*\.json\s*\(/g,
-    /res\.status\s*\([^)]*\)\s*\.send\s*\(/g,
-    /res\.json\s*\(/g,
-    /res\.send\s*\(/g,
-    /res\.sendStatus\s*\(/g,
-    /res\.end\s*\(/g,
-  ];
-  let lastIdx = -1;
-  for (const re of patterns) {
-    let m;
-    while ((m = re.exec(snippet)) !== null) {
-      if (m.index > lastIdx) lastIdx = m.index;
-    }
-  }
-  if (lastIdx === -1) return null;
-  const absoluteIdx = start + lastIdx;
-  let lineStart = absoluteIdx;
-  while (lineStart > 0 && source[lineStart - 1] !== '\n') lineStart--;
-  const indentMatch = source.slice(lineStart, absoluteIdx).match(/^(\s*)/);
-  const indent = (indentMatch && indentMatch[1]) || '  ';
-  return { insertAt: lineStart, indent };
-}
-
-function regexEnsureImport(source, opts = {}) {
-  if (source.includes(IMPORT_LINE_ESM) || source.includes(IMPORT_LINE_CJS)) return source;
-  // Sprint D / D4 — alias-aware specifier. ESM-only branch picks `@/lib/gurulu`
-  // when tsconfig declares it, otherwise a relative import. The CJS branch
-  // continues to use `./lib/gurulu` since CommonJS does not honor TS paths.
-  const isCjs = /\brequire\s*\(/.test(source) && !/^import\s/m.test(source);
-  let line;
-  if (isCjs) {
-    line = IMPORT_LINE_CJS;
-  } else if (opts.repoRoot) {
-    const specifier = ast.resolveGuruluImportSpecifier(opts.repoRoot, opts.relPath);
-    line = `import { gurulu } from '${specifier}';`;
-  } else {
-    line = IMPORT_LINE_ESM;
-  }
-  const importRegex = /^(?:import[\s\S]*?;\s*\n)+/m;
-  const requireRegex = /^(?:const\s[\s\S]*?require\([\s\S]*?\);\s*\n)+/m;
-  const m = source.match(importRegex) || source.match(requireRegex);
-  if (m) {
-    const end = m.index + m[0].length;
-    return source.slice(0, end) + line + '\n' + source.slice(end);
-  }
-  return line + '\n' + source;
-}
-
-function regexBuildTrackCall(eventName, indent) {
-  const safeName = JSON.stringify(eventName);
-  return `${indent}${MARKER} ${eventName}\n${indent}gurulu.track(${safeName}, {});\n`;
-}
-
-function regexInstrumentFile(before, method, urlPath, events, opts = {}) {
-  const body = regexFindHandlerStart(before, method, urlPath);
-  if (!body) return { ok: false, reason: 'handler-not-found' };
-  const snippet = before.slice(body.start, body.end);
-  const needed = [];
-  const skipped = [];
-  for (const e of events) {
-    if (snippet.includes(`${MARKER} ${e.name}`)) {
-      skipped.push({ event: e.name, reason: 'already-instrumented' });
-    } else {
-      needed.push(e);
-    }
-  }
-  if (needed.length === 0) return { ok: true, after: before, instrumented: [], skipped, changed: false };
-  const ret = regexFindLastResponseCall(before, body.start, body.end);
-  if (!ret) return { ok: false, reason: 'no-response-found' };
-  const block = needed.map((e) => regexBuildTrackCall(e.name, ret.indent)).join('');
-  let after = before.slice(0, ret.insertAt) + block + before.slice(ret.insertAt);
-  after = regexEnsureImport(after, opts);
-  return {
-    ok: true,
-    after,
-    instrumented: needed.map((e) => e.name),
-    skipped,
-    changed: true,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Glue
-// ---------------------------------------------------------------------------
-
-function resolveRouteFile(ctx, method, urlPath) {
-  const seen = new Set();
-  const candidates = [
-    ...CANDIDATE_ENTRIES,
-    ...walkRoutes(ctx.repoRoot),
-  ].filter((rel) => {
-    if (seen.has(rel)) return false;
-    seen.add(rel);
-    return fs.existsSync(path.join(ctx.repoRoot, rel));
-  });
-  for (const rel of candidates) {
-    const src = fs.readFileSync(path.join(ctx.repoRoot, rel), 'utf8');
-    // Cheap pre-filter: must contain `.${method.toLowerCase()}(`.
-    if (!src.includes(`.${method.toLowerCase()}(`)) continue;
-    try {
-      const tree = ast.parseSource(src);
-      const handlers = findRouteHandlers(tree, method, urlPath);
-      if (handlers.length > 0) return { relPath: rel };
-    } catch (_) {
-      // Regex check as last-ditch.
-      if (regexFindHandlerStart(src, method, urlPath)) return { relPath: rel };
-    }
-  }
-  return null;
-}
-
-function instrumentEvents(ctx, events) {
-  const helper = singleton.ensureSingletonHelper(ctx, 'express');
-  const changes = [...helper.changes];
-  const notes = [...helper.notes];
-  let eventsInstrumented = 0;
-  let eventsSkipped = 0;
-
-  if (helper.collision) {
-    return {
-      changes: [],
-      notes,
-      filesModified: 0,
-      eventsInstrumented: 0,
-      eventsSkipped: events ? events.length : 0,
-      collision: true,
-    };
-  }
-
-  const groups = new Map();
-  for (const e of events || []) {
-    const parsed = parseRoute(e && e.source && e.source.route);
-    if (!parsed) {
-      notes.push(`skip:${e && e.name}:no-source-route`);
-      eventsSkipped++;
-      continue;
-    }
-    const resolved = resolveRouteFile(ctx, parsed.method, parsed.urlPath);
-    if (!resolved) {
-      notes.push(`skip:${e.name}:route-not-found`);
-      eventsSkipped++;
-      continue;
-    }
-    const key = `${resolved.relPath}::${parsed.method}::${parsed.urlPath}`;
-    if (!groups.has(key)) {
-      groups.set(key, {
-        relPath: resolved.relPath,
-        method: parsed.method,
-        urlPath: parsed.urlPath,
-        events: [],
-      });
-    }
-    groups.get(key).events.push(e);
-  }
-
-  for (const group of groups.values()) {
-    const abs = path.join(ctx.repoRoot, group.relPath);
-    const before = fs.readFileSync(abs, 'utf8');
-    // Sprint D / D4 — thread repoRoot + relPath into the import resolver.
-    const fileOpts = { repoRoot: (ctx && ctx.repoRoot) || null, relPath: group.relPath };
-    let res;
-    try {
-      res = astInstrumentFile(before, group.method, group.urlPath, group.events, fileOpts);
-    } catch (err) {
-      const msg = (err && err.message) || String(err);
-      // eslint-disable-next-line no-console
-      console.warn(`[auto-instrument] patch.fallback ${group.relPath}: ${msg}`);
-      notes.push(`patch.fallback:${group.relPath}:${msg}`);
-      res = regexInstrumentFile(before, group.method, group.urlPath, group.events, fileOpts);
-    }
-    if (!res.ok) {
-      for (const e of group.events) {
-        notes.push(`skip:${e.name}:${res.reason || 'instrument-failed'}`);
-        eventsSkipped++;
-      }
-      continue;
-    }
-    for (const s of res.skipped || []) {
-      notes.push(`skip:${s.event}:${s.reason}`);
-      eventsSkipped++;
-    }
-    if (!res.changed) continue;
-    // Merge with earlier staged change to the same file (AST already takes
-    // care of dedup-by-marker within a single call, so we just overwrite).
-    const existing = changes.find((c) => c.relPath === group.relPath && c.type === 'auto-instrument');
-    if (existing) {
-      existing.after = res.after;
-    } else {
-      changes.push({
-        relPath: group.relPath,
-        before,
-        after: res.after,
-        reason: `auto-instrument-${group.method}`,
-        type: 'auto-instrument',
-      });
-    }
-    eventsInstrumented += (res.instrumented || []).length;
-  }
-
-  const filesModified = changes.filter((c) => c.type === 'auto-instrument').length;
-  return { changes, notes, filesModified, eventsInstrumented, eventsSkipped, collision: false };
-}
-
-function ensureSingletonHelper(ctx) {
-  return singleton.ensureSingletonHelper(ctx, 'express');
-}
-
-module.exports = {
-  name: NAME,
-  supportedFrameworks: SUPPORTED,
-  ensureSingletonHelper,
-  instrumentEvents,
-  _internals: {
-    parseRoute,
-    resolveRouteFile,
-    astInstrumentFile,
-    regexInstrumentFile,
-    walkRoutes,
-    findRouteHandlers,
-  },
-};