c64bridge 0.5.1 → 0.6.0

package/scripts/rag-rebuild.mjs

@@ -21,24 +21,22 @@ async function main() {
   let LocalMiniHashEmbedding;
   let buildAllIndexes;
 
-  if (await fileExists(distEmbeddings) && await fileExists(distIndexer)) {
+  const isBun = typeof globalThis.Bun !== 'undefined';
+
+  if (!isBun && await fileExists(distEmbeddings) && await fileExists(distIndexer)) {
     const em = await import(pathToFileURL(distEmbeddings).href);
     const ix = await import(pathToFileURL(distIndexer).href);
     LocalMiniHashEmbedding = em.LocalMiniHashEmbedding;
     buildAllIndexes = ix.buildAllIndexes;
+  } else if (isBun) {
+    const em = await import(pathToFileURL(path.join(projectRoot, 'src', 'rag', 'embeddings.ts')).href);
+    const ix = await import(pathToFileURL(path.join(projectRoot, 'src', 'rag', 'indexer.ts')).href);
+    LocalMiniHashEmbedding = em.LocalMiniHashEmbedding;
+    buildAllIndexes = ix.buildAllIndexes;
   } else {
-    // Fall back to TypeScript sources via ts-node when available
-    try {
-      await import('./register-ts-node.mjs');
-      const em = await import(pathToFileURL(path.join(projectRoot, 'src', 'rag', 'embeddings.ts')).href);
-      const ix = await import(pathToFileURL(path.join(projectRoot, 'src', 'rag', 'indexer.ts')).href);
-      LocalMiniHashEmbedding = em.LocalMiniHashEmbedding;
-      buildAllIndexes = ix.buildAllIndexes;
-    } catch (err) {
-      console.error('[rag-rebuild] Unable to load RAG modules from dist or src:', err);
-      process.exit(1);
-      return;
-    }
+    console.error('[rag-rebuild] Unable to locate compiled artifacts. Run `bun run build` (or `npm run build`) before invoking this script under Node.');
+    process.exit(1);
+    return;
   }
 
   const dim = Number(process.env.RAG_EMBED_DIM ?? 384);

package/scripts/run-mcp-check.sh

@@ -15,6 +15,14 @@ TMPDIR=$(mktemp -d)
 MOCK_INFO="$TMPDIR/mock-info.json"
 CFG_FILE="$TMPDIR/.c64bridge.json"
 
+if command -v bun >/dev/null 2>&1; then
+  BUILD_CMD=(bun run build)
+elif [[ -x "${HOME}/.bun/bin/bun" ]]; then
+  BUILD_CMD=("${HOME}/.bun/bin/bun" run build)
+else
+  BUILD_CMD=(npm run build)
+fi
+
 cleanup() {
   set +e
   [[ -n "${MCP_PID:-}" ]] && kill -TERM "$MCP_PID" 2>/dev/null || true
@@ -68,7 +76,7 @@ echo "==> Starting MCP server in '$MODE' mode for $DURATION seconds..."
 echo "==> Logs will be written to: $(realpath "$LOGFILE")"
 
 if [[ "$MODE" == "local" ]]; then
-  (cd "$ROOT_DIR" && npm run build)
+  (cd "$ROOT_DIR" && "${BUILD_CMD[@]}")
   VERSION=$(node -p "require('$ROOT_DIR/package.json').version")
   echo "==> Running local build version $VERSION"
   (cd "$ROOT_DIR" && node dist/index.js) 2>&1 | tee "$LOGFILE" &
@@ -101,4 +109,4 @@ else
   exit 1
 fi
 
-echo "==> Run complete. Logs saved to: $(realpath "$LOGFILE")"
+echo "==> Run complete. Logs saved to: $(realpath "$LOGFILE")"

package/scripts/run-tests.mjs

@@ -3,15 +3,15 @@ import { spawn } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { fileURLToPath } from "node:url";
 
 const DEFAULT_TARGET = "mock";
 
 let target = DEFAULT_TARGET;
 let explicitBaseUrl = null;
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const registerSpec = pathToFileURL(path.join(repoRoot, "scripts", "register-ts-node.mjs")).href;
-const nodeArgs = ["--import", registerSpec, "--test"];
+const registerDataUri = "data:text/javascript,import { register } from \"node:module\"; import { pathToFileURL } from \"node:url\"; register(\"ts-node/esm\", pathToFileURL(\"./\"));";
+const nodeArgs = ["--import", registerDataUri, "--test"];
 
 for (const arg of process.argv.slice(2)) {
   if (arg === "--mock") {

package/scripts/run-tests.ts

@@ -0,0 +1,187 @@
+#!/usr/bin/env bun
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+const DEFAULT_TARGET = "mock";
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const defaultEmbeddingsDir = path.join(repoRoot, "artifacts", "test-embeddings");
+
+let target = DEFAULT_TARGET;
+let explicitBaseUrl: string | null = null;
+let runCoverage = false;
+const passthrough: string[] = [];
+
+for (const arg of process.argv.slice(2)) {
+  if (arg === "--mock") {
+    target = "mock";
+    continue;
+  }
+  if (arg === "--real") {
+    target = "real";
+    continue;
+  }
+  if (arg.startsWith("--target=")) {
+    target = arg.split("=", 2)[1] ?? DEFAULT_TARGET;
+    continue;
+  }
+  if (arg.startsWith("--base-url=")) {
+    explicitBaseUrl = arg.split("=", 2)[1] ?? null;
+    continue;
+  }
+  if (arg === "--coverage") {
+    runCoverage = true;
+    continue;
+  }
+  passthrough.push(arg);
+}
+
+if (!fs.existsSync(defaultEmbeddingsDir)) {
+  fs.mkdirSync(defaultEmbeddingsDir, { recursive: true });
+}
+
+const env: Record<string, string> = { ...process.env } as Record<string, string>;
+env.C64_TEST_TARGET = target;
+if (!env.RAG_EMBEDDINGS_DIR) {
+  env.RAG_EMBEDDINGS_DIR = defaultEmbeddingsDir;
+}
+if (explicitBaseUrl) {
+  env.C64_TEST_BASE_URL = explicitBaseUrl;
+}
+if (target === "real" && !env.C64_TEST_BASE_URL) {
+  env.C64_TEST_BASE_URL = resolveBaseUrlFromConfig() ?? "http://c64u";
+}
+
+const bunExecutable = process.execPath;
+const cmd = [
+  bunExecutable,
+  "test",
+  ...(runCoverage
+    ? [
+        "--coverage",
+        // Ensure LCOV is emitted for Codecov
+        "--coverage-reporter=lcov",
+        // Use supported console reporter in Bun
+        "--coverage-reporter=text",
+      ]
+    : []),
+  ...passthrough,
+];
+const child = Bun.spawn({
+  cmd,
+  cwd: repoRoot,
+  env,
+  stdout: "inherit",
+  stderr: "inherit",
+});
+
+const exitCode = await child.exited;
+process.exit(typeof exitCode === "number" ? exitCode : 1);
+
+function resolveBaseUrlFromConfig(): string | null {
+  const configPathEnv = env.C64BRIDGE_CONFIG;
+  const homeConfig = os.homedir() ? path.join(os.homedir(), ".c64bridge.json") : null;
+  const repoConfig = path.join(repoRoot, ".c64bridge.json");
+  for (const candidate of [configPathEnv, homeConfig, repoConfig]) {
+    if (!candidate) continue;
+    try {
+      const raw = JSON.parse(fs.readFileSync(candidate, "utf8"));
+      const base = resolveBaseUrlFromJson(raw);
+      if (base) return base;
+    } catch (error) {
+      if (isSystemError(error) && error.code === "ENOENT") {
+        continue;
+      }
+      console.warn(`[run-tests] Failed to read config at ${candidate}:`, error);
+    }
+  }
+  return null;
+}
+
+function resolveBaseUrlFromJson(raw: unknown): string | null {
+  if (!raw || typeof raw !== "object") return null;
+  const root = raw as Record<string, unknown>;
+  const c64u = root.c64u;
+  if (c64u && typeof c64u === "object") {
+    const base = stringIfSet((c64u as Record<string, unknown>).baseUrl);
+    if (base) return normalizeBase(base);
+    const hostEntry = firstDefined(
+      stringIfSet((c64u as Record<string, unknown>).host),
+      stringIfSet((c64u as Record<string, unknown>).hostname),
+    );
+    const parsed = parseEndpoint(hostEntry);
+    const port = firstDefined(numberIfPort((c64u as Record<string, unknown>).port), parsed.port, DEFAULT_PORT);
+    if (parsed.hostname) {
+      return buildBaseUrl(parsed.hostname, port);
+    }
+  }
+  const legacyBase = stringIfSet(root.baseUrl);
+  if (legacyBase) return normalizeBase(legacyBase);
+  const legacyHost = firstDefined(stringIfSet(root.c64_host), stringIfSet(root.c64_ip));
+  if (legacyHost) {
+    const parsed = parseEndpoint(legacyHost);
+    const port = firstDefined(parsed.port, DEFAULT_PORT);
+    const hostname = parsed.hostname ?? legacyHost;
+    return buildBaseUrl(hostname, port);
+  }
+  return null;
+}
+
+function stringIfSet(value: unknown): string | null {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+function numberIfPort(value: unknown): number | null {
+  if (typeof value === "number" && Number.isInteger(value) && value > 0 && value <= 65535) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value.trim());
+    if (Number.isInteger(parsed) && parsed > 0 && parsed <= 65535) {
+      return parsed;
+    }
+  }
+  return null;
+}
+
+function normalizeBase(input: string): string {
+  return /^[a-z][a-z0-9+.-]*:\/\//i.test(input) ? input.replace(/\/+$/, "") : `http://${input}`;
+}
+
+function parseEndpoint(value: string | null): { hostname?: string; port?: number } {
+  const input = value && value.trim() ? value.trim() : null;
+  if (!input) return {};
+  try {
+    const hasScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(input);
+    const url = new URL(hasScheme ? input : `http://${input}`);
+    const hostname = url.hostname || undefined;
+    const port = url.port ? numberIfPort(url.port) ?? undefined : undefined;
+    return { hostname, port };
+  } catch {
+    return {};
+  }
+}
+
+const DEFAULT_PORT = 80;
+
+function buildBaseUrl(host: string, port: number | undefined): string {
+  const normalizedPort = Number.isInteger(port) && (port as number) > 0 ? (port as number) : DEFAULT_PORT;
+  const hostPart = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+  const suffix = normalizedPort === DEFAULT_PORT ? "" : `:${normalizedPort}`;
+  return `http://${hostPart}${suffix}`;
+}
+
+function firstDefined<T>(...values: Array<T | undefined | null>): T | undefined {
+  for (const value of values) {
+    if (value !== undefined && value !== null) {
+      return value;
+    }
+  }
+  return undefined;
+}
+
+function isSystemError(error: unknown): error is NodeJS.ErrnoException {
+  return Boolean(error && typeof error === "object" && "code" in error);
+}

package/scripts/start.mjs

@@ -27,36 +27,13 @@ async function fileExists(filePath) {
   }
 }
 
-function isModuleNotFound(error) {
-  if (!error || typeof error !== 'object') {
-    return false;
-  }
-  const err = error;
-  if (err.code === 'ERR_MODULE_NOT_FOUND') {
-    return true;
-  }
-  const message = typeof err.message === 'string' ? err.message : '';
-  return message.includes('Cannot find module');
-}
-
 async function launch() {
   const srcEntry = path.resolve(projectRoot, 'src/index.ts');
   const distEntry = path.resolve(projectRoot, 'dist/index.js');
 
-  if (await fileExists(srcEntry)) {
-    try {
-      await import('./register-ts-node.mjs');
-      await import(pathToFileURL(srcEntry).href);
-      return;
-    } catch (error) {
-      if (isModuleNotFound(error)) {
-        console.warn('[start] ts-node not available; falling back to compiled output.');
-      } else {
-        console.error('[start] Failed to launch TypeScript sources:', error);
-        process.exitCode = 1;
-        return;
-      }
-    }
+  if (typeof globalThis.Bun !== 'undefined' && await fileExists(srcEntry)) {
+    await import(pathToFileURL(srcEntry).href);
+    return;
   }
 
   if (await fileExists(distEntry)) {

package/scripts/update-readme.ts

@@ -126,8 +126,24 @@ function renderPromptsSection(): string[] {
   ];
 }
 
+function renderSummarySection(): string[] {
+  const modules = describeToolModules();
+  const resources = listKnowledgeResources();
+  const promptRegistry = createPromptRegistry();
+  const prompts = promptRegistry.list();
+
+  const toolCount = modules.reduce((sum, module) => sum + module.tools.length, 0);
+  const resourceCount = resources.length;
+  const promptCount = prompts.length;
+
+  return [
+    `This MCP server exposes **${toolCount} tools**, **${resourceCount} resources**, and **${promptCount} prompts** for controlling your Commodore 64.`,
+    "",
+  ];
+}
+
 function buildDocumentation(): string {
-  const sections = [renderToolsSection(), renderResourcesSection(), renderPromptsSection()];
+  const sections = [renderSummarySection(), renderToolsSection(), renderResourcesSection(), renderPromptsSection()];
   return sections.flat().join("\n").trim();
 }
 

package/scripts/verify-package.mjs

@@ -46,7 +46,6 @@ function assertSpotChecks() {
     'generated/c64/index.js',
     'scripts/cli.js',
     'scripts/start.mjs',
-    'scripts/register-ts-node.mjs',
   ];
   const dirs = [
     'doc',

package/data/assembly/examples/effects/sinewave.asm

@@ -1,5 +0,0 @@
-        *= $0801
-        LDA #$00
-LOOP    STA $D020
-        ADC #$01
-        JMP LOOP

package/doc/meta-tools-rollout.md

@@ -1,211 +0,0 @@
-## Meta Tools Rollout Plan for c64bridge
-
-Purpose: Provide a concrete, dependency-aware rollout approach for the meta tools defined in `doc/meta-tools.md`. This plan gives ordered, checkable task lists and high-level implementation notes. It is written so another LLM can execute the rollout autonomously.
-
-### Required reading
-
-The following documents need to be read and understood before starting the rollout:
-
-- `doc/meta-tools.md` — Meta tools definitions, effort/benefit/dependencies matrix
-- `doc/agent-state-spec.md` — Background task registry and persistence model
-- `doc/developer.md` — Architecture overview and contribution guidelines
-
-### Operator rules for the LLM performing the rollout
-
-- Always work tasks strictly in order as listed. Do not skip ahead unless a task is cancelled.
-- After each checklist item, run the full build and test suite and proceed only if it passes:
-  - Preferred: `npm run check` (build + tests) or `npm test` if already built.
-- If tests fail:
-  - Fix the cause if obvious and retry once.
-  - If still failing, revert the last change and leave a short note in the status log, then stop.
-- Keep edits minimal and focused. Prefer small, incremental changes.
-- Update documentation in the same change when tool behavior or surface changes.
-- For any new code, add/extend tests that cover basic happy path and one failure path.
-- Respect device-affecting safeguards already in the codebase (pause/resume, stream mutual exclusion, time limits).
-
-### Global implementation template (apply per meta tool)
-
-- [ ] Read the tool’s entry in `doc/meta-tools.md` and its Effort/Benefit/Dependencies.
-- [ ] Verify prerequisites (dependencies implemented). If missing, pause and complete dependencies first.
-- [ ] Implement the meta tool wrapper in the MCP server (compose existing low-level tools; avoid firmware-only assumptions).
-- [ ] Add or extend unit/integration tests for the meta tool’s happy path and a basic failure case.
-- [ ] Update docs: ensure the tool’s documentation is aligned; add usage hints if applicable.
-- [ ] Run full build + tests: `npm run check` must pass.
-
-Notes:
-
-- Do not expand the REST surface; meta tools must compose existing MCP tools.
-- Ensure mutual exclusion where streams and debug capture conflict.
-- Enforce timeouts and guardrails for background/scheduled operations.
-
----
-
-### Phase 0 — Foundations (low-effort, high-benefit, unlocks others)
-
-- [x] `firmware_info_and_healthcheck` — Implementation notes:
-  - Compose version, info, and a tiny `readmem` probe. Return structured readiness.
-  - Use short, bounded timeouts; capture latency metrics.
-- [x] `wait_for_screen_text` — Implementation notes:
-  - Poll screen RAM via existing helper; support regex and plain text. Provide timeout and interval.
-  - Return match bounds and elapsed time.
-- [x] `verify_and_write_memory` — Implementation notes:
-  - Pause → read → verify → write → read-back → resume. Abort on mismatch.
-  - Parameterize verification masks and expected buffer; return a diff when failing.
-- [x] `start_background_task` / `stop_background_task` / `list_background_tasks` / `stop_all_background_tasks` — Implementation notes:
-  - Implement a persistent registry (in-memory with serialized state to disk if available).
-  - Support fixed-interval scheduling and a maximum iterations cap.
-- [x] `find_paths_by_name` — Implementation notes:
-  - Container-aware discovery using wildcard info endpoints; return host and logical paths.
-  - Cache recent results with a short TTL to avoid repeated scans.
-- [x] `memory_dump_to_file` — Implementation notes:
-  - Chunked reads with retries; optional pause/resume. Support hex and binary formats.
-  - Emit a checksum and write a manifest alongside the dump.
-- [x] `config_snapshot_and_restore` — Implementation notes:
-  - Read all categories, persist versioned JSON; support batch restore and diff preview.
-
-Requirement: After each checkbox completion, run `npm run check` and proceed only on success.
-
----
-
-### Phase 1 — Orchestration and assertions
-
-- [x] `program_shuffle` — Implementation notes:
-  - Discover PRG/CRT under root; run each for a duration; capture screen; soft reset.
-  - Persist a light run log per program.
-- [x] `batch_run_with_assertions` — Implementation notes:
-  - Accept assertions: screen contains text, memory equals byte, SID silent.
-  - Produce junit-like results; stop on failure or continue-on-error per flag.
-- [x] `bundle_run_artifacts` — Implementation notes:
-  - Gather screen, memory snapshot, debugreg; structure outputs per run id.
-- [x] `compile_run_verify_cycle` — Implementation notes:
-  - Support BASIC/ASM/SID build routes; then run and verify via screen/audio.
-  - Archive artifacts in a run folder.
-
----
-
-### Phase 2 — Filesystem and drives
-
-- [ ] `drive_mount_and_verify` — Implementation notes:
-  - Power on if needed; mount; reset; verify via drives list. Retry with backoff.
-- [ ] `create_and_mount_blank_d64` — Implementation notes:
-  - Create blank D64; mount; optional BASIC header writer.
-- [ ] `container_aware_walk_and_classify` — Implementation notes:
-  - Recurse host and container entries; classify BASIC vs PRG-MC via load + read.
-- [ ] `classify_prg_basic_or_mc` — Implementation notes:
-  - For a single PRG; detect BASIC tokenization from header bytes.
-- [ ] `filesystem_stats_by_extension` — Implementation notes:
-  - Compute counts and sizes; rollups per extension and per-folder/container.
-- [ ] `dedup_scan` — Implementation notes:
-  - Group by size and extension; optional normalized names; optional hash when available.
-- [ ] `dedup_plan_and_apply` — Implementation notes:
-  - Produce reversible quarantine plan; default dry-run; require explicit confirm to apply.
-
-Optional in this phase:
-
-- [ ] `drive_mode_profile_switch`
-- [ ] `eject_and_poweroff_drive`
-
----
-
-### Phase 3 — Graphics and screen pipelines
-
-- [ ] `extract_sprites_from_ram` — Implementation notes:
-  - Search with stride for 63-byte sprite patterns; export `.spr`/hex/base64.
-- [ ] `rip_charset_from_ram` — Implementation notes:
-  - Locate 2KB charsets by structure; export binary and a PNG preview.
-- [ ] `screen_capture_timeline` — Implementation notes:
-  - Timed captures; export timestamped log and optional GIF.
-- [ ] `sprite_preview_prg_batch` — Implementation notes:
-  - Generate+run preview PRGs for many sprite blobs; capture screens.
-
----
-
-### Phase 4 — SID and audio
-
-- [ ] `silence_and_verify` — Implementation notes:
-  - Write SID reset/silence; record short audio; verify threshold.
-- [ ] `music_compile_play_analyze` — Implementation notes:
-  - Compile SIDWAVE→PRG or SID; play; record; analyze; save JSON.
-- [ ] `sid_param_sweep` — Implementation notes:
-  - Sweep ADSR/waveform/pulse width; schedule notes; analyze; score.
-
----
-
-### Phase 5 — Debug stream workflows (post‑GA)
-
-- Prerequisites (must be satisfied before starting this phase):
-  - UDP ingest pipeline with backpressure and packet‑loss handling.
-  - Sampling/windowing design for high‑rate streams and summary accuracy.
-  - Performance targets validated via load and soak tests.
-  - Observability and failure‑mode coverage (metrics, logs, alerts, drop counters).
-- [ ] `debug_stream_watch` — Implementation notes:
-  - Start/stop; summarize rates; enforce mutual exclusion with video stream.
-- [ ] `debug_loop_run_and_capture` — Implementation notes:
-  - Pause → start debug → resume → action → pause → stop → summarize packets.
-  - Support modes: 6510, VIC, 1541; choose minimal scope by default.
-- [ ] `verify_raster_irq_line` — Implementation notes:
-  - Correlate writes to $D012/$D011 and IRQ ack; configurable tolerance.
-- [ ] `debug_trace_until_cpu_write` — Implementation notes:
-  - Watch address set; freeze a pre/post window when first write observed.
-- [ ] `action_latency_measure` — Implementation notes:
-  - Timestamp action issue and first matching event; compute cycles/µs.
-
-Optional follow-ons in this phase (implement after above pass):
-
-- [ ] `verify_irq_jitter`
-- [ ] `sid_register_write_profile`
-- [ ] `iec_bus_handshake_probe`
-- [ ] `time_bounded_trace_around_event`
-
----
-
-### Phase 6 — Developer and recovery loops
-
-- [ ] `red_green_refactor_loop` — Implementation notes:
-  - Iterate: run → capture screen → write_memory fixes → rerun until pass.
-- [ ] `multi_range_guardrails` — Implementation notes:
-  - Continuously verify invariants; auto-restore from snapshot on violations.
-- [ ] `safe_reset_sequence` — Implementation notes:
-  - Snapshot select ranges; reset; compare persistence; resume.
-- [ ] `drive_recovery_sequence` — Implementation notes:
-  - Detect error; reset; power cycle; remount last image; verify.
-
----
-
-### RAG-coupled meta tools
-
-- [ ] `ask_and_apply_memory_fix` — Implementation notes:
-  - Retrieve assembly guidance (RAG), compute targeted writes, then `verify_and_write_memory`.
-- [ ] `sprite_program_from_prompt` — Implementation notes:
-  - Generate PETSCII/sprite asset from text; preview PRG; capture screen.
-
----
-
-### Optional follow-ups and experiments
-
-- [ ] `memory_heatmap_over_time`
-- [ ] `irq_latency_probe`
-- [ ] `sid_voice_stuck_guard`
-- [ ] `auto_benchmark_suite`
-- [ ] `firmware_compat_matrix`
-- [ ] `ultimate_config_migrate`
-
----
-
-### Per-task Done Definition (LLM must verify before ticking)
-
-- Implementation compiles with no TypeScript errors (where applicable).
-- New/updated tests exist and are passing locally.
-- `npm run check` passes end-to-end.
-- Documentation updated if tool behavior changed.
-
-### How to tick off checkboxes (LLM instructions)
-
-- After completing a checklist item and confirming the Done Definition, update the corresponding `- [ ]` line to `- [x]` in `doc/meta-tools-rollout.md`.
-- Only tick one line at a time, from top to bottom, respecting phases and dependencies.
-- After ticking, immediately run `npm run check` again to ensure that the documentation update did not break formatting-sensitive scripts.
-
-### Notes on sequencing
-
-- Respect the dependency graph from `doc/meta-tools.md` (Effort/Benefit/Dependencies Matrix).
-- Within a phase, process items in order. If an item depends on another not yet done, jump to the dependency’s phase, complete it, then resume.

package/scripts/register-ts-node.mjs

@@ -1,6 +0,0 @@
-import { register } from "node:module";
-
-// Register ts-node ESM loader using the recommended `register` API to avoid
-// the experimental loader warning shown during CI runs.
-const projectRootUrl = new URL("../", import.meta.url);
-register("ts-node/esm", projectRootUrl);