Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

Stop hidden Chat stress tests from leaving threads behind (#7567)

Nick Gomez9e6dd3ef7e07
diff --git a/knip.config.ts b/knip.config.ts
index fac2580fe..e04bf5228 100644
--- a/knip.config.ts
+++ b/knip.config.ts
@@ -157,15 +157,11 @@ 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/integration/bug3-source-mode-writeback.test.ts b/packages/app/tests/integration/bug3-source-mode-writeback.test.ts
index 4549c74b3..a50b00123 100644
--- a/packages/app/tests/integration/bug3-source-mode-writeback.test.ts
+++ b/packages/app/tests/integration/bug3-source-mode-writeback.test.ts
@@ -1,4 +1,3 @@
-
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 4fc2c11f9..6fcdc23f2 100644
--- a/packages/app/tests/integration/indented-jsx-byte-sacred.test.ts
+++ b/packages/app/tests/integration/indented-jsx-byte-sacred.test.ts
@@ -1,4 +1,3 @@
-
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 9f2f6feb6..40b5cdfd6 100644
--- a/packages/app/tests/integration/interior-edit-freshness.test.ts
+++ b/packages/app/tests/integration/interior-edit-freshness.test.ts
@@ -1,4 +1,3 @@
-
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 2a085742b..93666af70 100644
--- a/packages/app/tests/integration/keystroke-cadence-danger-space.test.ts
+++ b/packages/app/tests/integration/keystroke-cadence-danger-space.test.ts
@@ -1,4 +1,3 @@
-
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 878d5196b..867598d34 100644
--- a/packages/app/tests/integration/producer-guard-wiring.test.ts
+++ b/packages/app/tests/integration/producer-guard-wiring.test.ts
@@ -1,4 +1,3 @@
-
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 4ada3cf26..0970ac12f 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,4 +1,3 @@
-
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 cbe2b705f..b632185e1 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,4 +1,3 @@
-
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 89bc9b4d9..c530ce4ba 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,4 +1,3 @@
-
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 a78aeb0e4..d3767adc9 100644
--- a/packages/app/tests/integration/undo-after-rollback.test.ts
+++ b/packages/app/tests/integration/undo-after-rollback.test.ts
@@ -1,4 +1,3 @@
-
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 e7cc69c3f..b076f955c 100644
--- a/packages/app/tests/integration/undo-recycle-reset.test.ts
+++ b/packages/app/tests/integration/undo-recycle-reset.test.ts
@@ -1,4 +1,3 @@
-
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 9ddcd0730..7935e35f8 100644
--- a/packages/app/tests/integration/undo-rederive-survival.test.ts
+++ b/packages/app/tests/integration/undo-rederive-survival.test.ts
@@ -1,4 +1,3 @@
-
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/meta/hidden-chat-transport-helper.test.ts b/packages/app/tests/meta/hidden-chat-transport-helper.test.ts
new file mode 100644
index 000000000..ed5c46d79
--- /dev/null
+++ b/packages/app/tests/meta/hidden-chat-transport-helper.test.ts
@@ -0,0 +1,220 @@
+import type {
+ ThreadClientFrame,
+ ThreadServerFrame,
+} from '@inkeep/open-knowledge-core/acp/thread-protocol';
+import { describe, expect, test } from 'vitest';
+import { closeThreadAndDelete } from '../stress/hidden-chat-transport.test-helper';
+
+const noPause = async () => {};
+
+type SocketLogEntry = { kind: 'sent'; frame: ThreadClientFrame } | { kind: 'pause' };
+
+interface WaitCall {
+ deadline: number | undefined;
+ afterDelete: boolean;
+}
+
+function replyingThreadSocket(rosterReplies: ThreadServerFrame[]) {
+ const replies = [...rosterReplies];
+ const frames: ThreadServerFrame[] = [];
+ const log: SocketLogEntry[] = [];
+ const sentDuringMatches: ThreadClientFrame[] = [];
+ const sentWhilePauseHeld: ThreadClientFrame[] = [];
+ const waitCalls: WaitCall[] = [];
+ const unclaimedPauseReleases: Array<() => void> = [];
+ const pauseClaimers: Array<(release: () => void) => void> = [];
+ let matchesCalls = 0;
+ let insideMatches = false;
+ let heldPauses = 0;
+
+ const send = (frame: ThreadClientFrame) => {
+ log.push({ kind: 'sent', frame });
+ if (insideMatches) sentDuringMatches.push(frame);
+ if (heldPauses > 0) sentWhilePauseHeld.push(frame);
+ const reply = replies.shift();
+ if (reply !== undefined) frames.push(reply);
+ };
+ const waitForFrame = async (
+ matches: (frame: ThreadServerFrame) => boolean,
+ fromIndex: number,
+ deadline?: number,
+ ) => {
+ waitCalls.push({
+ deadline,
+ afterDelete: log.some((entry) => entry.kind === 'sent' && entry.frame.op === 'delete'),
+ });
+ for (let index = fromIndex; index < frames.length; index++) {
+ const frame = frames[index];
+ matchesCalls += 1;
+ insideMatches = true;
+ const matched = matches(frame);
+ insideMatches = false;
+ if (matched) return frame;
+ }
+ throw new Error('roster replies ended before the expected frame');
+ };
+ const pauseBeforeRefresh = () => {
+ log.push({ kind: 'pause' });
+ heldPauses += 1;
+ return new Promise<void>((resolve) => {
+ const release = () => {
+ heldPauses -= 1;
+ resolve();
+ };
+ const claimer = pauseClaimers.shift();
+ if (claimer === undefined) unclaimedPauseReleases.push(release);
+ else claimer(release);
+ });
+ };
+ const nextHeldPause = () =>
+ new Promise<() => void>((resolve) => {
+ const release = unclaimedPauseReleases.shift();
+ if (release === undefined) pauseClaimers.push(resolve);
+ else resolve(release);
+ });
+
+ return {
+ log,
+ sentDuringMatches,
+ sentWhilePauseHeld,
+ waitCalls,
+ matchesCallCount: () => matchesCalls,
+ send,
+ waitForFrame,
+ frameIndex: () => frames.length,
+ pauseBeforeRefresh,
+ nextHeldPause,
+ };
+}
+
+function rosterRepliesForConcurrentClose(threadId: string): ThreadServerFrame[] {
+ return [
+ { op: 'threads', threads: [{ threadId, archived: false }] },
+ { op: 'threads', threads: [{ threadId, archived: false }] },
+ { op: 'threads', threads: [{ threadId, archived: true }] },
+ { op: 'threads', threads: [] },
+ ];
+}
+
+describe('closeThreadAndDelete', () => {
+ test('waits for the archived roster before deleting a closed thread', async () => {
+ const threadId = 'thread-under-test';
+ const frames: ThreadServerFrame[] = [
+ { op: 'threads', threads: [{ threadId, archived: false }] },
+ { op: 'threads', threads: [{ threadId, archived: true }] },
+ { op: 'threads', threads: [] },
+ ];
+ const sent: ThreadClientFrame[] = [];
+ let nextFrame = 0;
+
+ await closeThreadAndDelete(
+ threadId,
+ (frame) => sent.push(frame),
+ async (matches) => {
+ while (nextFrame < frames.length) {
+ const frame = frames[nextFrame++];
+ if (matches(frame)) return frame;
+ }
+ throw new Error('frame stream ended before the expected frame');
+ },
+ () => nextFrame,
+ noPause,
+ );
+
+ expect(sent).toEqual([{ op: 'close', threadId }, { op: 'list' }, { op: 'delete', threadId }]);
+ });
+
+ test('does not delete a thread that close already discarded', async () => {
+ const threadId = 'empty-thread';
+ const sent: ThreadClientFrame[] = [];
+ let nextFrame = 0;
+
+ await closeThreadAndDelete(
+ threadId,
+ (frame) => sent.push(frame),
+ async (matches) => {
+ const frame: ThreadServerFrame = { op: 'threads', threads: [] };
+ nextFrame += 1;
+ if (matches(frame)) return frame;
+ throw new Error(`frame ${nextFrame} did not satisfy the close predicate`);
+ },
+ () => nextFrame,
+ noPause,
+ );
+
+ expect(sent).toEqual([{ op: 'close', threadId }]);
+ });
+
+ test('pauses before every roster refresh while a concurrent close is still archiving', async () => {
+ const threadId = 'concurrently-closing-thread';
+ const socket = replyingThreadSocket(rosterRepliesForConcurrentClose(threadId));
+
+ const closed = closeThreadAndDelete(
+ threadId,
+ socket.send,
+ socket.waitForFrame,
+ socket.frameIndex,
+ socket.pauseBeforeRefresh,
+ ).then(() => ({ kind: 'closed' }) as const);
+ for (;;) {
+ const step = await Promise.race([
+ closed,
+ socket.nextHeldPause().then((release) => ({ kind: 'paused', release }) as const),
+ ]);
+ if (step.kind === 'closed') break;
+ step.release();
+ }
+
+ expect(socket.sentWhilePauseHeld, 'frames sent before the pause ahead of them settled').toEqual(
+ [],
+ );
+ expect(socket.log).toEqual([
+ { kind: 'sent', frame: { op: 'close', threadId } },
+ { kind: 'pause' },
+ { kind: 'sent', frame: { op: 'list' } },
+ { kind: 'pause' },
+ { kind: 'sent', frame: { op: 'list' } },
+ { kind: 'sent', frame: { op: 'delete', threadId } },
+ ]);
+ });
+
+ test('sends roster refreshes from the helper rather than from the frame matcher', async () => {
+ const threadId = 'concurrently-closing-thread';
+ const socket = replyingThreadSocket(rosterRepliesForConcurrentClose(threadId));
+
+ await closeThreadAndDelete(
+ threadId,
+ socket.send,
+ socket.waitForFrame,
+ socket.frameIndex,
+ noPause,
+ );
+
+ expect(socket.matchesCallCount()).toBeGreaterThan(0);
+ expect(socket.log).toContainEqual({ kind: 'sent', frame: { op: 'list' } });
+ expect(socket.sentDuringMatches, 'frames sent while the matcher ran').toEqual([]);
+ });
+
+ test('gives every close-phase roster wait the same finite deadline', async () => {
+ const threadId = 'concurrently-closing-thread';
+ const socket = replyingThreadSocket(rosterRepliesForConcurrentClose(threadId));
+
+ await closeThreadAndDelete(
+ threadId,
+ socket.send,
+ socket.waitForFrame,
+ socket.frameIndex,
+ noPause,
+ );
+
+ const closePhaseDeadlines = socket.waitCalls
+ .filter((call) => !call.afterDelete)
+ .map((call) => call.deadline);
+ expect(
+ Number.isFinite(closePhaseDeadlines[0]),
+ 'the close phase waits under a finite deadline the helper supplies',
+ ).toBe(true);
+ expect(closePhaseDeadlines.length).toBeGreaterThanOrEqual(2);
+ expect(closePhaseDeadlines).toEqual(closePhaseDeadlines.map(() => closePhaseDeadlines[0]));
+ });
+});
diff --git a/packages/app/tests/stress/chat-shortcut-collapsed-thread.e2e.ts b/packages/app/tests/stress/chat-shortcut-collapsed-thread.e2e.ts
index 83b0de6e7..9dd1410b7 100644
--- a/packages/app/tests/stress/chat-shortcut-collapsed-thread.e2e.ts
+++ b/packages/app/tests/stress/chat-shortcut-collapsed-thread.e2e.ts
@@ -1,4 +1,5 @@
import { randomUUID } from 'node:crypto';
+import type { ThreadServerFrame } from '@inkeep/open-knowledge-core/acp/thread-protocol';
import type { Page } from '@playwright/test';
import type { AgentCatalog } from '@/lib/acp/catalog';
import { dockUnitRect, expect, test, waitForActiveProviderSynced } from './_helpers';
@@ -19,6 +20,36 @@ async function registerFixtureAgent(page: Page, agentId: string): Promise<void>
);
}, agentId);
}
+
+function collectBrowserThreadIds(page: Page, fixtureThreadId: string): Set<string> {
+ const threadIds = new Set<string>();
+ page.on('websocket', (socket) => {
+ if (!socket.url().endsWith('/collab/thread')) return;
+ socket.on('framereceived', ({ payload }) => {
+ if (typeof payload !== 'string') return;
+ const frame = JSON.parse(payload) as ThreadServerFrame;
+ if (frame.op === 'threads') {
+ for (const thread of frame.threads) {
+ if (thread.threadId !== fixtureThreadId) threadIds.add(thread.threadId);
+ }
+ }
+ if (frame.op === 'created' && frame.info.threadId !== fixtureThreadId)
+ threadIds.add(frame.info.threadId);
+ });
+ });
+ return threadIds;
+}
+
+async function closeCreatedThreads(
+ fixture: Awaited<ReturnType<typeof startHiddenChatAgent>>,
+ createdThreadIds: Set<string>,
+): Promise<void> {
+ try {
+ for (const id of createdThreadIds) await fixture.closeThread(id);
+ } finally {
+ await fixture.close();
+ }
+}
test.beforeEach(async ({ page }) => {
await page.route('**/api/acp/catalog', async (route) => {
const response = await route.fetch();
@@ -40,6 +71,7 @@ test('Chat shortcut restores a hidden real thread in the same frame', async ({
await api.seedDocs([{ name: docName, markdown: '# Chat shortcut fixture\n' }]);
const fixture = await startHiddenChatAgent(workerServer);
await registerFixtureAgent(page, fixture.agentId);
+ const createdThreadIds = collectBrowserThreadIds(page, fixture.threadId);
const client = await page.context().newCDPSession(page);
const frames: string[] = [];
client.on('Page.screencastFrame', (event) => {
@@ -174,7 +206,7 @@ test('Chat shortcut restores a hidden real thread in the same frame', async ({
expect(pageErrors).toEqual([]);
} finally {
await client.detach();
- await fixture.close();
+ await closeCreatedThreads(fixture, createdThreadIds);
}
});
@@ -193,6 +225,7 @@ for (const action of [
await api.seedDocs([{ name: docName, markdown: '# Chat reveal fixture\n' }]);
const fixture = await startHiddenChatAgent(workerServer);
await registerFixtureAgent(page, fixture.agentId);
+ const createdThreadIds = collectBrowserThreadIds(page, fixture.threadId);
try {
await page.setViewportSize({ width: 1600, height: 900 });
await page.goto(`/#/${docName}`);
@@ -310,7 +343,7 @@ for (const action of [
await threadTab.focus();
await expect(threadTab).toBeFocused();
} finally {
- await fixture.close();
+ await closeCreatedThreads(fixture, createdThreadIds);
}
});
}
diff --git a/packages/app/tests/stress/hidden-chat-transport.test-helper.ts b/packages/app/tests/stress/hidden-chat-transport.test-helper.ts
index 73bb54d75..afccafd59 100644
--- a/packages/app/tests/stress/hidden-chat-transport.test-helper.ts
+++ b/packages/app/tests/stress/hidden-chat-transport.test-helper.ts
@@ -1,6 +1,7 @@
import { randomUUID } from 'node:crypto';
import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
import { join } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
import type {
ThreadClientFrame,
ThreadServerFrame,
@@ -18,6 +19,50 @@ interface HiddenChatAgent {
close(): Promise<void>;
}
+const THREAD_FRAME_WAIT_MS = 20_000;
+const ROSTER_REFRESH_INTERVAL_MS = 50;
+
+const pauseBeforeRosterRefresh = () => delay(ROSTER_REFRESH_INTERVAL_MS);
+
+export async function closeThreadAndDelete(
+ id: string,
+ send: (frame: ThreadClientFrame) => void,
+ waitForFrame: (
+ matches: (frame: ThreadServerFrame) => boolean,
+ fromIndex: number,
+ deadline: number,
+ ) => Promise<ThreadServerFrame>,
+ frameIndex: () => number,
+ pauseBeforeRefresh: () => Promise<void>,
+): Promise<void> {
+ let rosterFromIndex = frameIndex();
+ send({ op: 'close', threadId: id });
+ const closeDeadline = performance.now() + THREAD_FRAME_WAIT_MS;
+ for (;;) {
+ const roster = await waitForFrame(
+ (frame) => frame.op === 'threads',
+ rosterFromIndex,
+ closeDeadline,
+ );
+ if (roster.op !== 'threads') {
+ throw new Error(`thread fixture roster wait resolved a ${roster.op} frame`);
+ }
+ const thread = roster.threads.find((candidate) => candidate.threadId === id);
+ if (thread === undefined) return;
+ if (thread.archived === true) break;
+ await pauseBeforeRefresh();
+ rosterFromIndex = frameIndex();
+ send({ op: 'list' });
+ }
+ const deleteFromIndex = frameIndex();
+ send({ op: 'delete', threadId: id });
+ await waitForFrame(
+ (frame) => frame.op === 'threads' && !frame.threads.some((thread) => thread.threadId === id),
+ deleteFromIndex,
+ performance.now() + THREAD_FRAME_WAIT_MS,
+ );
+}
+
export async function startHiddenChatAgent(workerServer: WorkerServer): Promise<HiddenChatAgent> {
const localDir = join(workerServer.contentDir, '.ok', 'local');
mkdirSync(localDir, { recursive: true });
@@ -102,21 +147,28 @@ process.stdin.on('data', (chunk) => {
});
});
const send = (frame: ThreadClientFrame) => socket.send(JSON.stringify(frame));
- const waitForFrame = (matches: (frame: ThreadServerFrame) => boolean, fromIndex = 0) =>
+ const waitForFrame = (
+ matches: (frame: ThreadServerFrame) => boolean,
+ fromIndex = 0,
+ deadline = performance.now() + THREAD_FRAME_WAIT_MS,
+ ) =>
new Promise<ThreadServerFrame>((resolve, reject) => {
const found = frames.slice(fromIndex).find(matches);
if (found !== undefined) {
resolve(found);
return;
}
- const timer = setTimeout(() => {
- listeners.delete(listener);
- reject(
- new Error(
- `thread fixture frame timeout; saw ${frames.map((frame) => frame.op).join(', ')}`,
- ),
- );
- }, 20_000);
+ const timer = setTimeout(
+ () => {
+ listeners.delete(listener);
+ reject(
+ new Error(
+ `thread fixture frame timeout; saw ${frames.map((frame) => frame.op).join(', ')}`,
+ ),
+ );
+ },
+ Math.max(0, deadline - performance.now()),
+ );
const listener = (frame: ThreadServerFrame) => {
if (!matches(frame)) return;
clearTimeout(timer);
@@ -136,19 +188,13 @@ process.stdin.on('data', (chunk) => {
);
const closeThread = async (id: string) => {
- const closeFromIndex = frames.length;
- send({ op: 'close', threadId: id });
- const closed = await waitForFrame((frame) => frame.op === 'threads', closeFromIndex);
- if (closed.op !== 'threads') return;
- if (closed.threads.some((thread) => thread.threadId === id && thread.archived === true)) {
- const deleteFromIndex = frames.length;
- send({ op: 'delete', threadId: id });
- await waitForFrame(
- (frame) =>
- frame.op === 'threads' && !frame.threads.some((thread) => thread.threadId === id),
- deleteFromIndex,
- );
- }
+ await closeThreadAndDelete(
+ id,
+ send,
+ waitForFrame,
+ () => frames.length,
+ pauseBeforeRosterRefresh,
+ );
};
return {
diff --git a/packages/core/src/bridge/compose.ts b/packages/core/src/bridge/compose.ts
index 2a597ec3d..f4cc8a286 100644
--- a/packages/core/src/bridge/compose.ts
+++ b/packages/core/src/bridge/compose.ts
@@ -1,4 +1,3 @@
-
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 ffd8fce06..e7e63f43d 100644
--- a/packages/core/src/bridge/doc-boundary-space.ts
+++ b/packages/core/src/bridge/doc-boundary-space.ts
@@ -1,4 +1,3 @@
-
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 fb0ba5a7c..fc267cbea 100644
--- a/packages/core/src/markdown/comment-promoter.ts
+++ b/packages/core/src/markdown/comment-promoter.ts
@@ -1,4 +1,3 @@
-
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 ae8cb390b..861003fb4 100644
--- a/packages/core/src/markdown/merged-walker.ts
+++ b/packages/core/src/markdown/merged-walker.ts
@@ -1,4 +1,3 @@
-
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 8be632ba4..4d3250d3a 100644
--- a/packages/core/src/markdown/safe-url.ts
+++ b/packages/core/src/markdown/safe-url.ts
@@ -1,4 +1,3 @@
-
export const SAFE_URL_SCHEMES = ['https', 'http', 'mailto', 'tel', 'ftp', 'sms'] as const;
const SCHEME_ALT = SAFE_URL_SCHEMES.map((s) => `${s}:`).join('|');