@playola-radio/slipstream 0.1.0

package/dist/swift-interface-extract.js

@@ -0,0 +1,344 @@
+/** Swift syntax extraction. Call only in the pinned --liftoff-only child. */
+import { Parser } from 'web-tree-sitter';
+import { buildUtf16ToByteTable, utf16RangeToByteRange } from "./swift-spans.js";
+export const SWIFT_V1 = {
+    language: 'swift', languageVersion: 'swift.v1', extensions: ['.swift'],
+    exclusions: [
+        'anonymous closures', 'local functions', 'nested functions', 'accessors', 'subscripts',
+        'macro-generated declarations', 'deinitializers', 'shared type propagation', 'effects', 'behavior',
+        'typed throws (pinned grammar reports ERROR)',
+    ],
+};
+class Unsupported extends Error {
+}
+class TooLarge extends Error {
+    limit;
+    constructor(limit) { super(limit); this.limit = limit; }
+}
+function children(node) { return node.children.filter((child) => child !== null); }
+function named(node) { return node.namedChildren.filter((child) => child !== null); }
+function field(node, child) {
+    for (let i = 0; i < node.childCount; i++)
+        if (node.child(i)?.id === child.id)
+            return node.fieldNameForChild(i);
+    return null;
+}
+function direct(node, type) { return children(node).find((child) => child.type === type); }
+function tokens(node, source) {
+    const result = [];
+    const pending = [node];
+    while (pending.length) {
+        const current = pending.pop();
+        if (current.type === 'comment' || current.type === 'multiline_comment')
+            continue;
+        if (current.type.includes('string_literal') || current.type === 'regex_literal' || current.childCount === 0) {
+            result.push(source.slice(current.startIndex, current.endIndex));
+            continue;
+        }
+        const parts = children(current);
+        for (let i = parts.length - 1; i >= 0; i--)
+            pending.push(parts[i]);
+    }
+    return result;
+}
+/** Canonical token rendering: trivia is discarded, literal contents are atomic. */
+function renderTokens(ts) {
+    let result = '';
+    for (let i = 0; i < ts.length; i++) {
+        const t = ts[i];
+        const previous = ts[i - 1];
+        const word = (s) => /[\p{L}\p{N}_$]$/u.test(s);
+        const startsWord = (s) => /^[\p{L}\p{N}_$]/u.test(s);
+        const operator = (s) => /^[&|+*/%=~^-]+$/.test(s);
+        const punctuation = (s) => /^[!$%&*+./:<=>?@^|~-]+$/.test(s);
+        const gap = previous !== undefined && ((word(previous) && startsWord(t)) || previous === ':' || previous === ',' ||
+            previous === '->' || t === '->' || operator(previous) || operator(t) ||
+            (punctuation(previous) && punctuation(t)));
+        if (gap)
+            result += ' ';
+        result += t;
+    }
+    return result;
+}
+function normalized(node, source) { return renderTokens(tokens(node, source)); }
+function identifier(node, source) {
+    const written = normalized(node, source);
+    return written.startsWith('`') && written.endsWith('`') ? written.slice(1, -1) : written;
+}
+function writtenType(parts, source, parameter) {
+    const syntax = parts.filter((c) => c.type !== 'comment' && c.type !== 'multiline_comment' &&
+        !(parameter && (c.type === 'parameter_modifiers' || c.type === '...')));
+    const types = syntax.filter((c) => c.isNamed);
+    if (types.length < 1 || types.length > 2 ||
+        (types.length === 2 && types[0].type !== 'type_modifiers') ||
+        types.at(-1).type === 'type_modifiers')
+        throw new Unsupported('type without representable syntax');
+    const suffix = syntax.filter((c) => !c.isNamed);
+    if (suffix.length > 1 || (suffix.length === 1 &&
+        (suffix[0].type !== '!' || syntax.at(-1) !== suffix[0])))
+        throw new Unsupported('unrepresented type suffix');
+    return types.map((c) => normalized(c, source)).join(' ') + (suffix.length ? '!' : '');
+}
+/** The pinned grammar exposes a #if directive as one opaque leaf, so scan its
+ * condition into tokens without treating comments or spacing as identity. */
+function guardCondition(raw) {
+    const result = [];
+    let i = 0;
+    while (i < raw.length) {
+        if (/\s/u.test(raw[i])) {
+            i++;
+            continue;
+        }
+        if (raw.startsWith('//', i))
+            break;
+        if (raw.startsWith('/*', i)) {
+            let depth = 1;
+            i += 2;
+            while (i < raw.length && depth) {
+                if (raw.startsWith('/*', i)) {
+                    depth++;
+                    i += 2;
+                }
+                else if (raw.startsWith('*/', i)) {
+                    depth--;
+                    i += 2;
+                }
+                else
+                    i++;
+            }
+            if (depth)
+                throw new Unsupported('unclosed directive comment');
+            continue;
+        }
+        const start = i;
+        const c = raw[i];
+        if (c === '"') {
+            i++;
+            while (i < raw.length) {
+                if (raw[i] === '\\') {
+                    i += 2;
+                    continue;
+                }
+                if (raw[i++] === '"')
+                    break;
+            }
+        }
+        else if (/[\p{L}\p{N}_]/u.test(c)) {
+            i++;
+            while (i < raw.length && /[\p{L}\p{N}_]/u.test(raw[i]))
+                i++;
+        }
+        else if (/[!$%&*+./:<=>?@^|~-]/.test(c)) {
+            i++;
+            while (i < raw.length && /[!$%&*+./:<=>?@^|~-]/.test(raw[i]))
+                i++;
+        }
+        else
+            i++;
+        result.push(raw.slice(start, i));
+    }
+    return renderTokens(result);
+}
+function parameter(node, source, position, attributes, defaultNode) {
+    const parts = children(node);
+    const names = parts.filter((c) => c.type === 'simple_identifier');
+    const external = parts.find((c) => field(node, c) === 'external_name');
+    const local = names.find((c) => c !== external);
+    if (!local)
+        throw new Unsupported('parameter without local name');
+    const colon = parts.findIndex((c) => c.type === ':');
+    if (colon < 0)
+        throw new Unsupported('parameter without type');
+    const type = writtenType(parts.slice(colon + 1), source, true);
+    const modifierNode = direct(node, 'parameter_modifiers');
+    const modifiers = [
+        ...attributes.map((attribute) => normalized(attribute, source)),
+        ...(modifierNode ? named(modifierNode).map((c) => normalized(c, source)) : []),
+    ];
+    const name = identifier(local, source);
+    return {
+        position, label: external ? identifier(external, source) : null, name,
+        binding: name === '_' ? 'wildcard' : 'identifier',
+        type: { state: 'written', text: type },
+        optional: false, variadic: Boolean(direct(node, '...')),
+        default: defaultNode ? normalized(defaultNode, source) : null,
+        modifiers,
+    };
+}
+function scopeKind(node) {
+    if (node.type === 'protocol_declaration')
+        return 'protocol';
+    const kind = children(node).find((c) => ['class', 'struct', 'enum', 'extension', 'actor'].includes(c.type));
+    if (!kind)
+        throw new Unsupported('unknown type scope');
+    return kind.type;
+}
+function declaration(node, source, table, scope, guards) {
+    const parts = children(node);
+    const isInit = node.type === 'init_declaration';
+    const nameNode = parts.find((c) => field(node, c) === 'name' &&
+        (c.type === 'simple_identifier' || c.type === 'init'));
+    if (!nameNode && !isInit)
+        throw new Unsupported('function without representable name');
+    const name = isInit ? 'init' : identifier(nameNode, source);
+    const params = [];
+    const pendingAttributes = [];
+    let withinParameters = false;
+    for (let i = 0; i < parts.length; i++) {
+        const child = parts[i];
+        if (child.type === '(' && !withinParameters) {
+            withinParameters = true;
+            continue;
+        }
+        if (child.type === ')' && withinParameters) {
+            if (pendingAttributes.length)
+                throw new Unsupported('parameter attribute without parameter');
+            withinParameters = false;
+            continue;
+        }
+        if (child.type === 'attribute' && withinParameters) {
+            pendingAttributes.push(child);
+            continue;
+        }
+        if (child.type === 'parameter') {
+            const next = parts[i + 1];
+            const defaultNode = next?.type === '=' ? parts[i + 2] : undefined;
+            params.push(parameter(child, source, params.length, pendingAttributes, defaultNode));
+            pendingAttributes.length = 0;
+        }
+    }
+    const arrow = parts.findIndex((c) => c.type === '->');
+    const endOfReturn = arrow < 0 ? -1 : parts.findIndex((c, i) => i > arrow &&
+        (c.type === 'type_constraints' || c.type === 'function_body'));
+    const returnType = arrow < 0 ? null : writtenType(parts.slice(arrow + 1, endOfReturn < 0 ? undefined : endOfReturn), source, false);
+    const failableNode = isInit ? parts.find((c) => c.type === '?' || c.type === '!' || c.type === 'bang') : undefined;
+    const failable = failableNode?.type === 'bang' ? '!' : failableNode?.type;
+    const result = isInit ? { kind: 'initializer', failable: failable ?? null } :
+        { kind: 'return', type: returnType !== null ? { state: 'written', text: returnType } :
+                { state: 'implicit', text: 'Void' } };
+    const throwsNode = direct(node, 'throws');
+    const throws = { mode: throwsNode?.text === 'rethrows' ? 'rethrows' : throwsNode ? 'throws' : 'none' };
+    const modifierNode = direct(node, 'modifiers');
+    const genericNode = direct(node, 'type_parameters');
+    const constraintNode = direct(node, 'type_constraints');
+    const header = {
+        modifiers: [
+            ...(modifierNode ? children(modifierNode).map((c) => normalized(c, source)) : []),
+            ...parts.filter((c) => c.type === 'class' || c.type === 'static').map((c) => normalized(c, source)),
+            ...parts.filter((c) => c.type === 'async').map((c) => normalized(c, source)),
+        ],
+        generic_parameters: genericNode ? named(genericNode).filter((c) => c.type === 'type_parameter').map((c) => normalized(c, source)) : [],
+        constraints: constraintNode ? named(constraintNode).filter((c) => c.type === 'type_constraint').map((c) => normalized(c, source)) : [],
+    };
+    const labels = params.map((p) => `${p.label ?? p.name}:`).join('');
+    const displayName = `${scope.length ? `${scope.map((s) => s.name).join('.')}.` : ''}${name}(${labels})`;
+    const identity = { kind: isInit ? 'initializer' : scope.length ? 'method' : 'function', scope, name, guards };
+    // The grammar omits an optional protocol requirement semicolon from the node.
+    // It is still part of the written declaration's source reference.
+    const trailing = /^[ \t]*;/.exec(source.slice(node.endIndex));
+    const span = utf16RangeToByteRange(table, node.startIndex, node.endIndex + (trailing?.[0].length ?? 0));
+    return {
+        identity, displayName, span,
+        signature: JSON.stringify([params.map(({ position: _position, ...p }) => p), result, throws, header]),
+        parameters: params, result, throws, header,
+    };
+}
+/** One whole-file parse; any ERROR/MISSING or eligible unsupported syntax refuses all rows. */
+export function extractSwiftSource(language, source, limits = {}) {
+    const table = buildUtf16ToByteTable(source);
+    if (limits.inputBytes !== undefined && table.bytes[table.length] > limits.inputBytes)
+        return { status: 'tooLarge', limit: 'inputBytes' };
+    const parser = new Parser();
+    let tree = null;
+    try {
+        parser.setLanguage(language);
+        tree = parser.parse(source);
+        if (!tree)
+            throw new Error('Swift parser returned no tree');
+        if (tree.rootNode.hasError)
+            return { status: 'incomplete', reason: 'parse-error' };
+        let syntaxVisits = 0;
+        const stack = [tree.rootNode];
+        let malformed = false;
+        while (stack.length) {
+            const node = stack.pop();
+            syntaxVisits++;
+            if (limits.syntaxVisits !== undefined && syntaxVisits > limits.syntaxVisits)
+                throw new TooLarge('syntaxVisits');
+            if (node.isError || node.isMissing)
+                malformed = true;
+            for (let i = node.childCount - 1; i >= 0; i--) {
+                const child = node.child(i);
+                if (child)
+                    stack.push(child);
+            }
+        }
+        if (malformed || tree.rootNode.hasError)
+            return { status: 'incomplete', reason: 'parse-error' };
+        const declarations = [];
+        const visit = (container, scope, guards) => {
+            const frames = [];
+            for (const child of named(container)) {
+                if (child.type === 'directive') {
+                    const text = child.text.trim();
+                    const match = /^#(if|elseif|else|endif)\b(?:\s+([\s\S]*))?$/.exec(text);
+                    if (!match)
+                        continue; // Nonconditional directives do not change identity.
+                    const condition = match[2] === undefined ? undefined : guardCondition(match[2]);
+                    if (match[1] === 'if') {
+                        if (!condition)
+                            throw new Unsupported('empty if');
+                        frames.push({ prior: [condition], active: condition });
+                    }
+                    else if (match[1] === 'endif') {
+                        if (!frames.pop())
+                            throw new Unsupported('unmatched endif');
+                    }
+                    else {
+                        const frame = frames.at(-1);
+                        if (!frame)
+                            throw new Unsupported('unmatched conditional');
+                        const prior = frame.prior.map((c) => `!(${c})`).join(' && ');
+                        if (match[1] === 'elseif' && !condition)
+                            throw new Unsupported('empty elseif');
+                        frame.active = match[1] === 'else' ? prior : `${prior} && (${condition})`;
+                        if (match[1] === 'elseif')
+                            frame.prior.push(condition);
+                    }
+                    continue;
+                }
+                const activeGuards = [...guards, ...frames.map((f) => f.active)];
+                if (['function_declaration', 'protocol_function_declaration', 'init_declaration'].includes(child.type)) {
+                    declarations.push(declaration(child, source, table, scope, activeGuards));
+                    if (limits.declarations !== undefined && declarations.length > limits.declarations)
+                        throw new TooLarge('declarations');
+                }
+                else if (child.type === 'class_declaration' || child.type === 'protocol_declaration') {
+                    const kind = scopeKind(child);
+                    if (kind === 'extension' && direct(child, 'type_constraints'))
+                        throw new Unsupported('constrained extension scope');
+                    const nameNode = children(child).find((c) => field(child, c) === 'name');
+                    const body = children(child).find((c) => field(child, c) === 'body');
+                    if (!nameNode || !body)
+                        throw new Unsupported('type scope without name or body');
+                    visit(body, [...scope, { kind, name: identifier(nameNode, source) }], activeGuards);
+                }
+            }
+            if (frames.length)
+                throw new Unsupported('unclosed if');
+        };
+        visit(tree.rootNode, [], []);
+        return { status: 'complete', declarations };
+    }
+    catch (error) {
+        if (error instanceof TooLarge)
+            return { status: 'tooLarge', limit: error.limit };
+        if (error instanceof Unsupported)
+            return { status: 'incomplete', reason: 'unsupported-construct' };
+        throw error;
+    }
+    finally {
+        tree?.delete();
+        parser.delete();
+    }
+}

package/dist/swift-interface.js

@@ -0,0 +1,62 @@
+/** FD2 parent API. Grammar loading/parsing stays in the liftoff-only child. */
+import { runSwiftParseChild, SwiftChildError } from "./swift-parse.js";
+import { SWIFT_V1 } from "./swift-interface-extract.js";
+import { emitProjectionTrace } from "./projection-trace.js";
+export { SWIFT_V1 };
+export class SwiftExtractCancelled extends Error {
+}
+export class SwiftExtractTimeout extends Error {
+}
+/** Batch sides into one isolated child invocation. Callers may pass absent sides as no entry. */
+export async function extractSwiftSides(sides, options = {}) {
+    if (options.signal?.aborted)
+        throw new SwiftExtractCancelled('Swift extraction aborted before start');
+    const ids = new Set();
+    const decoded = [];
+    const failures = new Map();
+    for (const { id, bytes } of sides) {
+        if (ids.has(id))
+            throw new Error(`duplicate Swift side id: ${id}`);
+        ids.add(id);
+        if (options.limits?.inputBytes !== undefined && bytes.byteLength > options.limits.inputBytes) {
+            failures.set(id, { status: 'tooLarge', limit: 'inputBytes' });
+            continue;
+        }
+        try {
+            const source = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes);
+            decoded.push({ id, source });
+        }
+        catch {
+            failures.set(id, { status: 'incomplete', reason: 'parse-error' });
+        }
+    }
+    if (!decoded.length)
+        return failures;
+    if (options.trace && options.traceUnitId !== undefined)
+        emitProjectionTrace(options.trace, { kind: 'parser-request', unitId: options.traceUnitId, atNs: process.hrtime.bigint() });
+    try {
+        const result = await runSwiftParseChild({ op: 'extract', sides: decoded, limits: options.limits,
+            ...(options.trace ? { traceTimings: true } : {}) }, { signal: options.signal, deadlineMs: options.deadlineMs, trace: options.trace, traceUnitId: options.traceUnitId });
+        if (result.op !== 'extract')
+            throw new Error('Swift child returned unexpected operation');
+        if (options.trace && result.traceTimings
+            && Number.isSafeInteger(result.traceTimings.grammarLoadNs) && result.traceTimings.grammarLoadNs >= 0
+            && Number.isSafeInteger(result.traceTimings.parseCompareNs) && result.traceTimings.parseCompareNs >= 0) {
+            const atNs = process.hrtime.bigint();
+            emitProjectionTrace(options.trace, { kind: 'phase', scope: 'swift', phase: 'grammar-load', atNs,
+                durationNs: BigInt(result.traceTimings.grammarLoadNs), unitId: options.traceUnitId });
+            emitProjectionTrace(options.trace, { kind: 'phase', scope: 'swift', phase: 'parse-compare', atNs,
+                durationNs: BigInt(result.traceTimings.parseCompareNs), unitId: options.traceUnitId });
+        }
+        for (const { id, side } of result.results)
+            failures.set(id, side);
+        return failures;
+    }
+    catch (error) {
+        if (error instanceof SwiftChildError && /aborted/.test(error.message))
+            throw new SwiftExtractCancelled(error.message);
+        if (error instanceof SwiftChildError && /deadline/.test(error.message))
+            throw new SwiftExtractTimeout(error.message);
+        throw error;
+    }
+}

package/dist/swift-parse-host.js

@@ -0,0 +1,174 @@
+/**
+ * The isolated feasibility child: the ONLY process that loads and parses the
+ * Swift grammar. It must be launched with `node --liftoff-only` (see
+ * src/swift-grammar.ts for why); the runner (src/swift-parse.ts) does that.
+ * It reads one JSON request on stdin, performs one operation, prints one JSON
+ * result line on stdout, and exits. Keeping every real Swift load behind this
+ * boundary means a stray default-launch parse can never abort the checker, the
+ * test runner, or the daemon.
+ */
+import { Worker } from 'node:worker_threads';
+import { siblingModuleUrl } from "./sibling-module.js";
+import { readFile } from 'node:fs/promises';
+import { isMainModule } from "./entrypoint.js";
+import { loadSwiftLanguage, parseSwiftSource } from "./swift-grammar.js";
+import { extractSwiftSource } from "./swift-interface-extract.js";
+const WORKER_URL = siblingModuleUrl('swift-parse-worker', import.meta.url);
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(chunk);
+    return new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(Buffer.concat(chunks));
+}
+async function readRequest() {
+    const [mode, path] = process.argv.slice(2).filter(arg => arg !== '--fd5-trace-startup');
+    if (mode === '--parse-file') {
+        if (path === undefined)
+            throw new Error('--parse-file requires a path');
+        return { op: 'parse', source: new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(await readFile(path)) };
+    }
+    if (mode === '--parse-stdin')
+        return { op: 'parse', source: await readStdin() };
+    return JSON.parse(await readStdin());
+}
+/** Run one Swift parse in a fresh terminable worker, resolving when the parse
+ * finishes (`done`) — or rejecting if the worker errors. Returns a `cancel`
+ * that hard-terminates the worker (a synchronous parse cannot be stopped from
+ * inside), a `started` promise that resolves when the worker is about to block
+ * in the parse, and `finished()`, which reads a shared flag the worker sets the
+ * instant the parse returns. Because the parse is synchronous, `started` can
+ * only fire immediately before it; the caller proves mid-flight cancellation by
+ * reading `finished()` (shared memory, immune to this process's event-loop
+ * scheduling), not by trusting `started` alone or by racing a `done` message. */
+export function runInWorker(source, workerUrl = WORKER_URL) {
+    const worker = new Worker(workerUrl);
+    const progress = new Int32Array(new SharedArrayBuffer(4));
+    let onStarted;
+    let rejectStarted;
+    const started = new Promise((res, reject) => { onStarted = res; rejectStarted = reject; });
+    let settled = false;
+    const fail = (err) => {
+        if (settled)
+            return;
+        settled = true;
+        rejectStarted(err);
+        rejectDone(err);
+    };
+    let rejectDone;
+    const done = new Promise((resolve, reject) => {
+        rejectDone = reject;
+        worker.on('message', (msg) => {
+            if (msg.type === 'started')
+                onStarted();
+            else if (msg.type === 'done') {
+                settled = true;
+                resolve(msg.result);
+            }
+            else
+                fail(new Error(msg.message));
+        });
+        worker.on('error', fail);
+        worker.on('exit', (code) => {
+            if (code !== 0)
+                fail(new Error(`Swift parse worker exited before completing (code=${code})`));
+        });
+    });
+    // The cancellation path intentionally does not await `done`; mark its
+    // rejection observed while preserving the promise for normal callers.
+    void done.catch(() => { });
+    worker.postMessage({ source, progress });
+    return {
+        done,
+        started,
+        finished: () => Atomics.load(progress, 0) === 1,
+        cancel: () => worker.terminate(),
+        worker,
+    };
+}
+async function main() {
+    if (process.argv.includes('--fd5-trace-startup'))
+        process.stdout.write('FD5_CHILD_READY\n');
+    const request = await readRequest();
+    if (request.op === 'cancel-demo') {
+        const first = runInWorker(request.pathologicalSource);
+        await first.started;
+        // Completion guard: a synchronous parse can only be terminated from outside,
+        // so `started` is posted just before the parse blocks the worker. Give it a
+        // beat to get into the parse, then hard-terminate and read the worker's
+        // shared progress flag AFTER teardown completes. The worker stores the flag
+        // the instant the parse returns, before any teardown, so once the thread has
+        // exited: flag set => the parse finished before it was killed; flag unset =>
+        // it was still parsing when terminated. Sampling at the teardown boundary
+        // (not before terminate) closes the check-to-terminate window — a parse that
+        // completes while the host is descheduled is observed as finished, never
+        // mis-reported as interrupted. `inProgressAtCancel:false` means the
+        // pathological input finished before the kill landed; the acceptance check
+        // treats that as a failure, never a pass. (One irreducible sub-instruction
+        // window remains: a parse that returns but is killed before its very next
+        // store executes — documented in SWIFT-GRAMMAR.md, inherent to a
+        // non-interruptible synchronous parse.)
+        await new Promise((res) => setTimeout(res, 150));
+        const t = performance.now();
+        await first.cancel();
+        const terminateMs = performance.now() - t;
+        const inProgressAtCancel = !first.finished();
+        // The runtime recovers: a replacement worker parses clean input to completion.
+        const second = runInWorker(request.cleanSource);
+        const result = await second.done;
+        await second.worker.terminate();
+        print({
+            op: 'cancel-demo',
+            startedBeforeCancel: true,
+            inProgressAtCancel,
+            terminateMs,
+            replacement: { clean: result.clean, rootType: result.rootType },
+        });
+        return 0;
+    }
+    const t0 = performance.now();
+    const loaded = await loadSwiftLanguage();
+    const initAndLoadMs = performance.now() - t0;
+    if (request.op === 'parse') {
+        const p0 = performance.now();
+        const result = parseSwiftSource(loaded.language, request.source);
+        const firstParseMs = performance.now() - p0;
+        print({ op: 'parse', provenance: loaded.provenance, result, timings: { initAndLoadMs, firstParseMs } });
+        return 0;
+    }
+    if (request.op === 'extract') {
+        const parseStarted = request.traceTimings ? performance.now() : undefined;
+        const results = request.sides.map(({ id, source }) => ({ id, side: extractSwiftSource(loaded.language, source, request.limits) }));
+        print({ op: 'extract', results,
+            ...(parseStarted === undefined ? {} : { traceTimings: {
+                    grammarLoadNs: Math.round(initAndLoadMs * 1e6),
+                    parseCompareNs: Math.round((performance.now() - parseStarted) * 1e6)
+                } }) });
+        return 0;
+    }
+    if (request.op === 'measure') {
+        const parses = request.sources.map(({ label, source }) => {
+            const f0 = performance.now();
+            const first = parseSwiftSource(loaded.language, source);
+            const firstParseMs = performance.now() - f0;
+            const w0 = performance.now();
+            parseSwiftSource(loaded.language, source);
+            const warmParseMs = performance.now() - w0;
+            return { label, byteLength: first.byteLength, clean: first.clean, firstParseMs, warmParseMs };
+        });
+        print({ op: 'measure', provenance: loaded.provenance, initAndLoadMs, parses });
+        return 0;
+    }
+    // op: 'survive' — parse, then stay alive past the observed OOM window and exit
+    // 0. A default-launch process aborts during this hold; surviving it is the
+    // load-bearing proof that --liftoff-only actually prevents the delayed crash.
+    const result = parseSwiftSource(loaded.language, request.source);
+    await new Promise((res) => setTimeout(res, request.holdMs));
+    print({ op: 'survive', result, heldMs: request.holdMs });
+    return 0;
+}
+function print(result) {
+    process.stdout.write(JSON.stringify(result) + '\n');
+}
+if (isMainModule(import.meta.url, process.argv[1] ?? '')) {
+    main().then((code) => process.stdout.write('', () => process.exit(code)), (err) => { process.stderr.write(`swift-parse-host: ${err.stack ?? err}\n`); process.exit(2); });
+}

package/dist/swift-parse-worker.js

@@ -0,0 +1,34 @@
+/**
+ * A terminable Swift-parse worker, used only to demonstrate cancellation
+ * (STAGE-T-PREREQS 3.4). It inherits `--liftoff-only` from the host that spawns
+ * it (src/swift-parse-host.ts), so it can load the grammar without aborting.
+ *
+ * Protocol: the parent posts `{ source, progress? }`; the worker posts
+ * `{ type: 'started' }` immediately before the (synchronous, blocking) parse,
+ * then — after the parse returns — writes the shared `progress` flag to 1 and
+ * posts `{ type: 'done', result }` (or `{ type: 'error', message }`). A
+ * synchronous parse cannot post mid-flight, so `started` fires just before the
+ * worker blocks; the parent proves mid-flight cancellation by reading the shared
+ * flag (which the worker sets only once the parse has actually finished, immune
+ * to the parent's event-loop scheduling), then calling `worker.terminate()` —
+ * the clip worker precedent (src/clip-worker-pool.ts).
+ */
+import { parentPort } from 'node:worker_threads';
+import { loadSwiftLanguage, parseSwiftSource } from "./swift-grammar.js";
+const port = parentPort;
+if (!port)
+    throw new Error('swift-parse-worker must run as a worker thread');
+let loaded;
+port.on('message', async (req) => {
+    try {
+        loaded ??= await loadSwiftLanguage();
+        port.postMessage({ type: 'started' });
+        const result = parseSwiftSource(loaded.language, req.source);
+        if (req.progress)
+            Atomics.store(req.progress, 0, 1);
+        port.postMessage({ type: 'done', result });
+    }
+    catch (err) {
+        port.postMessage({ type: 'error', message: err.message });
+    }
+});