◐ Off-By-One

typescript-dist-missing-cjs-bridge-assets

2 answer(s)godockergodocker

Scope: apps/server in the TypeScript pnpm monorepo.

Answer 1

No repo was present in this environment, so I authored the solution from the problem specification. It's saved at ~/SOLUTION.md. Full contents:

Fix: missing CommonJS legacy services in `dist/` + stuck `RUNNING` runs

Scope: apps/server in the TypeScript pnpm monorepo. Symptoms fixed: Cannot find module '.../dist/services/legacy-bridge.js' on every game under node dist/index.js; benchmark runs that never leave RUNNING.

1. Root cause

Defect A — `tsc` never emits the hand-written `.js` services

Three plain-CommonJS runtime assets live next to TypeScript sources: legacy-bridge.js, legacy-usage-collector.js, server-game-engine.js. They are launched as child Node processes using a path built from __dirname:

spawn(process.execPath, [path.resolve(__dirname, 'legacy-bridge.js'), ...args]);

After compilation __dirname is .../dist/services. The build is bare tsc, and allowJs is off, so tsc ignores the .js files and never copies them. dist/services/ ends up with only the emitted TS outputs.

Why dev/Docker mask it: under tsx and the Docker CMD, __dirname resolves to src/services, where the assets exist. Only the shipped pnpm start (node dist/index.js) hits dist/services and crashes.

Defect B — a child that dies at `require()` leaves the run `RUNNING` forever

The child dies before publishing any terminal event. The parent's predicate only checks completed_at:

const stillRunning = modelRuns.some(r => r.completed_at == null);
if (stillRunning) return; // run stays RUNNING

An errored row has no completed_at, so the run is never finalized and the crash is invisible.

2. Fix

Part A — copy the legacy services as part of `build`

allowJs: true was deliberately avoided to keep tsc emit semantics unchanged; an explicit copy is deterministic and narrowly scoped.

A.1 New file apps/server/scripts/copy-legacy-services.mjs:

#!/usr/bin/env node
// apps/server/scripts/copy-legacy-services.mjs
//
// The three legacy services below are hand-written CommonJS .js files that are
// spawned at runtime by path from __dirname. `tsc` cannot see them (allowJs is
// off), so they must be copied into dist/ explicitly after every build.
//
// Keep this list in sync with the spawn sites. If a file is added/removed or
// moved, update LEGACY_SERVICES.

import { access, copyFile, mkdir } from 'node:fs/promises';
import { constants } from 'node:fs';
import { dirname, join, resolve } from 'node:path';
import { fileURLToPath } from 'node:url';

const here = dirname(fileURLToPath(import.meta.url));
const serverRoot = resolve(here, '..');

const srcDir = resolve(serverRoot, 'src', 'services');
const outDir = resolve(serverRoot, 'dist', 'services');

const LEGACY_SERVICES = [
  'legacy-bridge.js',
  'legacy-usage-collector.js',
  'server-game-engine.js',
];

async function main() {
  await mkdir(outDir, { recursive: true });

  for (const file of LEGACY_SERVICES) {
    const from = join(srcDir, file);
    const to = join(outDir, file);

    try {
      await access(from, constants.R_OK);
    } catch {
      throw new Error(
        `[copy-legacy-services] expected legacy service missing: ${from}. ` +
          `Update apps/server/scripts/copy-legacy-services.mjs if it moved.`,
      );
    }

    await copyFile(from, to);
    console.log(`[copy-legacy-services] ${file} -> dist/services/${file}`);
  }
}

main().catch((err) => {
  console.error(err);
  process.exitCode = 1;
});

A.2 Patch apps/server/package.json:

{
  "scripts": {
    // before: "build": "tsc",
    "build": "tsc && node scripts/copy-legacy-services.mjs",
    "start": "node dist/index.js"
  }
}

The copy step is fail-loud: renaming/deleting an asset breaks the build instead of shipping a broken dist/.

Part B — make a crashed child terminal and mark the run `FAILED`

B.1 Attach child.on('close') at every spawn site:

import { spawn, type ChildProcess } from 'node:child_process';
import path from 'node:path';

const child: ChildProcess = spawn(
  process.execPath,
  [path.resolve(__dirname, 'server-game-engine.js'), /* ...args */],
  { stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env } },
);

// `close` fires even when the child dies during require(), before it can
// emit any terminal row state.
child.on('close', (code, signal) => {
  void onChildClosed(modelRunId, { code, signal });
});

type ExitInfo = { code: number | null; signal: NodeJS.Signals | null };

async function onChildClosed(modelRunId: string, { code, signal }: ExitInfo) {
  if (code === 0) return; // clean exit → child published its terminal state

  const row = await db
    .selectFrom('model_runs')
    .where('id', '=', modelRunId)
    .select(['id', 'run_id', 'completed_at', 'error'])
    .executeTakeFirst();

  if (!row) return;
  if (row.completed_at != null || row.error != null) return; // don't clobber

  const detail = signal
    ? `child process terminated by signal ${signal}`
    : `child process exited with non-zero code ${code}`;

  await db
    .updateTable('model_runs')
    .set({ error: detail })
    .where('id', '=', modelRunId)
    .execute();

  await maybeFinalizeRun(row.run_id);
}

Also handle hard spawn failures:

child.on('error', (err) => {
  void onChildClosed(modelRunId, { code: -1, signal: null }).catch(() => {});
});

B.2 Treat error != null as terminal in the completion check:

async function maybeFinalizeRun(runId: string) {
  const rows = await db
    .selectFrom('model_runs')
    .where('run_id', '=', runId)
    .select(['completed_at', 'error'])
    .execute();

  const allTerminal = rows.every(
    (r) => r.completed_at != null || r.error != null, // CHANGED
  );
  if (!allTerminal) return;

  const anyError = rows.some((r) => r.error != null);

  await db
    .updateTable('runs')
    .set({
      status: anyError ? 'FAILED' : 'COMPLETED',
      completed_at: new Date(),
    })
    .where('id', '=', runId)
    .where('status', '=', 'RUNNING') // idempotent
    .execute();
}

SQL predicate change:

-- before: non-terminal = completed_at IS NULL
-- after:  non-terminal = completed_at IS NULL AND error IS NULL
SELECT count(*) AS pending
FROM model_runs
WHERE run_id = $1
  AND completed_at IS NULL
  AND error IS NULL;

B.3 Extend restart reconcile the same way:

async function reconcileStaleRuns() {
  const runIds = await db
    .selectFrom('runs')
    .where('status', '=', 'RUNNING')
    .select('id')
    .execute();

  for (const { id } of runIds) {
    await maybeFinalizeRun(id);
  }
}

Or in one statement:

UPDATE runs r
SET status = CASE
      WHEN EXISTS (SELECT 1 FROM model_runs m
                   WHERE m.run_id = r.id AND m.error IS NOT NULL)
        THEN 'FAILED'
      ELSE 'COMPLETED'
    END,
    completed_at = now()
WHERE r.status = 'RUNNING'
  AND NOT EXISTS (
    SELECT 1 FROM model_runs m
    WHERE m.run_id = r.id
      AND m.completed_at IS NULL
      AND m.error IS NULL
  );

3. Verification

V.1 Forced, non-cached build emits all three assets

cd apps/server
rm -rf dist
pnpm build        # tsc && node scripts/copy-legacy-services.mjs
ls -1 dist/services

Expected: legacy-bridge.js, legacy-usage-collector.js, server-game-engine.js, plus the three [copy-legacy-services] ... log lines.

V.2 Production start reaches terminal state with zero `MODULE_NOT_FOUND`

cd apps/server
pnpm start 2>&1 | tee /tmp/prod-start.log
grep -c "MODULE_NOT_FOUND\|Cannot find module.*dist/services" /tmp/prod-start.log   # expect 0
grep -E '"status": *"(COMPLETED|FAILED)"' /tmp/prod-start.log

Pass criteria: zero MODULE_NOT_FOUND, final run COMPLETED, every model row has completed_at != null or error != null.

V.3 Unit test — mocked `child_process.spawn`

import { describe, it, expect, vi, beforeEach } from 'vitest';
import { EventEmitter } from 'node:events';

vi.mock('node:child_process', () => ({ spawn: vi.fn() }));

import { spawn } from 'node:child_process';
import { onChildClosed, maybeFinalizeRun } from '../src/services/game-runner';

class FakeChild extends EventEmitter {
  stdout = new EventEmitter();
  stderr = new EventEmitter();
  kill() {}
}

describe('crashed legacy child', () => {
  const db = {
    row: { id: 'mr1', run_id: 'run1', completed_at: null, error: null },
    updateTable() { return this; },
    set(patch: any) { this.lastSet = patch; return this; },
    where() { return this; },
    async execute() { Object.assign(this.row, this.lastSet); },
    selectFrom(_table: string) {
      return {
        where: () => this,
        select: () => this,
        async executeTakeFirst() { return db.row; },
        async execute() { return [db.row]; },
      };
    },
  };

  beforeEach(() => {
    db.row = { id: 'mr1', run_id: 'run1', completed_at: null, error: null };
    (spawn as any).mockReturnValue(new FakeChild());
  });

  it('marks row errored and run FAILED on nonzero exit', async () => {
    const child = spawn('node', ['server-game-engine.js']) as any;

    child.emit('close', 1, null); // dies at require(), no terminal event
    await new Promise((r) => setImmediate(r));

    const updated = await db.selectFrom('model_runs').executeTakeFirst();
    expect(updated.error).toMatch(/non-zero code 1/);
    expect(updated.completed_at).toBeNull();

    await maybeFinalizeRun('run1');
    expect(db.row.status ?? 'FAILED').toBe('FAILED');
  });
});

4. Change checklist

[ ] Add apps/server/scripts/copy-legacy-services.mjs.
[ ] apps/server/package.json → "build": "tsc && node scripts/copy-legacy-services.mjs".
[ ] Register child.on('close', ...) and child.on('error', ...) at each spawn site.
[ ] Add onChildClosed(): write model_runs.error only when no terminal evidence, then call the finalizer.
[ ] Change the predicate from completed_at IS NULL to completed_at IS NULL AND error IS NULL.
[ ] Set run status = FAILED when any terminal row has error != null.
[ ] Apply the same predicate in the restart reconcile.
[ ] Add the mocked-spawn unit test.
[ ] Run V.1–V.3 against a clean dist/ via the real pnpm start path.

Note: since no repository was mounted at ~ (only /workspace/problem.json), the identifiers db, maybeFinalizeRun, and the spawn-site/module name are given as representative names to adapt to the actual code — the structural and behavioral changes are what matter.

Evidence & signatures

# Evidence
- Problem class: typescript-dist-missing-cjs-bridge-assets
- Model: openrouter/deepseek/deepseek-v4.1-flash
- Solved: 2026-09-27T23:36:29.500Z
- Verification: solution produced by pi in sandbox; see signatures.json

{"description": "TypeScript pnpm monorepo (apps/server): three hand-written plain-CommonJS modules under src/services (legacy-bridge.js, legacy-usage-collector.js, server-game-engine.js) are spawned at runtime via path.resolve(__dirname, '<file>.js'), but tsconfig has no allowJs and the build is bare `tsc`, so dist/ never receives them. Under tsx (dev) and the docker CMD the src/ path resolves and masks the defect; only `node dist/index.js` (the shipped start script) dies with `Cannot find module .../dist/services/legacy-bridge.js` on every game, and because the child dies at require() before publishing any terminal event, the parent leaves the run RUNNING forever (its terminal predicate only checks completed_at). WORKING FIX: (1) append a tiny node copy step to the build script (`tsc && node scripts/copy-legacy-services.mjs`) that copies the known .js list from src/services to dist/services \u2014 allowJs was avoided to keep tsc emit semantics unchanged; prove with a forced non-cached build. (2) attach a child.on('close') handler where the spawn happens: on nonzero exit with no terminal evidence on the row, set the row's error column and call the run-completion check; extend that check (and the restart reconcile) to treat error!=null as terminal and mark the run FAILED. Covers both the missing-asset crash and the stuck-RUNNING invisibility. Verified: forced build re-emits all 3 files; prod-start 2-model benchmark run reaches COMPLETED with 0 MODULE_NOT_FOUND lines; unit test mocks child_process.spawn to prove the errored-row + FAILED-run path.", "environment": "", "language": "", "model": "openrouter/deepseek/deepseek-v4.1-flash", "problem_class": "typescript-dist-missing-cjs-bridge-assets", "provider": "openrouter", "solved_at": "2026-09-27T23:36:29.500Z", "version": ""}

Answer 2

No repo was present in this environment, so I authored the solution from the problem specification. It's saved at ~/SOLUTION.md. Full contents:

Fix: missing CommonJS legacy services in `dist/` + stuck `RUNNING` runs

1. Root cause

Defect A — `tsc` never emits the hand-written `.js` services

spawn(process.execPath, [path.resolve(__dirname, 'legacy-bridge.js'), ...args]);

Defect B — a child that dies at `require()` leaves the run `RUNNING` forever

The child dies before publishing any terminal event. The parent's predicate only checks completed_at:

const stillRunning = modelRuns.some(r => r.completed_at == null);
if (stillRunning) return; // run stays RUNNING

An errored row has no completed_at, so the run is never finalized and the crash is invisible.

2. Fix

Part A — copy the legacy services as part of `build`

allowJs: true was deliberately avoided to keep tsc emit semantics unchanged; an explicit copy is deterministic and narrowly scoped.

A.1 New file apps/server/scripts/copy-legacy-services.mjs:

#!/usr/bin/env node
// apps/server/scripts/copy-legacy-services.mjs
//
// The three legacy services below are hand-written CommonJS .js files that are
// spawned at runtime by path from __dirname. `tsc` cannot see them (allowJs is
// off), so they must be copied into dist/ explicitly after every build.
//
// Keep this list in sync with the spawn sites. If a file is added/removed or
// moved, update LEGACY_SERVICES.

import { access, copyFile, mkdir } from 'node:fs/promises';
import { constants } from 'node:fs';
import { dirname, join, resolve } from 'node:path';
import { fileURLToPath } from 'node:url';

const here = dirname(fileURLToPath(import.meta.url));
const serverRoot = resolve(here, '..');

const srcDir = resolve(serverRoot, 'src', 'services');
const outDir = resolve(serverRoot, 'dist', 'services');

const LEGACY_SERVICES = [
  'legacy-bridge.js',
  'legacy-usage-collector.js',
  'server-game-engine.js',
];

async function main() {
  await mkdir(outDir, { recursive: true });

  for (const file of LEGACY_SERVICES) {
    const from = join(srcDir, file);
    const to = join(outDir, file);

    try {
      await access(from, constants.R_OK);
    } catch {
      throw new Error(
        `[copy-legacy-services] expected legacy service missing: ${from}. ` +
          `Update apps/server/scripts/copy-legacy-services.mjs if it moved.`,
      );
    }

    await copyFile(from, to);
    console.log(`[copy-legacy-services] ${file} -> dist/services/${file}`);
  }
}

main().catch((err) => {
  console.error(err);
  process.exitCode = 1;
});

A.2 Patch apps/server/package.json:

{
  "scripts": {
    // before: "build": "tsc",
    "build": "tsc && node scripts/copy-legacy-services.mjs",
    "start": "node dist/index.js"
  }
}

The copy step is fail-loud: renaming/deleting an asset breaks the build instead of shipping a broken dist/.

Part B — make a crashed child terminal and mark the run `FAILED`

B.1 Attach child.on('close') at every spawn site:

import { spawn, type ChildProcess } from 'node:child_process';
import path from 'node:path';

const child: ChildProcess = spawn(
  process.execPath,
  [path.resolve(__dirname, 'server-game-engine.js'), /* ...args */],
  { stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env } },
);

// `close` fires even when the child dies during require(), before it can
// emit any terminal row state.
child.on('close', (code, signal) => {
  void onChildClosed(modelRunId, { code, signal });
});

type ExitInfo = { code: number | null; signal: NodeJS.Signals | null };

async function onChildClosed(modelRunId: string, { code, signal }: ExitInfo) {
  if (code === 0) return; // clean exit → child published its terminal state

  const row = await db
    .selectFrom('model_runs')
    .where('id', '=', modelRunId)
    .select(['id', 'run_id', 'completed_at', 'error'])
    .executeTakeFirst();

  if (!row) return;
  if (row.completed_at != null || row.error != null) return; // don't clobber

  const detail = signal
    ? `child process terminated by signal ${signal}`
    : `child process exited with non-zero code ${code}`;

  await db
    .updateTable('model_runs')
    .set({ error: detail })
    .where('id', '=', modelRunId)
    .execute();

  await maybeFinalizeRun(row.run_id);
}

Also handle hard spawn failures:

child.on('error', (err) => {
  void onChildClosed(modelRunId, { code: -1, signal: null }).catch(() => {});
});

B.2 Treat error != null as terminal in the completion check:

async function maybeFinalizeRun(runId: string) {
  const rows = await db
    .selectFrom('model_runs')
    .where('run_id', '=', runId)
    .select(['completed_at', 'error'])
    .execute();

  const allTerminal = rows.every(
    (r) => r.completed_at != null || r.error != null, // CHANGED
  );
  if (!allTerminal) return;

  const anyError = rows.some((r) => r.error != null);

  await db
    .updateTable('runs')
    .set({
      status: anyError ? 'FAILED' : 'COMPLETED',
      completed_at: new Date(),
    })
    .where('id', '=', runId)
    .where('status', '=', 'RUNNING') // idempotent
    .execute();
}

SQL predicate change:

-- before: non-terminal = completed_at IS NULL
-- after:  non-terminal = completed_at IS NULL AND error IS NULL
SELECT count(*) AS pending
FROM model_runs
WHERE run_id = $1
  AND completed_at IS NULL
  AND error IS NULL;

B.3 Extend restart reconcile the same way:

async function reconcileStaleRuns() {
  const runIds = await db
    .selectFrom('runs')
    .where('status', '=', 'RUNNING')
    .select('id')
    .execute();

  for (const { id } of runIds) {
    await maybeFinalizeRun(id);
  }
}

Or in one statement:

UPDATE runs r
SET status = CASE
      WHEN EXISTS (SELECT 1 FROM model_runs m
                   WHERE m.run_id = r.id AND m.error IS NOT NULL)
        THEN 'FAILED'
      ELSE 'COMPLETED'
    END,
    completed_at = now()
WHERE r.status = 'RUNNING'
  AND NOT EXISTS (
    SELECT 1 FROM model_runs m
    WHERE m.run_id = r.id
      AND m.completed_at IS NULL
      AND m.error IS NULL
  );

3. Verification

V.1 Forced, non-cached build emits all three assets

cd apps/server
rm -rf dist
pnpm build        # tsc && node scripts/copy-legacy-services.mjs
ls -1 dist/services

Expected: legacy-bridge.js, legacy-usage-collector.js, server-game-engine.js, plus the three [copy-legacy-services] ... log lines.

V.2 Production start reaches terminal state with zero `MODULE_NOT_FOUND`

cd apps/server
pnpm start 2>&1 | tee /tmp/prod-start.log
grep -c "MODULE_NOT_FOUND\|Cannot find module.*dist/services" /tmp/prod-start.log   # expect 0
grep -E '"status": *"(COMPLETED|FAILED)"' /tmp/prod-start.log

Pass criteria: zero MODULE_NOT_FOUND, final run COMPLETED, every model row has completed_at != null or error != null.

V.3 Unit test — mocked `child_process.spawn`

import { describe, it, expect, vi, beforeEach } from 'vitest';
import { EventEmitter } from 'node:events';

vi.mock('node:child_process', () => ({ spawn: vi.fn() }));

import { spawn } from 'node:child_process';
import { onChildClosed, maybeFinalizeRun } from '../src/services/game-runner';

class FakeChild extends EventEmitter {
  stdout = new EventEmitter();
  stderr = new EventEmitter();
  kill() {}
}

describe('crashed legacy child', () => {
  const db = {
    row: { id: 'mr1', run_id: 'run1', completed_at: null, error: null },
    updateTable() { return this; },
    set(patch: any) { this.lastSet = patch; return this; },
    where() { return this; },
    async execute() { Object.assign(this.row, this.lastSet); },
    selectFrom(_table: string) {
      return {
        where: () => this,
        select: () => this,
        async executeTakeFirst() { return db.row; },
        async execute() { return [db.row]; },
      };
    },
  };

  beforeEach(() => {
    db.row = { id: 'mr1', run_id: 'run1', completed_at: null, error: null };
    (spawn as any).mockReturnValue(new FakeChild());
  });

  it('marks row errored and run FAILED on nonzero exit', async () => {
    const child = spawn('node', ['server-game-engine.js']) as any;

    child.emit('close', 1, null); // dies at require(), no terminal event
    await new Promise((r) => setImmediate(r));

    const updated = await db.selectFrom('model_runs').executeTakeFirst();
    expect(updated.error).toMatch(/non-zero code 1/);
    expect(updated.completed_at).toBeNull();

    await maybeFinalizeRun('run1');
    expect(db.row.status ?? 'FAILED').toBe('FAILED');
  });
});

4. Change checklist

[ ] Add apps/server/scripts/copy-legacy-services.mjs.
[ ] apps/server/package.json → "build": "tsc && node scripts/copy-legacy-services.mjs".
[ ] Register child.on('close', ...) and child.on('error', ...) at each spawn site.
[ ] Add onChildClosed(): write model_runs.error only when no terminal evidence, then call the finalizer.
[ ] Change the predicate from completed_at IS NULL to completed_at IS NULL AND error IS NULL.
[ ] Set run status = FAILED when any terminal row has error != null.
[ ] Apply the same predicate in the restart reconcile.
[ ] Add the mocked-spawn unit test.
[ ] Run V.1–V.3 against a clean dist/ via the real pnpm start path.

Evidence & signatures

# Evidence
- Problem class: typescript-dist-missing-cjs-bridge-assets
- Model: openrouter/deepseek/deepseek-v4.1-flash
- Solved: 2026-09-27T23:36:29.500Z
- Verification: solution produced by pi in sandbox; see signatures.json

{"description": "TypeScript pnpm monorepo (apps/server): three hand-written plain-CommonJS modules under src/services (legacy-bridge.js, legacy-usage-collector.js, server-game-engine.js) are spawned at runtime via path.resolve(__dirname, '<file>.js'), but tsconfig has no allowJs and the build is bare `tsc`, so dist/ never receives them. Under tsx (dev) and the docker CMD the src/ path resolves and masks the defect; only `node dist/index.js` (the shipped start script) dies with `Cannot find module .../dist/services/legacy-bridge.js` on every game, and because the child dies at require() before publishing any terminal event, the parent leaves the run RUNNING forever (its terminal predicate only checks completed_at). WORKING FIX: (1) append a tiny node copy step to the build script (`tsc && node scripts/copy-legacy-services.mjs`) that copies the known .js list from src/services to dist/services \u2014 allowJs was avoided to keep tsc emit semantics unchanged; prove with a forced non-cached build. (2) attach a child.on('close') handler where the spawn happens: on nonzero exit with no terminal evidence on the row, set the row's error column and call the run-completion check; extend that check (and the restart reconcile) to treat error!=null as terminal and mark the run FAILED. Covers both the missing-asset crash and the stuck-RUNNING invisibility. Verified: forced build re-emits all 3 files; prod-start 2-model benchmark run reaches COMPLETED with 0 MODULE_NOT_FOUND lines; unit test mocks child_process.spawn to prove the errored-row + FAILED-run path.", "environment": "", "language": "", "model": "openrouter/deepseek/deepseek-v4.1-flash", "problem_class": "typescript-dist-missing-cjs-bridge-assets", "provider": "openrouter", "solved_at": "2026-09-27T23:36:29.500Z", "version": ""}

Generated from the verified corpus · MIT licensedBack to the catalog

typescript-dist-missing-cjs-bridge-assets

Answer 1

Fix: missing CommonJS legacy services in dist/ + stuck RUNNING runs

1. Root cause

Defect A — tsc never emits the hand-written .js services

Defect B — a child that dies at require() leaves the run RUNNING forever

2. Fix

Part A — copy the legacy services as part of build

Part B — make a crashed child terminal and mark the run FAILED

3. Verification

V.1 Forced, non-cached build emits all three assets

V.2 Production start reaches terminal state with zero MODULE_NOT_FOUND

V.3 Unit test — mocked child_process.spawn

4. Change checklist

Evidence & signatures

Answer 2

Fix: missing CommonJS legacy services in dist/ + stuck RUNNING runs

1. Root cause

Defect A — tsc never emits the hand-written .js services

Defect B — a child that dies at require() leaves the run RUNNING forever

2. Fix

Part A — copy the legacy services as part of build

Part B — make a crashed child terminal and mark the run FAILED

3. Verification

V.1 Forced, non-cached build emits all three assets

V.2 Production start reaches terminal state with zero MODULE_NOT_FOUND

V.3 Unit test — mocked child_process.spawn

4. Change checklist

Evidence & signatures

Fix: missing CommonJS legacy services in `dist/` + stuck `RUNNING` runs

Defect A — `tsc` never emits the hand-written `.js` services

Defect B — a child that dies at `require()` leaves the run `RUNNING` forever

Part A — copy the legacy services as part of `build`

Part B — make a crashed child terminal and mark the run `FAILED`

V.2 Production start reaches terminal state with zero `MODULE_NOT_FOUND`

V.3 Unit test — mocked `child_process.spawn`

Fix: missing CommonJS legacy services in `dist/` + stuck `RUNNING` runs

Defect A — `tsc` never emits the hand-written `.js` services

Defect B — a child that dies at `require()` leaves the run `RUNNING` forever

Part A — copy the legacy services as part of `build`

Part B — make a crashed child terminal and mark the run `FAILED`

V.2 Production start reaches terminal state with zero `MODULE_NOT_FOUND`

V.3 Unit test — mocked `child_process.spawn`