diff --git a/infra/scripts/release/oxfmt-inprocess/api-bindings.ts b/infra/scripts/release/oxfmt-inprocess/api-bindings.ts
new file mode 100644
index 0000000..ce95f5b
--- /dev/null
+++ b/infra/scripts/release/oxfmt-inprocess/api-bindings.ts
@@ -0,0 +1,128 @@
+import { ApiExportMissing, WorkerImportUnrecognised } from '#oxfmt-inprocess/errors';
+import { err, ok } from '#oxfmt-inprocess/result';
+import type { Result } from '#oxfmt-inprocess/result';
+
+/** How oxfmt's worker entry imports the functions the shim delegates to. */
+const WORKER_IMPORT = /import\s*\{([^}]*)\}\s*from\s*["']([^"']+)["']/;
+
+/**
+ * One imported binding, in either form a bundler may emit: `x as localName`
+ * (rolldown's minified re-export) or a bare `localName`.
+ */
+const BINDING = /^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/;
+
+/**
+ * Where oxfmt's embedded-formatting functions live, and what each is exported
+ * as.
+ *
+ * oxfmt's worker entry (`cli-worker.js`) is a two-line module that re-exports
+ * four functions from a content-hashed API module, e.g.
+ *
+ * ```js
+ * import { i as sortTailwindClasses, n as formatEmbeddedDoc, r as formatFile, t as formatEmbeddedCode } from './apis-CvFX8LhR.js';
+ * ```
+ *
+ * Both the hash and the single-letter aliases are bundler output and change
+ * between oxfmt releases, so they are read from the worker entry rather than
+ * hard-coded. Parsing succeeds only when all four functions are present, which
+ * is what lets the getters be total.
+ */
+export class ApiBindings {
+	readonly #moduleSpecifier: string;
+	readonly #formatFile: string;
+	readonly #formatEmbeddedCode: string;
+	readonly #formatEmbeddedDoc: string;
+	readonly #sortTailwindClasses: string;
+
+	private constructor(moduleSpecifier: string, formatFile: string, formatEmbeddedCode: string, formatEmbeddedDoc: string, sortTailwindClasses: string) {
+		this.#moduleSpecifier = moduleSpecifier;
+		this.#formatFile = formatFile;
+		this.#formatEmbeddedCode = formatEmbeddedCode;
+		this.#formatEmbeddedDoc = formatEmbeddedDoc;
+		this.#sortTailwindClasses = sortTailwindClasses;
+	}
+
+	/**
+	 * Read the API module and its export aliases out of oxfmt's worker entry.
+	 *
+	 * @param workerSource - The contents of oxfmt's `cli-worker.js`.
+	 * @param workerPath - Where that file came from, for error reporting.
+	 * @returns The parsed bindings, or the reason the worker entry was not recognised.
+	 */
+	static parse(workerSource: string, workerPath: string): Result<ApiBindings, ApiExportMissing | WorkerImportUnrecognised> {
+		const workerImport = WORKER_IMPORT.exec(workerSource);
+
+		if (workerImport === null) {
+			return err(new WorkerImportUnrecognised(workerPath, 'cannot find the API import'));
+		}
+
+		const [, bindingList, moduleSpecifier] = workerImport;
+
+		if (bindingList === undefined || moduleSpecifier === undefined) {
+			return err(new WorkerImportUnrecognised(workerPath, 'the API import carries no bindings'));
+		}
+
+		const exportsByRole = new Map<string, string>();
+
+		for (const binding of bindingList.split(',')) {
+			const trimmed = binding.trim();
+			const parsed = BINDING.exec(trimmed);
+			const exported = parsed?.[1];
+
+			if (parsed === null || exported === undefined) {
+				return err(new WorkerImportUnrecognised(workerPath, `unexpected binding "${trimmed}"`));
+			}
+
+			// A bare binding is imported under its own name, so it is its own role.
+			exportsByRole.set(parsed[2] ?? exported, exported);
+		}
+
+		const formatFile = exportsByRole.get('formatFile');
+		const formatEmbeddedCode = exportsByRole.get('formatEmbeddedCode');
+		const formatEmbeddedDoc = exportsByRole.get('formatEmbeddedDoc');
+		const sortTailwindClasses = exportsByRole.get('sortTailwindClasses');
+
+		if (formatFile === undefined) {
+			return err(new ApiExportMissing('formatFile', workerPath));
+		}
+
+		if (formatEmbeddedCode === undefined) {
+			return err(new ApiExportMissing('formatEmbeddedCode', workerPath));
+		}
+
+		if (formatEmbeddedDoc === undefined) {
+			return err(new ApiExportMissing('formatEmbeddedDoc', workerPath));
+		}
+
+		if (sortTailwindClasses === undefined) {
+			return err(new ApiExportMissing('sortTailwindClasses', workerPath));
+		}
+
+		return ok(new ApiBindings(moduleSpecifier, formatFile, formatEmbeddedCode, formatEmbeddedDoc, sortTailwindClasses));
+	}
+
+	/** The module specifier the API functions are imported from. */
+	get moduleSpecifier(): string {
+		return this.#moduleSpecifier;
+	}
+
+	/** The name `formatFile` is exported as. */
+	get formatFile(): string {
+		return this.#formatFile;
+	}
+
+	/** The name `formatEmbeddedCode` is exported as. */
+	get formatEmbeddedCode(): string {
+		return this.#formatEmbeddedCode;
+	}
+
+	/** The name `formatEmbeddedDoc` is exported as. */
+	get formatEmbeddedDoc(): string {
+		return this.#formatEmbeddedDoc;
+	}
+
+	/** The name `sortTailwindClasses` is exported as. */
+	get sortTailwindClasses(): string {
+		return this.#sortTailwindClasses;
+	}
+}
diff --git a/infra/scripts/release/oxfmt-inprocess/cli-patcher.ts b/infra/scripts/release/oxfmt-inprocess/cli-patcher.ts
new file mode 100644
index 0000000..c79ba2b
--- /dev/null
+++ b/infra/scripts/release/oxfmt-inprocess/cli-patcher.ts
@@ -0,0 +1,141 @@
+import { join } from 'node:path';
+import { ApiBindings } from '#oxfmt-inprocess/api-bindings';
+import { CliAlreadyPatched, CliAnchorMissing, CliPatchIncomplete } from '#oxfmt-inprocess/errors';
+import type { OxfmtPatchError } from '#oxfmt-inprocess/errors';
+import { err, isErr, ok } from '#oxfmt-inprocess/result';
+import type { Result } from '#oxfmt-inprocess/result';
+import { SHIM_MARKER, ShimSource } from '#oxfmt-inprocess/shim-source';
+import type { TextFiles } from '#oxfmt-inprocess/text-files';
+
+/** oxfmt's import of the worker-pool library, replaced by the shim's import. */
+const TINYPOOL_IMPORT = 'import Tinypool from "tinypool";';
+
+/**
+ * The structures the rewrite edits. Absent any one of them, oxfmt's CLI has
+ * changed shape and the rewrite must be re-derived rather than misapplied.
+ */
+const ANCHORS: ReadonlyArray<string> = [TINYPOOL_IMPORT, '//#region src-js/cli/worker-proxy.ts', 'runtime: "child_process"'];
+
+/** oxfmt's `worker-proxy` region, from its marker to the first region end. */
+const WORKER_PROXY_REGION = /\/\/#region src-js\/cli\/worker-proxy\.ts[\s\S]*?\/\/#endregion/;
+
+/** Worker-pool code that must not survive the rewrite. */
+const RESIDUE: ReadonlyArray<string> = ['Tinypool', 'pool.run', 'pool = '];
+
+/** What a successful rewrite changed. */
+export type PatchOutcome = {
+	/** The CLI file that was rewritten. */
+	readonly cliPath: string;
+
+	/** The API module the shim now calls directly. */
+	readonly apiModuleSpecifier: string;
+};
+
+/**
+ * Rewrites oxfmt's CLI to format embedded code in-process.
+ *
+ * oxfmt formats embedded code — Vue `<template>`/`<style>`, markdown fences,
+ * HTML — by handing it to a Tinypool pool running with
+ * `runtime: "child_process"`. That pool forks worker entry scripts which, in a
+ * `bun build --compile` binary, exist only as virtual `/$bunfs/root/…` paths and
+ * are never carved out as real files: every worker dies on startup and
+ * `Tinypool.destroy()` then awaits an exit event that never fires, wedging the
+ * process. Plain `.ts` never initialises the pool, which is why only files with
+ * embedded code hang.
+ *
+ * The four pooled functions are stateless prettier calls, so the pool only ever
+ * bought cross-file parallelism — not isolation. Calling them directly is
+ * therefore behaviourally identical, minus the worker layer that cannot work
+ * here. For the embedded-code fraction of a codebase the lost parallelism is
+ * negligible, and the per-worker prettier startup cost disappears with it.
+ *
+ * This runs at release-staging time against a freshly installed oxfmt in a
+ * throwaway workdir; the committed tree is never touched.
+ */
+export class OxfmtCliPatcher {
+	readonly #files: TextFiles;
+
+	/** @param files - Reads the CLI and worker entry, and writes the result back. */
+	constructor(files: TextFiles) {
+		this.#files = files;
+	}
+
+	/**
+	 * Rewrite oxfmt's CLI in place.
+	 *
+	 * @param distDir - oxfmt's `dist` directory, holding `cli.js` and `cli-worker.js`.
+	 * @returns What was rewritten, or the reason oxfmt no longer matches the rewrite.
+	 */
+	patch(distDir: string): Result<PatchOutcome, OxfmtPatchError> {
+		const cliPath = join(distDir, 'cli.js');
+		const workerPath = join(distDir, 'cli-worker.js');
+
+		const cliSource = this.#files.readText(cliPath);
+
+		if (isErr(cliSource)) {
+			return cliSource;
+		}
+
+		const workerSource = this.#files.readText(workerPath);
+
+		if (isErr(workerSource)) {
+			return workerSource;
+		}
+
+		const bindings = ApiBindings.parse(workerSource.value, workerPath);
+
+		if (isErr(bindings)) {
+			return bindings;
+		}
+
+		const rewritten = OxfmtCliPatcher.#rewrite(cliSource.value, bindings.value, cliPath);
+
+		if (isErr(rewritten)) {
+			return rewritten;
+		}
+
+		const written = this.#files.writeText(cliPath, rewritten.value);
+
+		if (isErr(written)) {
+			return written;
+		}
+
+		return ok({ cliPath, apiModuleSpecifier: bindings.value.moduleSpecifier });
+	}
+
+	/**
+	 * Swap the worker-pool proxy for the in-process shim.
+	 *
+	 * @param cliSource - The contents of oxfmt's `cli.js`.
+	 * @param bindings - Where the API functions live and what they are exported as.
+	 * @param cliPath - Where the CLI came from, for error reporting.
+	 * @returns The rewritten CLI, or the reason it could not be rewritten safely.
+	 */
+	static #rewrite(cliSource: string, bindings: ApiBindings, cliPath: string): Result<string, CliAlreadyPatched | CliAnchorMissing | CliPatchIncomplete> {
+		if (cliSource.includes(SHIM_MARKER)) {
+			return err(new CliAlreadyPatched(cliPath));
+		}
+
+		for (const anchor of ANCHORS) {
+			if (!cliSource.includes(anchor)) {
+				return err(new CliAnchorMissing(anchor, cliPath));
+			}
+		}
+
+		const imported = cliSource.replace(TINYPOOL_IMPORT, ShimSource.importStatement(bindings));
+
+		if (!WORKER_PROXY_REGION.test(imported)) {
+			return err(new CliAnchorMissing('the worker-proxy region', cliPath));
+		}
+
+		const patched = imported.replace(WORKER_PROXY_REGION, ShimSource.workerProxyRegion());
+
+		for (const residue of RESIDUE) {
+			if (patched.includes(residue)) {
+				return err(new CliPatchIncomplete(residue, cliPath));
+			}
+		}
+
+		return ok(patched);
+	}
+}
diff --git a/infra/scripts/release/oxfmt-inprocess/errors.ts b/infra/scripts/release/oxfmt-inprocess/errors.ts
new file mode 100644
index 0000000..c73937d
--- /dev/null
+++ b/infra/scripts/release/oxfmt-inprocess/errors.ts
@@ -0,0 +1,133 @@
+/**
+ * Typed failures raised while rewriting oxfmt's CLI.
+ *
+ * Every failure here means the same thing operationally: oxfmt's internals no
+ * longer match what the rewrite assumes, so the release must stop rather than
+ * ship a half-patched CLI that hangs at runtime. Each error therefore carries
+ * the exact anchor/path it was looking for, so a version bump reports what to
+ * re-derive instead of a bare stack trace.
+ */
+
+/** A file the rewrite depends on could not be read. */
+export class OxfmtFileUnreadable extends Error {
+	readonly _tag = 'OxfmtFileUnreadable';
+	readonly path: string;
+	override readonly cause: unknown;
+
+	/**
+	 * @param path - The file that could not be read.
+	 * @param cause - The underlying filesystem error.
+	 */
+	constructor(path: string, cause: unknown) {
+		super(`cannot read ${path}`);
+
+		this.path = path;
+		this.cause = cause;
+	}
+}
+
+/** The rewritten CLI could not be written back. */
+export class OxfmtFileUnwritable extends Error {
+	readonly _tag = 'OxfmtFileUnwritable';
+	readonly path: string;
+	override readonly cause: unknown;
+
+	/**
+	 * @param path - The file that could not be written.
+	 * @param cause - The underlying filesystem error.
+	 */
+	constructor(path: string, cause: unknown) {
+		super(`cannot write ${path}`);
+
+		this.path = path;
+		this.cause = cause;
+	}
+}
+
+/** The worker entry no longer carries a recognisable API import. */
+export class WorkerImportUnrecognised extends Error {
+	readonly _tag = 'WorkerImportUnrecognised';
+	readonly path: string;
+	readonly detail: string;
+
+	/**
+	 * @param path - The worker entry that was parsed.
+	 * @param detail - What about the import could not be read.
+	 */
+	constructor(path: string, detail: string) {
+		super(`${detail} in ${path}`);
+
+		this.path = path;
+		this.detail = detail;
+	}
+}
+
+/** The worker entry no longer re-exports a function the shim delegates to. */
+export class ApiExportMissing extends Error {
+	readonly _tag = 'ApiExportMissing';
+	readonly role: string;
+	readonly path: string;
+
+	/**
+	 * @param role - The function the shim expected to find.
+	 * @param path - The worker entry that was parsed.
+	 */
+	constructor(role: string, path: string) {
+		super(`worker entry ${path} no longer exports "${role}"`);
+
+		this.role = role;
+		this.path = path;
+	}
+}
+
+/** oxfmt's CLI no longer contains a structure the rewrite edits. */
+export class CliAnchorMissing extends Error {
+	readonly _tag = 'CliAnchorMissing';
+	readonly anchor: string;
+	readonly path: string;
+
+	/**
+	 * @param anchor - The source fragment that was expected.
+	 * @param path - The CLI file that was searched.
+	 */
+	constructor(anchor: string, path: string) {
+		super(`anchor not found in ${path}: ${anchor}`);
+
+		this.anchor = anchor;
+		this.path = path;
+	}
+}
+
+/** oxfmt's CLI already carries the in-process shim. */
+export class CliAlreadyPatched extends Error {
+	readonly _tag = 'CliAlreadyPatched';
+	readonly path: string;
+
+	/** @param path - The CLI file that was already rewritten. */
+	constructor(path: string) {
+		super(`${path} is already patched`);
+
+		this.path = path;
+	}
+}
+
+/** The rewrite left worker-pool code behind, so the result cannot be trusted. */
+export class CliPatchIncomplete extends Error {
+	readonly _tag = 'CliPatchIncomplete';
+	readonly residue: string;
+	readonly path: string;
+
+	/**
+	 * @param residue - The worker-pool fragment still present after rewriting.
+	 * @param path - The CLI file that was rewritten.
+	 */
+	constructor(residue: string, path: string) {
+		super(`residual worker-pool reference "${residue}" in ${path} after patching`);
+
+		this.residue = residue;
+		this.path = path;
+	}
+}
+
+/** Every way rewriting oxfmt's CLI is expected to fail. */
+export type OxfmtPatchError = ApiExportMissing | CliAlreadyPatched | CliAnchorMissing | CliPatchIncomplete | OxfmtFileUnreadable | OxfmtFileUnwritable | WorkerImportUnrecognised;
diff --git a/infra/scripts/release/oxfmt-inprocess/index.ts b/infra/scripts/release/oxfmt-inprocess/index.ts
new file mode 100644
index 0000000..a102e63
--- /dev/null
+++ b/infra/scripts/release/oxfmt-inprocess/index.ts
@@ -0,0 +1,16 @@
+/**
+ * Rewrites oxfmt's CLI so the release binary formats embedded code in-process
+ * instead of through a worker pool that cannot survive `bun build --compile`.
+ *
+ * See `OxfmtCliPatcher` for the failure this exists to prevent.
+ */
+export { ApiBindings } from '#oxfmt-inprocess/api-bindings';
+export { OxfmtCliPatcher } from '#oxfmt-inprocess/cli-patcher';
+export type { PatchOutcome } from '#oxfmt-inprocess/cli-patcher';
+export { ApiExportMissing, CliAlreadyPatched, CliAnchorMissing, CliPatchIncomplete, OxfmtFileUnreadable, OxfmtFileUnwritable, WorkerImportUnrecognised } from '#oxfmt-inprocess/errors';
+export type { OxfmtPatchError } from '#oxfmt-inprocess/errors';
+export { err, isErr, ok } from '#oxfmt-inprocess/result';
+export type { Result } from '#oxfmt-inprocess/result';
+export { SHIM_MARKER, ShimSource } from '#oxfmt-inprocess/shim-source';
+export { NodeTextFiles } from '#oxfmt-inprocess/text-files';
+export type { TextFiles } from '#oxfmt-inprocess/text-files';
diff --git a/infra/scripts/release/oxfmt-inprocess/result.ts b/infra/scripts/release/oxfmt-inprocess/result.ts
new file mode 100644
index 0000000..94590af
--- /dev/null
+++ b/infra/scripts/release/oxfmt-inprocess/result.ts
@@ -0,0 +1,43 @@
+/**
+ * The Result vocabulary this slice reports expected failures with.
+ *
+ * `Result` is a value type discriminating on a tag, so its helpers stay
+ * functional by design rather than being wrapped in a class.
+ */
+
+/** A computed value that is either a success or a typed failure. */
+export type Result<T, E extends Error> = { readonly _tag: 'ok'; readonly value: T } | { readonly _tag: 'err'; readonly error: E };
+
+/**
+ * Wrap a value as a success.
+ *
+ * @template T - The success type.
+ * @param value - The value to wrap.
+ * @returns A successful result carrying `value`.
+ */
+export function ok<T>(value: T): Result<T, never> {
+	return { _tag: 'ok', value };
+}
+
+/**
+ * Wrap an error as a failure.
+ *
+ * @template E - The error type.
+ * @param error - The error to wrap.
+ * @returns A failed result carrying `error`.
+ */
+export function err<E extends Error>(error: E): Result<never, E> {
+	return { _tag: 'err', error };
+}
+
+/**
+ * Narrow a result to its failure branch.
+ *
+ * @template T - The success type.
+ * @template E - The error type.
+ * @param result - The result to inspect.
+ * @returns `true` when the result is a failure, narrowing `result.error`.
+ */
+export function isErr<T, E extends Error>(result: Result<T, E>): result is { readonly _tag: 'err'; readonly error: E } {
+	return result._tag === 'err';
+}
diff --git a/infra/scripts/release/oxfmt-inprocess/shim-source.ts b/infra/scripts/release/oxfmt-inprocess/shim-source.ts
new file mode 100644
index 0000000..aafdfe7
--- /dev/null
+++ b/infra/scripts/release/oxfmt-inprocess/shim-source.ts
@@ -0,0 +1,65 @@
+import type { ApiBindings } from '#oxfmt-inprocess/api-bindings';
+
+/** Marks a rewritten CLI, so a second run is reported rather than nested. */
+export const SHIM_MARKER = 'fmtkit: in-process external formatter';
+
+/**
+ * Renders the source that replaces oxfmt's worker-pool proxy.
+ *
+ * The generated code keeps the original function names and their
+ * Promise-returning contract, so the rest of oxfmt's CLI — the `runCli` wiring
+ * that receives these as callbacks, and the `disposeExternalFormatter` call on
+ * the way out — is left untouched.
+ */
+export class ShimSource {
+	private constructor() {}
+
+	/**
+	 * Render the import that replaces oxfmt's `tinypool` import.
+	 *
+	 * @param bindings - Where the API functions live and what they are exported as.
+	 * @returns An import statement binding the four API functions to shim-local names.
+	 */
+	static importStatement(bindings: ApiBindings): string {
+		const named = [
+			`${bindings.formatFile} as __fmtkitFormatFile`,
+			`${bindings.formatEmbeddedCode} as __fmtkitFormatEmbeddedCode`,
+			`${bindings.formatEmbeddedDoc} as __fmtkitFormatEmbeddedDoc`,
+			`${bindings.sortTailwindClasses} as __fmtkitSortTailwindClasses`,
+		].join(', ');
+
+		return `import { ${named} } from "${bindings.moduleSpecifier}";`;
+	}
+
+	/**
+	 * Render the replacement for oxfmt's `worker-proxy` region.
+	 *
+	 * The API functions are `async`, so calling one returns a Promise — exactly
+	 * what `pool.run()` returned before. That Promise is handed to
+	 * `toFormatFileResult`/`toNullable` unawaited on purpose: those helpers are
+	 * `run.then(...)`/`run.catch(...)` wrappers, so they need the Promise itself.
+	 * Awaiting first would pass a plain value, break on `run.then is not a
+	 * function`, and let rejections escape instead of becoming `{ ok: false }` /
+	 * `null`.
+	 *
+	 * @returns The `worker-proxy` region, formatting embedded code in-process.
+	 */
+	static workerProxyRegion(): string {
+		return `//#region src-js/cli/worker-proxy.ts (${SHIM_MARKER} — see infra/scripts/release/oxfmt-inprocess)
+async function initExternalFormatter(numThreads) {}
+async function disposeExternalFormatter() {}
+function formatFile(options, code) {
+	return toFormatFileResult(__fmtkitFormatFile({ options, code }));
+}
+function formatEmbeddedCode(options, code) {
+	return toNullable(__fmtkitFormatEmbeddedCode({ options, code }));
+}
+function formatEmbeddedDoc(options, texts) {
+	return toNullable(__fmtkitFormatEmbeddedDoc({ options, texts }));
+}
+function sortTailwindClasses(options, classes) {
+	return toNullable(__fmtkitSortTailwindClasses({ options, classes }));
+}
+//#endregion`;
+	}
+}
diff --git a/infra/scripts/release/oxfmt-inprocess/text-files.ts b/infra/scripts/release/oxfmt-inprocess/text-files.ts
new file mode 100644
index 0000000..0341888
--- /dev/null
+++ b/infra/scripts/release/oxfmt-inprocess/text-files.ts
@@ -0,0 +1,63 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { OxfmtFileUnreadable, OxfmtFileUnwritable } from '#oxfmt-inprocess/errors';
+import { err, ok } from '#oxfmt-inprocess/result';
+import type { Result } from '#oxfmt-inprocess/result';
+
+/**
+ * The whole filesystem surface the rewrite needs.
+ *
+ * Kept this narrow so the patcher can be driven by an in-memory fake; the
+ * concrete adapter is free to be wider.
+ */
+export type TextFiles = {
+	/**
+	 * Read a UTF-8 file.
+	 *
+	 * @param path - The file to read.
+	 * @returns The file contents, or `OxfmtFileUnreadable` when it cannot be read.
+	 */
+	readText(path: string): Result<string, OxfmtFileUnreadable>;
+
+	/**
+	 * Overwrite a UTF-8 file.
+	 *
+	 * @param path - The file to write.
+	 * @param contents - The contents to write.
+	 * @returns Nothing, or `OxfmtFileUnwritable` when it cannot be written.
+	 */
+	writeText(path: string, contents: string): Result<void, OxfmtFileUnwritable>;
+};
+
+/** Reads and writes through the real filesystem. */
+export class NodeTextFiles implements TextFiles {
+	/**
+	 * Read a UTF-8 file from disk.
+	 *
+	 * @param path - The file to read.
+	 * @returns The file contents, or `OxfmtFileUnreadable` when it cannot be read.
+	 */
+	readText(path: string): Result<string, OxfmtFileUnreadable> {
+		try {
+			return ok(readFileSync(path, 'utf8'));
+		} catch (cause) {
+			return err(new OxfmtFileUnreadable(path, cause));
+		}
+	}
+
+	/**
+	 * Write a UTF-8 file to disk, replacing any existing contents.
+	 *
+	 * @param path - The file to write.
+	 * @param contents - The contents to write.
+	 * @returns Nothing, or `OxfmtFileUnwritable` when it cannot be written.
+	 */
+	writeText(path: string, contents: string): Result<void, OxfmtFileUnwritable> {
+		try {
+			writeFileSync(path, contents);
+
+			return ok(undefined);
+		} catch (cause) {
+			return err(new OxfmtFileUnwritable(path, cause));
+		}
+	}
+}
diff --git a/infra/scripts/release/package.json b/infra/scripts/release/package.json
new file mode 100644
index 0000000..ae0cc2b
--- /dev/null
+++ b/infra/scripts/release/package.json
@@ -0,0 +1,12 @@
+{
+	"type": "module",
+	"imports": {
+		"#oxfmt-inprocess": "./oxfmt-inprocess/index.ts",
+		"#oxfmt-inprocess/api-bindings": "./oxfmt-inprocess/api-bindings.ts",
+		"#oxfmt-inprocess/cli-patcher": "./oxfmt-inprocess/cli-patcher.ts",
+		"#oxfmt-inprocess/errors": "./oxfmt-inprocess/errors.ts",
+		"#oxfmt-inprocess/result": "./oxfmt-inprocess/result.ts",
+		"#oxfmt-inprocess/shim-source": "./oxfmt-inprocess/shim-source.ts",
+		"#oxfmt-inprocess/text-files": "./oxfmt-inprocess/text-files.ts"
+	}
+}
diff --git a/infra/scripts/release/patch-oxfmt-inprocess.ts b/infra/scripts/release/patch-oxfmt-inprocess.ts
new file mode 100644
index 0000000..ee560b9
--- /dev/null
+++ b/infra/scripts/release/patch-oxfmt-inprocess.ts
@@ -0,0 +1,28 @@
+/**
+ * Rewrites oxfmt to format embedded code in-process, so the `bun build
+ * --compile` binary stops hanging on Vue/markdown/HTML files. Invoked by
+ * stage-ts-assets.sh between installing oxfmt and bundling it; see
+ * `OxfmtCliPatcher` for why the rewrite exists.
+ *
+ * usage: node patch-oxfmt-inprocess.ts <path/to/oxfmt/dist>
+ */
+import { NodeTextFiles, OxfmtCliPatcher, isErr } from '#oxfmt-inprocess';
+
+const NAME = 'patch-oxfmt-inprocess';
+const USAGE_EXIT_CODE = 2;
+
+const distDir = process.argv[2];
+
+if (distDir === undefined || distDir.length === 0) {
+	process.stderr.write(`usage: node ${NAME}.ts <path/to/oxfmt/dist>\n`);
+	process.exit(USAGE_EXIT_CODE);
+}
+
+const patched = new OxfmtCliPatcher(new NodeTextFiles()).patch(distDir);
+
+if (isErr(patched)) {
+	process.stderr.write(`${NAME}: ${patched.error.message}\n`);
+	process.exit(1);
+}
+
+process.stderr.write(`${NAME}: rewrote ${patched.value.cliPath} to format embedded code in-process (api module: ${patched.value.apiModuleSpecifier})\n`);
diff --git a/infra/scripts/release/stage-ts-assets.sh b/infra/scripts/release/stage-ts-assets.sh
index 3c4ac38..4bdbebd 100755
--- a/infra/scripts/release/stage-ts-assets.sh
+++ b/infra/scripts/release/stage-ts-assets.sh
@@ -119,6 +119,14 @@ cp "${root}/packages/devx/scripts/package.json" "${workdir}/scripts/package.json
 		"oxc-parser@${oxc_parser_pin}" >/dev/null
 )
 
+# oxfmt formats embedded code (Vue <template>/<style>, markdown, HTML) through a
+# Tinypool child_process pool whose worker entry scripts do not survive
+# `bun build --compile` (they resolve to non-existent /$bunfs/root/ paths), which
+# hangs the binary on any such file. Rewrite oxfmt to do that work in-process
+# before it is bundled. See infra/scripts/release/oxfmt-inprocess for the full
+# rationale. Run by node directly (type stripping) so staging needs no tsx.
+node "${root}/infra/scripts/release/patch-oxfmt-inprocess.ts" "${workdir}/node_modules/oxfmt/dist"
+
 # The napi bindings stay external: every target loads them from files staged
 # next to the sidecar through NAPI_RS_NATIVE_LIBRARY_PATH, which keeps the JS
 # bundle platform-independent. oxfmt's optional prettier plugins are external
diff --git a/infra/scripts/tasks/test-binary-smoke.sh b/infra/scripts/tasks/test-binary-smoke.sh
index e39d57f..d8b6794 100755
--- a/infra/scripts/tasks/test-binary-smoke.sh
+++ b/infra/scripts/tasks/test-binary-smoke.sh
@@ -40,11 +40,19 @@ printf 'const  a = { x:1, s:"hi" }\nexport default a\n' > app.ts
 printf 'package p\n\nfunc f() {\n\tdefer println("d")\n\treturn\n}\n' > app.go
 printf 'module fixture\n\ngo 1.26.4\n' > go.mod
 
+# The Vue SFC is the embedded-formatter probe: its <template> and <style> blocks
+# are formatted by oxfmt's external (prettier) formatter, the code path that a
+# bun-compiled binary must run in-process (see stage-ts-assets.sh). If that path
+# regresses, `format` hangs on this file instead of completing — which is exactly
+# the failure this fixture guards against.
+printf '<script setup lang="ts">\nconst  a = { x:1, s:"hi" }\n</script>\n\n<template>\n<div><p>{{ a.s }}</p></div>\n</template>\n\n<style scoped>\n.box{color:red;padding:0}\n</style>\n' > app.vue
+
 XDG_CACHE_HOME="${tmp_root}/cache" "$bin" version
 XDG_CACHE_HOME="${tmp_root}/cache" "$bin" format .
 
 expected_ts=$'const a = { x: 1, s: \'hi\' };\n\nexport default a;\n'
 expected_go=$'package p\n\nfunc f() {\n\tdefer println("d")\n\n\treturn\n}\n'
+expected_vue=$'<script setup lang="ts">\nconst a = { x: 1, s: \'hi\' };\n</script>\n\n<template>\n\t<div>\n\t\t<p>{{ a.s }}</p>\n\t</div>\n</template>\n\n<style scoped>\n.box {\n\tcolor: red;\n\tpadding: 0;\n}\n</style>\n'
 
 if ! diff <(printf '%s' "$expected_ts") app.ts; then
 	printf 'app.ts was not formatted as expected\n' >&2
@@ -56,4 +64,9 @@ if ! diff <(printf '%s' "$expected_go") app.go; then
 	exit 1
 fi
 
+if ! diff <(printf '%s' "$expected_vue") app.vue; then
+	printf 'app.vue was not formatted as expected (embedded formatter regression?)\n' >&2
+	exit 1
+fi
+
 printf 'binary smoke test passed\n'