Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

Tie warm cache dev server to setup owner (#7563)

Nick Gomez956a5ea7f08d
diff --git a/knip.config.ts b/knip.config.ts
index e04bf5228..fac2580fe 100644
--- a/knip.config.ts
+++ b/knip.config.ts
@@ -157,11 +157,15 @@ export default {
'src/shadow-fixture-launch.test-helper.mjs',
],
project: 'src/**',
- ignoreDependencies: ['@types/shell-quote'],
+ ignoreDependencies: [
+ '@types/shell-quote',
+ ],
},
'packages/cli': {
entry: ['src/**/*.test.ts', 'scripts/*.ts', 'tests/**/*.ts', 'src/parse-worker.ts'],
- ignoreDependencies: ['yjs'],
+ ignoreDependencies: [
+ 'yjs',
+ ],
},
'packages/desktop': {
entry: [
diff --git a/packages/app/tests/foundation/warm-cache-owner-loss.node.test.ts b/packages/app/tests/foundation/warm-cache-owner-loss.node.test.ts
new file mode 100644
index 000000000..ce50d9150
--- /dev/null
+++ b/packages/app/tests/foundation/warm-cache-owner-loss.node.test.ts
@@ -0,0 +1,327 @@
+import { spawn } from 'node:child_process';
+import {
+ appendFileSync,
+ existsSync,
+ mkdirSync,
+ mkdtempSync,
+ readFileSync,
+ rmSync,
+ watch,
+ writeFileSync,
+} from 'node:fs';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { expect, test } from 'vitest';
+
+const require_ = createRequire(import.meta.url);
+const APP_ROOT = fileURLToPath(new URL('../..', import.meta.url));
+const SOURCE = fileURLToPath(new URL('../stress/_helpers/global-warm-cache.ts', import.meta.url));
+const HOLDER = fileURLToPath(
+ new URL('../stress/_helpers/warm-cache-owner-loss-holder.mjs', import.meta.url),
+);
+const GUARD = fileURLToPath(
+ new URL('../stress/_helpers/warm-cache-owner-loss-guard.cjs', import.meta.url),
+);
+const TSX = require_.resolve('tsx');
+const TERMINAL_WINDOW_MS = 5_000;
+const TEST_BUDGET_MS = 28_000;
+
+type SpawnEvent = {
+ kind: 'spawn';
+ childPid: number | undefined;
+ file: string;
+ args: string[] | undefined;
+ detached: boolean;
+ chain: boolean;
+};
+type GuardEvent =
+ | { kind: 'loaded'; chain: boolean; argv: string[] }
+ | SpawnEvent
+ | {
+ kind: 'child-exit';
+ childPid: number | undefined;
+ code: number | null;
+ signal: NodeJS.Signals | null;
+ }
+ | { kind: 'owner-lost'; ownerPid: number }
+ | { kind: 'parent-changed'; expectedParent: number; currentParent: number; ownerLost: boolean }
+ | { kind: 'exit' | 'guard-cleanup' | 'parent-lost' | 'signal:SIGINT' | 'signal:SIGTERM' };
+type ProcessDetail = { pid: number; file?: string; args?: string[]; argv?: string[] };
+type TestEvent =
+ | {
+ kind: 'cleanup-incomplete';
+ remainingPids: number[];
+ remainingProcesses: ProcessDetail[];
+ holderPid: number | undefined;
+ message: string;
+ }
+ | { kind: 'test-finished' };
+type EventRecord = { event: GuardEvent | TestEvent; pid: number; ppid?: number; time: number };
+type EventKind = EventRecord['event']['kind'];
+
+const SELF_EXIT_KINDS: ReadonlySet<EventKind> = new Set<EventKind>([
+ 'exit',
+ 'parent-lost',
+ 'signal:SIGINT',
+ 'signal:SIGTERM',
+]);
+const CLEANUP_EXIT_KINDS: ReadonlySet<EventKind> = new Set<EventKind>([
+ ...SELF_EXIT_KINDS,
+ 'guard-cleanup',
+]);
+
+test('warm-cache chain terminates when its setup owner exits', async () => {
+ const testStart = Date.now();
+ const bodyDeadline = testStart + TEST_BUDGET_MS - TERMINAL_WINDOW_MS;
+ const cleanupDeadline = testStart + TEST_BUDGET_MS;
+ const runDir = mkdtempSync(join(tmpdir(), 'ok-warm-cache-owner-loss-'));
+ const runtimeTmp = join(runDir, 'tmp');
+ const eventsPath = join(runDir, 'events.jsonl');
+ const cleanupPath = join(runDir, 'cleanup');
+ mkdirSync(runtimeTmp);
+ const env = {
+ ...process.env,
+ NODE_OPTIONS: `--require=${GUARD}`,
+ OK_TEST_WARM_CACHE_OWNER_LOSS_CLEANUP: cleanupPath,
+ OK_TEST_WARM_CACHE_OWNER_LOSS_EVENTS: eventsPath,
+ OK_TEST_WARM_CACHE_OWNER_LOSS_SOURCE: SOURCE,
+ OK_TEST_VITE_SEED_DIR: join(runDir, 'seed'),
+ TMPDIR: runtimeTmp,
+ OTEL_SDK_DISABLED: 'true',
+ };
+ const holder = spawn(process.execPath, ['--conditions=@inkeep/source', '--import', TSX, HOLDER], {
+ cwd: APP_ROOT,
+ env,
+ stdio: ['ignore', 'pipe', 'pipe'],
+ });
+ let transcript = '';
+ holder.stdout?.on('data', (chunk: Buffer) => {
+ transcript += chunk.toString('utf8');
+ });
+ holder.stderr?.on('data', (chunk: Buffer) => {
+ transcript += chunk.toString('utf8');
+ });
+ const holderClosed = new Promise<[number | null, NodeJS.Signals | null]>((resolve) =>
+ holder.once('close', (...result) => resolve(result)),
+ );
+ const events = (): EventRecord[] =>
+ existsSync(eventsPath)
+ ? readFileSync(eventsPath, 'utf8')
+ .split('\n')
+ .filter(Boolean)
+ .map((line) => JSON.parse(line) as EventRecord)
+ : [];
+ const waitFor = async (
+ predicate: (records: EventRecord[]) => boolean,
+ deadline: number,
+ phase: string,
+ ): Promise<EventRecord[]> => {
+ let watcher: ReturnType<typeof watch> | undefined;
+ let timeout: ReturnType<typeof setTimeout> | undefined;
+ return new Promise<EventRecord[]>((resolve, reject) => {
+ const finish = (error?: Error) => {
+ watcher?.close();
+ if (timeout !== undefined) clearTimeout(timeout);
+ if (error === undefined) resolve(events());
+ else reject(error);
+ };
+ const check = () => {
+ const records = events();
+ if (predicate(records)) {
+ finish();
+ return;
+ }
+ if (Date.now() >= deadline) {
+ finish(
+ new Error(
+ `timed out waiting for warm-cache ${phase}: ${JSON.stringify({ records, transcript })}`,
+ ),
+ );
+ }
+ };
+ watcher = watch(runDir, check);
+ watcher.on('error', (error) => finish(error));
+ timeout = setTimeout(check, Math.max(0, deadline - Date.now()));
+ check();
+ });
+ };
+ const recordedPids = (records: EventRecord[]): number[] => {
+ const pids = new Set<number>();
+ const add = (pid: number | undefined) => {
+ if (pid !== undefined && Number.isInteger(pid) && pid > 1 && pid !== holder.pid) {
+ pids.add(pid);
+ }
+ };
+ for (const record of records) {
+ if (record.event.kind === 'loaded' && record.event.chain) {
+ add(record.pid);
+ add(record.ppid);
+ }
+ if (record.event.kind === 'spawn') add(record.event.childPid);
+ }
+ return [...pids];
+ };
+ const isLive = (pid: number): boolean => {
+ if (!Number.isInteger(pid) || pid <= 1) return false;
+ try {
+ process.kill(pid, 0);
+ return true;
+ } catch (error) {
+ if (error && typeof error === 'object' && 'code' in error && error.code === 'ESRCH') {
+ return false;
+ }
+ throw error;
+ }
+ };
+ const endedByOwnEvidence = (
+ records: EventRecord[],
+ pid: number,
+ exitKinds: ReadonlySet<EventKind>,
+ ): boolean =>
+ records.some(
+ ({ event, pid: recordPid }) =>
+ (recordPid === pid && exitKinds.has(event.kind)) ||
+ (event.kind === 'child-exit' && event.childPid === pid),
+ );
+ const chainEnded = (
+ records: EventRecord[],
+ pids: number[],
+ exitKinds: ReadonlySet<EventKind>,
+ ): boolean => pids.every((pid) => endedByOwnEvidence(records, pid, exitKinds) || !isLive(pid));
+ const findPnpmSpawn = (records: EventRecord[]): SpawnEvent | undefined => {
+ for (const { event } of records) {
+ if (event.kind === 'spawn' && event.file === 'pnpm') return event;
+ }
+ return undefined;
+ };
+ const findViteLoad = (records: EventRecord[]): EventRecord | undefined =>
+ records.find(
+ ({ event }) =>
+ event.kind === 'loaded' &&
+ event.chain &&
+ event.argv.some((argument) => /[/\\]vite[/\\]/.test(argument)),
+ );
+ const waitForHolderClosed = async (
+ deadline: number,
+ ): Promise<[number | null, NodeJS.Signals | null] | undefined> => {
+ const remaining = deadline - Date.now();
+ if (remaining <= 0) return undefined;
+ let timer: ReturnType<typeof setTimeout> | undefined;
+ const expired = new Promise<undefined>((resolve) => {
+ timer = setTimeout(() => resolve(undefined), remaining);
+ });
+ try {
+ return await Promise.race([holderClosed, expired]);
+ } finally {
+ clearTimeout(timer);
+ }
+ };
+ const recordedProcessDetails = (records: EventRecord[], pids: number[]): ProcessDetail[] => {
+ const wanted = new Set(pids);
+ return records.flatMap(({ event, pid }): ProcessDetail[] => {
+ if (event.kind === 'spawn' && event.childPid !== undefined && wanted.has(event.childPid)) {
+ return [{ pid: event.childPid, file: event.file, args: event.args }];
+ }
+ if (event.kind === 'loaded' && wanted.has(pid)) return [{ pid, argv: event.argv }];
+ return [];
+ });
+ };
+ let holderResult: [number | null, NodeJS.Signals | null] | undefined;
+ let holderCloseTimedOut = false;
+ let cleanupError: Error | undefined;
+ try {
+ const startRecords = await waitFor(
+ (records) => findPnpmSpawn(records) !== undefined && findViteLoad(records) !== undefined,
+ bodyDeadline,
+ 'Vite load',
+ );
+ const spawned = findPnpmSpawn(startRecords);
+ const viteLoad = findViteLoad(startRecords);
+ if (
+ spawned?.childPid === undefined ||
+ !Number.isInteger(spawned.childPid) ||
+ spawned.childPid <= 1 ||
+ viteLoad === undefined
+ ) {
+ throw new Error(`warm-cache pnpm spawn was not witnessed: ${JSON.stringify(startRecords)}`);
+ }
+ expect(isLive(viteLoad.pid), JSON.stringify({ transcript, records: startRecords })).toBe(true);
+ if (!holder.kill('SIGKILL')) throw new Error('warm-cache owner holder did not accept SIGKILL');
+ holderResult = await waitForHolderClosed(bodyDeadline);
+ if (holderResult === undefined)
+ throw new Error('warm-cache owner holder did not close in time');
+ const ownerLossRecords = await waitFor(
+ (records) => records.some(({ event }) => event.kind === 'owner-lost'),
+ bodyDeadline,
+ 'owner loss',
+ );
+ let pids = recordedPids(ownerLossRecords);
+ const deadline = Math.min(bodyDeadline, Date.now() + TERMINAL_WINDOW_MS);
+ let terminalRecords = ownerLossRecords;
+ while (!chainEnded(terminalRecords, pids, SELF_EXIT_KINDS) && Date.now() < deadline) {
+ await new Promise((resolve) => setTimeout(resolve, 25));
+ terminalRecords = events();
+ pids = recordedPids(terminalRecords);
+ }
+ const diagnostics = JSON.stringify({ transcript, spawned, pids, records: terminalRecords });
+ expect(holderResult, diagnostics).toEqual([null, 'SIGKILL']);
+ expect(spawned.detached, diagnostics).toBe(true);
+ expect(pids, diagnostics).toContain(viteLoad.pid);
+ expect(chainEnded(terminalRecords, pids, SELF_EXIT_KINDS), diagnostics).toBe(true);
+ } finally {
+ writeFileSync(cleanupPath, 'cleanup\n', 'utf8');
+ if (holder.exitCode === null && holder.signalCode === null) holder.kill('SIGKILL');
+ if (holderResult === undefined) {
+ holderResult = await waitForHolderClosed(cleanupDeadline);
+ holderCloseTimedOut = holderResult === undefined;
+ }
+ try {
+ await waitFor(
+ (records) => chainEnded(records, recordedPids(records), CLEANUP_EXIT_KINDS),
+ cleanupDeadline,
+ 'cleanup',
+ );
+ } catch (error) {
+ cleanupError = error instanceof Error ? error : new Error(String(error));
+ }
+ if (holderCloseTimedOut && cleanupError === undefined) {
+ cleanupError = new Error('warm-cache owner holder did not close during cleanup');
+ }
+ if (cleanupError !== undefined) {
+ const records = events();
+ const remainingPids = recordedPids(records).filter((pid) => isLive(pid));
+ const remainingProcesses = recordedProcessDetails(records, remainingPids);
+ const incomplete: EventRecord = {
+ event: {
+ kind: 'cleanup-incomplete',
+ remainingPids,
+ remainingProcesses,
+ holderPid: holder.pid,
+ message: cleanupError.message,
+ },
+ pid: process.pid,
+ time: Date.now(),
+ };
+ appendFileSync(eventsPath, `${JSON.stringify(incomplete)}\n`);
+ console.error(
+ `[warm-cache owner-loss] cleanup incomplete: ${JSON.stringify({
+ runDir,
+ remainingPids,
+ remainingProcesses,
+ holderPid: holder.pid,
+ message: cleanupError.message,
+ })}`,
+ );
+ }
+ const finished: EventRecord = {
+ event: { kind: 'test-finished' },
+ pid: process.pid,
+ time: Date.now(),
+ };
+ appendFileSync(eventsPath, `${JSON.stringify(finished)}\n`);
+ if (cleanupError === undefined) rmSync(runDir, { recursive: true, force: true });
+ }
+ if (cleanupError !== undefined) throw cleanupError;
+});
diff --git a/packages/app/tests/foundation/warm-cache-owner-loss.reads.ts b/packages/app/tests/foundation/warm-cache-owner-loss.reads.ts
new file mode 100644
index 000000000..e9d233ede
--- /dev/null
+++ b/packages/app/tests/foundation/warm-cache-owner-loss.reads.ts
@@ -0,0 +1,21 @@
+export const ROUND_READS = {
+ test: './warm-cache-owner-loss.node.test.ts',
+ reads:
+ "the warm-cache spawn, its owner guard, the holder and the observation preload the test starts in child processes, with everything they import, then what those processes read at run time: the core source the holder loads through @inkeep/open-knowledge-core, the seed-key inputs (the lockfile and the app's Vite config files and package.json), the app and root tsconfig.json, the root package.json the pnpm launcher reads, the app's predev script, the read observer each Node child preloads, and what the warm Vite build reads before owner loss ends it, which a later owner loss widens to a full start's app, core and server packages, project config and root package.json",
+ roots: [
+ 'packages/app/tests/stress/_helpers/global-warm-cache.ts',
+ 'packages/app/tests/stress/_helpers/warm-cache-owner-guard.cjs',
+ 'packages/app/tests/stress/_helpers/warm-cache-owner-loss-holder.mjs',
+ 'packages/app/tests/stress/_helpers/warm-cache-owner-loss-guard.cjs',
+ ],
+ include: [
+ 'packages/app/**',
+ 'packages/core/**',
+ 'packages/server/**',
+ 'test-support/read-declarations-observer.ts',
+ 'pnpm-lock.yaml',
+ '.ok/config.yml',
+ 'package.json',
+ 'tsconfig.json',
+ ],
+};
diff --git a/packages/app/tests/integration/bug3-source-mode-writeback.test.ts b/packages/app/tests/integration/bug3-source-mode-writeback.test.ts
index a50b00123..4549c74b3 100644
--- a/packages/app/tests/integration/bug3-source-mode-writeback.test.ts
+++ b/packages/app/tests/integration/bug3-source-mode-writeback.test.ts
@@ -1,3 +1,4 @@
+
import { readFileSync } from 'node:fs';
import { join } from 'node:path';
import { setTimeout as wait } from 'node:timers/promises';
diff --git a/packages/app/tests/integration/indented-jsx-byte-sacred.test.ts b/packages/app/tests/integration/indented-jsx-byte-sacred.test.ts
index 6fcdc23f2..4fc2c11f9 100644
--- a/packages/app/tests/integration/indented-jsx-byte-sacred.test.ts
+++ b/packages/app/tests/integration/indented-jsx-byte-sacred.test.ts
@@ -1,3 +1,4 @@
+
import { setTimeout as wait } from 'node:timers/promises';
import { normalizeBridge } from '@inkeep/open-knowledge-core';
import { updateYFragment } from '@tiptap/y-tiptap';
diff --git a/packages/app/tests/integration/interior-edit-freshness.test.ts b/packages/app/tests/integration/interior-edit-freshness.test.ts
index 40b5cdfd6..9f2f6feb6 100644
--- a/packages/app/tests/integration/interior-edit-freshness.test.ts
+++ b/packages/app/tests/integration/interior-edit-freshness.test.ts
@@ -1,3 +1,4 @@
+
import { setTimeout as wait } from 'node:timers/promises';
import { updateYFragment, yXmlFragmentToProseMirrorRootNode } from '@tiptap/y-tiptap';
import { afterAll, beforeAll, describe, expect, test } from 'vitest';
diff --git a/packages/app/tests/integration/keystroke-cadence-danger-space.test.ts b/packages/app/tests/integration/keystroke-cadence-danger-space.test.ts
index 93666af70..2a085742b 100644
--- a/packages/app/tests/integration/keystroke-cadence-danger-space.test.ts
+++ b/packages/app/tests/integration/keystroke-cadence-danger-space.test.ts
@@ -1,3 +1,4 @@
+
import { setTimeout as wait } from 'node:timers/promises';
import { updateYFragment, yXmlFragmentToProseMirrorRootNode } from '@tiptap/y-tiptap';
import { afterAll, beforeAll, describe, expect, test } from 'vitest';
diff --git a/packages/app/tests/integration/producer-guard-wiring.test.ts b/packages/app/tests/integration/producer-guard-wiring.test.ts
index 867598d34..878d5196b 100644
--- a/packages/app/tests/integration/producer-guard-wiring.test.ts
+++ b/packages/app/tests/integration/producer-guard-wiring.test.ts
@@ -1,3 +1,4 @@
+
import { setTimeout as wait } from 'node:timers/promises';
import { updateYFragment, yXmlFragmentToProseMirrorRootNode } from '@tiptap/y-tiptap';
import { afterAll, beforeAll, describe, expect, test } from 'vitest';
diff --git a/packages/app/tests/integration/qa-039-reconciliation-counters-http.test.ts b/packages/app/tests/integration/qa-039-reconciliation-counters-http.test.ts
index 0970ac12f..4ada3cf26 100644
--- a/packages/app/tests/integration/qa-039-reconciliation-counters-http.test.ts
+++ b/packages/app/tests/integration/qa-039-reconciliation-counters-http.test.ts
@@ -1,3 +1,4 @@
+
import { randomUUID } from 'node:crypto';
import { afterEach, describe, expect, test } from 'vitest';
import { agentWriteMd, createTestServer, type TestServer } from './test-harness';
diff --git a/packages/app/tests/integration/qa-045-restore-after-gc.test.ts b/packages/app/tests/integration/qa-045-restore-after-gc.test.ts
index b632185e1..cbe2b705f 100644
--- a/packages/app/tests/integration/qa-045-restore-after-gc.test.ts
+++ b/packages/app/tests/integration/qa-045-restore-after-gc.test.ts
@@ -1,3 +1,4 @@
+
import { execFileSync } from 'node:child_process';
import { randomUUID } from 'node:crypto';
import { join } from 'node:path';
diff --git a/packages/app/tests/integration/qa-050-rollback-undo-shipped-path.test.ts b/packages/app/tests/integration/qa-050-rollback-undo-shipped-path.test.ts
index c530ce4ba..89bc9b4d9 100644
--- a/packages/app/tests/integration/qa-050-rollback-undo-shipped-path.test.ts
+++ b/packages/app/tests/integration/qa-050-rollback-undo-shipped-path.test.ts
@@ -1,3 +1,4 @@
+
import { randomUUID } from 'node:crypto';
import { afterAll, afterEach, beforeAll, describe, expect, test } from 'vitest';
import type * as Y from 'yjs';
diff --git a/packages/app/tests/integration/undo-after-rollback.test.ts b/packages/app/tests/integration/undo-after-rollback.test.ts
index d3767adc9..a78aeb0e4 100644
--- a/packages/app/tests/integration/undo-after-rollback.test.ts
+++ b/packages/app/tests/integration/undo-after-rollback.test.ts
@@ -1,3 +1,4 @@
+
import { ROLLBACK_ORIGIN } from '@inkeep/open-knowledge-server';
import { afterAll, beforeAll, describe, expect, test } from 'vitest';
import * as Y from 'yjs';
diff --git a/packages/app/tests/integration/undo-recycle-reset.test.ts b/packages/app/tests/integration/undo-recycle-reset.test.ts
index b076f955c..e7cc69c3f 100644
--- a/packages/app/tests/integration/undo-recycle-reset.test.ts
+++ b/packages/app/tests/integration/undo-recycle-reset.test.ts
@@ -1,3 +1,4 @@
+
import { writeFileSync } from 'node:fs';
import { join } from 'node:path';
import { setTimeout as wait } from 'node:timers/promises';
diff --git a/packages/app/tests/integration/undo-rederive-survival.test.ts b/packages/app/tests/integration/undo-rederive-survival.test.ts
index 7935e35f8..9ddcd0730 100644
--- a/packages/app/tests/integration/undo-rederive-survival.test.ts
+++ b/packages/app/tests/integration/undo-rederive-survival.test.ts
@@ -1,3 +1,4 @@
+
import { prependFrontmatter } from '@inkeep/open-knowledge-core';
import { Plugin, PluginKey } from '@tiptap/pm/state';
import { updateYFragment, yXmlFragmentToProseMirrorRootNode } from '@tiptap/y-tiptap';
diff --git a/packages/app/tests/stress/_helpers/global-warm-cache.ts b/packages/app/tests/stress/_helpers/global-warm-cache.ts
index fc66485f9..2c635a80d 100644
--- a/packages/app/tests/stress/_helpers/global-warm-cache.ts
+++ b/packages/app/tests/stress/_helpers/global-warm-cache.ts
@@ -13,6 +13,7 @@ import {
import { tmpdir } from 'node:os';
import { dirname, join } from 'node:path';
import { setTimeout as wait } from 'node:timers/promises';
+import { fileURLToPath } from 'node:url';
import { APP_PACKAGE_ROOT, computeSeedKey } from './seed-key.ts';
import {
beginViteStartup,
@@ -32,6 +33,14 @@ import { removeAllDuringTeardown } from './teardown-fs.ts';
const SEED_KEY_FILENAME = '.seed-key';
const OPTIMIZER_SETTLE_BUDGET_MS = 90_000;
const WARM_ATTEMPTS = 2;
+const OWNER_GUARD = fileURLToPath(new URL('./warm-cache-owner-guard.cjs', import.meta.url));
+
+function appendNodeOption(options: string | undefined, option: string): string {
+ if (options?.split(/\s+/).includes(option)) return options;
+ return [options, option]
+ .filter((value): value is string => value !== undefined && value !== '')
+ .join(' ');
+}
function publishSeed(buildDir: string): void {
const seedParent = dirname(VITE_E2E_SEED_DIR);
@@ -77,6 +86,8 @@ async function buildSeedOnce(key: string): Promise<void> {
env: {
...process.env,
...request.environment,
+ OK_WARM_CACHE_OWNER_PID: String(process.pid),
+ NODE_OPTIONS: appendNodeOption(process.env.NODE_OPTIONS, `--require=${OWNER_GUARD}`),
OK_TEST_CONTENT_DIR: contentDir,
OK_TEST_VITE_CACHE_DIR: buildDir,
OK_TEST_SKIP_I18N_COMPILE: '1',
diff --git a/packages/app/tests/stress/_helpers/warm-cache-owner-guard.cjs b/packages/app/tests/stress/_helpers/warm-cache-owner-guard.cjs
new file mode 100644
index 000000000..f9f175f46
--- /dev/null
+++ b/packages/app/tests/stress/_helpers/warm-cache-owner-guard.cjs
@@ -0,0 +1,33 @@
+'use strict';
+
+const OWNER_PID_ENV = 'OK_WARM_CACHE_OWNER_PID';
+const POLL_INTERVAL_MS = 25;
+
+function parseOwnerPid(value) {
+ const ownerPid = Number(value);
+ return Number.isInteger(ownerPid) && ownerPid > 1 ? ownerPid : undefined;
+}
+
+function exitForOwnerLoss(ownerPid) {
+ process.stderr.write(
+ `[warm-cache owner guard] pid ${process.pid} exiting on owner ESRCH; owner pid ${ownerPid}\n`,
+ );
+ process.exit(0);
+}
+
+function startOwnerGuard(ownerPid) {
+ const poll = setInterval(() => {
+ try {
+ process.kill(ownerPid, 0);
+ } catch (error) {
+ if (error && typeof error === 'object' && error.code === 'ESRCH') {
+ clearInterval(poll);
+ exitForOwnerLoss(ownerPid);
+ }
+ }
+ }, POLL_INTERVAL_MS);
+ poll.unref();
+}
+
+const ownerPid = parseOwnerPid(process.env[OWNER_PID_ENV]);
+if (ownerPid !== undefined) startOwnerGuard(ownerPid);
diff --git a/packages/app/tests/stress/_helpers/warm-cache-owner-loss-guard.cjs b/packages/app/tests/stress/_helpers/warm-cache-owner-loss-guard.cjs
new file mode 100644
index 000000000..6892f29e3
--- /dev/null
+++ b/packages/app/tests/stress/_helpers/warm-cache-owner-loss-guard.cjs
@@ -0,0 +1,103 @@
+const { appendFileSync, existsSync } = require('node:fs');
+const { tracingChannel } = require('node:diagnostics_channel');
+const { isMainThread } = require('node:worker_threads');
+
+const eventsPath = process.env.OK_TEST_WARM_CACHE_OWNER_LOSS_EVENTS;
+const ownerPid = Number(process.env.OK_TEST_WARM_CACHE_OWNER_PID);
+const expectedParent = Number.isInteger(ownerPid) && ownerPid > 1 ? ownerPid : process.ppid;
+const chain = process.env.OK_TEST_WARM_CACHE_OWNER_LOSS_CHAIN === '1';
+const cleanupPath = process.env.OK_TEST_WARM_CACHE_OWNER_LOSS_CLEANUP;
+let changed = false;
+let ownerLost = false;
+let exited = false;
+
+function write(event) {
+ if (eventsPath === undefined || !isMainThread) return;
+ appendFileSync(
+ eventsPath,
+ `${JSON.stringify({ event, pid: process.pid, ppid: process.ppid, time: Date.now() })}\n`,
+ );
+}
+
+function observeOwnerLoss() {
+ if (ownerLost || !Number.isInteger(ownerPid) || ownerPid <= 1) return;
+ try {
+ process.kill(ownerPid, 0);
+ } catch (error) {
+ if (error && typeof error === 'object' && error.code === 'ESRCH') {
+ ownerLost = true;
+ write({ kind: 'owner-lost', ownerPid });
+ }
+ }
+}
+
+write({ kind: 'loaded', chain, argv: process.argv });
+
+const spawnChannel = tracingChannel('child_process.spawn');
+spawnChannel.start.subscribe(({ process: child, options }) => {
+ const isPnpm =
+ options.file === 'pnpm' ||
+ options.file.endsWith('/pnpm') ||
+ options.args?.some((arg) => arg.endsWith('/pnpm')) === true;
+ if (!chain && (!isPnpm || options.detached !== true)) return;
+ const propagatedOwnerPid =
+ chain && Number.isInteger(ownerPid) && ownerPid > 1 ? ownerPid : process.pid;
+ if (Array.isArray(options.envPairs)) {
+ options.envPairs = options.envPairs
+ .filter((entry) => !entry.startsWith('OK_TEST_WARM_CACHE_OWNER_PID='))
+ .filter((entry) => !entry.startsWith('OK_TEST_WARM_CACHE_OWNER_LOSS_CHAIN='))
+ .concat(`OK_TEST_WARM_CACHE_OWNER_PID=${propagatedOwnerPid}`)
+ .concat('OK_TEST_WARM_CACHE_OWNER_LOSS_CHAIN=1');
+ }
+ child.once('spawn', () => {
+ write({
+ kind: 'spawn',
+ childPid: child.pid,
+ file: options.file,
+ args: options.args,
+ detached: options.detached === true,
+ chain: chain || isPnpm,
+ });
+ });
+ child.once('exit', (code, signal) =>
+ write({ kind: 'child-exit', childPid: child.pid, code, signal }),
+ );
+});
+
+function finish(kind) {
+ if (exited) return;
+ exited = true;
+ write({ kind });
+ process.exit(0);
+}
+
+process.on('exit', () => {
+ if (exited) return;
+ observeOwnerLoss();
+ exited = true;
+ write({ kind: 'exit' });
+});
+process.on('SIGTERM', () => finish('signal:SIGTERM'));
+process.on('SIGINT', () => finish('signal:SIGINT'));
+
+const poll = setInterval(() => {
+ if (process.ppid !== expectedParent && !changed) {
+ changed = true;
+ write({
+ kind: 'parent-changed',
+ expectedParent,
+ currentParent: process.ppid,
+ ownerLost: process.ppid === 1,
+ });
+ if (!chain) finish('parent-lost');
+ }
+ observeOwnerLoss();
+}, 10);
+poll.unref();
+
+if (cleanupPath !== undefined) {
+ const cleanup = setInterval(() => {
+ if (existsSync(cleanupPath)) finish('guard-cleanup');
+ }, 10);
+ cleanup.unref();
+}
diff --git a/packages/app/tests/stress/_helpers/warm-cache-owner-loss-holder.mjs b/packages/app/tests/stress/_helpers/warm-cache-owner-loss-holder.mjs
new file mode 100644
index 000000000..6796ea959
--- /dev/null
+++ b/packages/app/tests/stress/_helpers/warm-cache-owner-loss-holder.mjs
@@ -0,0 +1,6 @@
+import { pathToFileURL } from 'node:url';
+
+const source = process.env.OK_TEST_WARM_CACHE_OWNER_LOSS_SOURCE;
+if (source === undefined) throw new Error('warm-cache source is missing');
+const { default: globalWarmViteCache } = await import(pathToFileURL(source).href);
+await globalWarmViteCache();
diff --git a/packages/core/src/bridge/compose.ts b/packages/core/src/bridge/compose.ts
index f4cc8a286..2a597ec3d 100644
--- a/packages/core/src/bridge/compose.ts
+++ b/packages/core/src/bridge/compose.ts
@@ -1,3 +1,4 @@
+
import { prependFrontmatter, stripFrontmatter } from '../extensions/frontmatter.ts';
export type ComposeAdjustment = 'none' | 'body' | 'frontmatter' | 'unresolved';
diff --git a/packages/core/src/bridge/doc-boundary-space.ts b/packages/core/src/bridge/doc-boundary-space.ts
index e7e63f43d..ffd8fce06 100644
--- a/packages/core/src/bridge/doc-boundary-space.ts
+++ b/packages/core/src/bridge/doc-boundary-space.ts
@@ -1,3 +1,4 @@
+
import { FRONTMATTER_RE, stripFrontmatter } from '../extensions/frontmatter.ts';
import { carriedEdgeEmpties, type DocEdgeEmpties } from '../markdown/doc-edge-blank-runs.ts';
diff --git a/packages/core/src/markdown/comment-promoter.ts b/packages/core/src/markdown/comment-promoter.ts
index fc267cbea..fb0ba5a7c 100644
--- a/packages/core/src/markdown/comment-promoter.ts
+++ b/packages/core/src/markdown/comment-promoter.ts
@@ -1,3 +1,4 @@
+
import type { Nodes, Paragraph, PhrasingContent, Root, RootContent, Text } from 'mdast';
import { SKIP, visit } from 'unist-util-visit';
import type { VFile } from 'vfile';
diff --git a/packages/core/src/markdown/merged-walker.ts b/packages/core/src/markdown/merged-walker.ts
index 861003fb4..ae8cb390b 100644
--- a/packages/core/src/markdown/merged-walker.ts
+++ b/packages/core/src/markdown/merged-walker.ts
@@ -1,3 +1,4 @@
+
import type { Nodes, Parent, Root } from 'mdast';
import { SKIP, visit } from 'unist-util-visit';
import type { VFile } from 'vfile';
diff --git a/packages/core/src/markdown/safe-url.ts b/packages/core/src/markdown/safe-url.ts
index 4d3250d3a..8be632ba4 100644
--- a/packages/core/src/markdown/safe-url.ts
+++ b/packages/core/src/markdown/safe-url.ts
@@ -1,3 +1,4 @@
+
export const SAFE_URL_SCHEMES = ['https', 'http', 'mailto', 'tel', 'ftp', 'sms'] as const;
const SCHEME_ALT = SAFE_URL_SCHEMES.map((s) => `${s}:`).join('|');