ttsc 0.30.4 → 0.31.0

package/lib/internal/E2ETrace.js

@@ -0,0 +1,541 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.E2ETrace = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_events_1 = require("node:events");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Private opt-in observations of maintained process primitives and separately
+ * classified runtime source preparation inputs, watch-shutdown phases and
+ * computed capability cache gates.
+ *
+ * TTSC_E2E_TRACE selects coordinator-owned scratch. Each writer owns one JSONL
+ * and its raw returned-buffer payloads. Returned strings are recorded as text,
+ * without claiming their encoding reconstructs original process bytes. Missing
+ * or invalid evidence is a measurement failure, never permission to change a
+ * product result. Times are call bounds; a synchronous return does not reveal
+ * an exact OS start time or descendant close. No trace output is written to
+ * product streams.
+ *
+ * @evidence contracts/common.md#principled-implementation Actual primitive call bounds and returned PID/status/signal/error/output remain separate from source-preparation inputs and caller-observed shutdown phases; failed admission or sink writes do not synthesize success or replace product results.
+ * @evidence contracts/common.md#clear-and-simple-design A private token connects one attempt and returned result; per-process writer state owns serialization, payload budget and append-close IO.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The helper neither patches child_process nor infers launches from wrapper call counts; no tests/utils or public product API is introduced.
+ * @evidence contracts/common.md#meaningful-documentation Native prose separates observation from lifecycle ownership and documents opt-in failure and time-bound limitations.
+ * @evidence contracts/portability.md#os-neutral-implementation Native Node path and filesystem APIs admit an absolute scratch root; argv/cwd retain selected representations and returned PID/signal are native observations, not shell syntax or OS defaults.
+ * @evidence contracts/performance.md#efficient-algorithms Each event serializes its actual metadata and returned payload bytes. JSON encoding and string-to-byte conversion temporarily precede budget admission; encoded metadata and payload IO scale with those inputs and add synchronous latency.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each primitive invocation has independent effects; matching command/argv cannot share its observation as a new execution.
+ * @evidence contracts/performance.md#bound-retention-and-release-resources One writer retains root/nonce/counters until process exit. Each sink write closes in finally; payloads are capped at 64MiB each and writer output at 256MiB including reserved integrity metadata. Coordinator owns scratch reclamation and writer/child settlement; IO failure can leave partial files and missing evidence.
+ */
+var E2ETrace;
+(function (E2ETrace) {
+    /**
+     * Observe one runtime cleanup without repeating ownership or filesystem work.
+     *
+     * The returned observer shares an invocation across actual lock, ownership,
+     * removal and failure phases. It records caller-computed values only.
+     * Disabled tracing allocates no writer; observer errors never replace cleanup
+     * results.
+     *
+     * @evidence contracts/common.md#principled-implementation One token binds the caller's actual cleanup phases and computed classification; an event does not establish an unobserved owner incarnation or successful deletion.
+     * @evidence contracts/common.md#clear-and-simple-design A private optional callback reuses the existing writer, metadata schema and error absorption; owner observations preserve the existing scan's values without changing its policy.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts No ownership scan, liveness probe, file observation, policy decision or retry is performed by tracing.
+     * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes computed phases from OS ownership proof and documents disabled and failed-sink behavior.
+     * @evidence contracts/portability.md#os-neutral-implementation The caller's native directory coordinates and error code are recorded without path rewriting, shell commands or OS-name inference.
+     * @evidence contracts/performance.md#efficient-algorithms Enabled metadata encoding and synchronous sink IO scale with actual field/error text; disabled mode returns before copying argv or creating writer state.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each cleanup occurrence owns its effect and observer token; previous classifications cannot certify a later cleanup.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources One callback/token lives with the cleanup call and retains no history. Existing writer budgets, append-close lifecycle and coordinator scratch ownership remain unchanged.
+     */
+    function runtimeCleanup(directory, runtimeCacheDir, origin = "ttsx-runtime-cleanup") {
+        const selected = process.env.TTSC_E2E_TRACE;
+        if (!selected)
+            return undefined;
+        try {
+            if (!admit(selected))
+                return undefined;
+            const token = {
+                invocation: String(++ordinal),
+                argv: [...process.argv],
+                cwd: process.cwd(),
+                lower: new Date().toISOString(),
+                origin,
+                argv0: null,
+            };
+            const record = (phase, ownership, error, ownerObservation) => {
+                try {
+                    const detail = error !== null && typeof error === "object"
+                        ? error
+                        : undefined;
+                    event(token, "runtime-cleanup", process.pid, {
+                        phase,
+                        directory,
+                        runtimeCacheDir,
+                        ownership,
+                        ownerObservation,
+                        errorName: detail && typeof detail.name === "string"
+                            ? detail.name
+                            : undefined,
+                        errorCode: detail && typeof detail.code === "string"
+                            ? detail.code
+                            : undefined,
+                        errorMessage: detail && typeof detail.message === "string"
+                            ? detail.message
+                            : undefined,
+                        origin: token.origin,
+                    });
+                }
+                catch {
+                    failed = true;
+                }
+            };
+            record("attempt");
+            return record;
+        }
+        catch {
+            failed = true;
+            return undefined;
+        }
+    }
+    E2ETrace.runtimeCleanup = runtimeCleanup;
+    /**
+     * Record already-computed capability cache gates as non-process observations.
+     * Disabled tracing performs no sink IO. Writer admission, budgets and failed
+     * sink handling are shared with the other private observations; no gate is
+     * recomputed and no product result is replaced by an observer failure.
+     *
+     * @evidence contracts/common.md#principled-implementation Caller-supplied gate values and actual publication branches are observations, not fabricated producer proof or process outcomes.
+     * @evidence contracts/common.md#clear-and-simple-design One capability event uses the existing private writer and schema without changing capability response fields.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts No process, hash probe, public API or environment selector is added; observer failure remains inside the trace owner.
+     * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes computed gates from product evidence and states disabled and failed-sink behavior.
+     * @evidence contracts/portability.md#os-neutral-implementation Actual Node argv, cwd and writer identity retain their native representations under the existing absolute scratch admission.
+     * @evidence contracts/performance.md#efficient-algorithms Enabled metadata copying, serialization and synchronous sink IO scale with actual text sizes; disabled mode returns before those operations.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each occurrence reports its own decision and cannot substitute an earlier gate outcome.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This call retains no history or resource; the existing bounded writer owns append-close IO and coordinator-owned scratch lifetime.
+     */
+    function capabilityResolution(phase, data) {
+        const selected = process.env.TTSC_E2E_TRACE;
+        if (!selected)
+            return;
+        try {
+            if (!admit(selected))
+                return;
+            const token = {
+                invocation: String(++ordinal),
+                argv: [...process.argv],
+                cwd: process.cwd(),
+                lower: new Date().toISOString(),
+                origin: "ttsc-capability-resolution",
+                argv0: null,
+            };
+            event(token, "capability-resolution", process.pid, {
+                ...data,
+                phase,
+                origin: token.origin,
+            });
+        }
+        catch {
+            failed = true;
+        }
+    }
+    E2ETrace.capabilityResolution = capabilityResolution;
+    /**
+     * Record a watch-shutdown phase as a non-process observation. Callers report
+     * actual promise/callback outcomes and the received stop ID; observation time
+     * is not an OS exit time or proof of descendant termination. Disabled tracing
+     * performs no sink IO or metadata copying. Sink failures never replace the
+     * caller's promise, result, exception or protocol message.
+     *
+     * @evidence contracts/common.md#principled-implementation Actual caller-supplied phase metadata is recorded without treating observation as a join authority or synthesizing settlement.
+     * @evidence contracts/common.md#clear-and-simple-design One non-process event uses the existing private writer, invocation schema, budget and integrity path.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts No promise or foreign process method is replaced; no product stream, public API, flag, configuration or test dependency is introduced.
+     * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes observed phase time and received stop ID from native lifecycle authority.
+     * @evidence contracts/portability.md#os-neutral-implementation Node supplies actual writer PID, argv, cwd and UTC metadata; the existing absolute native scratch admission owns path handling.
+     * @evidence contracts/performance.md#efficient-algorithms Enabled argv/metadata copying, JSON encoding and synchronous native sink IO scale with their text sizes and add latency; disabled mode returns before copying.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each phase occurrence describes a distinct caller observation; another occurrence cannot reuse an earlier outcome.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This call keeps no phase history or handle; the existing writer owns its 256MiB output limit, append-close writes and coordinator-owned scratch cleanup.
+     */
+    function watchShutdown(phase, data) {
+        const selected = process.env.TTSC_E2E_TRACE;
+        if (!selected)
+            return;
+        try {
+            if (!admit(selected))
+                return;
+            const token = {
+                invocation: String(++ordinal),
+                argv: [...process.argv],
+                cwd: process.cwd(),
+                lower: new Date().toISOString(),
+                origin: "ttsc-watch-shutdown",
+                argv0: null,
+            };
+            event(token, "watch-shutdown-phase", process.pid, {
+                ...data,
+                phase,
+                origin: token.origin,
+            });
+        }
+        catch {
+            failed = true;
+        }
+    }
+    E2ETrace.watchShutdown = watchShutdown;
+    /**
+     * Observe the actual source string before runtime preparation, not a launch.
+     * UTF-16LE preserves JavaScript code units, including unpaired surrogates;
+     * these bytes represent the consumed string, not original disk or emit bytes.
+     * Optional served-emit coordinates report the caller's selected ownership
+     * metadata, not current artifact identity or successful preparation. Disabled
+     * An empty project build may instead report its actual returned failure
+     * envelope; that distinct event contains no consumed source or emit claim.
+     * Disabled tracing performs no sink IO or source conversion. Observer failure
+     * leaves the caller's preparation and exception behavior untouched.
+     *
+     * @evidence contracts/common.md#principled-implementation The caller supplies its already-read source, filename and selected format; the observation precedes unchanged preparation without certifying parsing success or executable identity. An empty project emit reports only its actual returned build envelope in a distinct failed event, preserving the original fallback and exception.
+     * @evidence contracts/common.md#clear-and-simple-design One non-process event and bounded raw-string payload use the existing private writer, invocation schema and integrity policy.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts No source is reconstructed, product result replaced, syntax admitted, or launch inferred from this observation; no public product API or test dependency is introduced.
+     * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes consumed UTF-16 code units from disk bytes, process starts and preparation success.
+     * @evidence contracts/portability.md#os-neutral-implementation Native filenames and selected format remain caller metadata; Node's explicit utf16le encoding preserves source code units without filesystem case or module-format guessing.
+     * @evidence contracts/performance.md#efficient-algorithms Enabled source conversion and payload IO scale with twice the source code-unit count; returned build text is budget-checked and serialized by its actual size. Metadata encoding and synchronous sink IO add latency. Disabled tracing returns before conversion, and oversized source is rejected before allocation.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each preparation observation concerns its actual caller input, not a shared compilation or historical execution answer.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources This operation retains no source history or handle; the existing writer owns bounded payload writes, failure metadata and coordinator-owned scratch cleanup.
+     */
+    function runtimePreparation(source, filename, selectedFormat, origin, emitAttribution) {
+        const selected = process.env.TTSC_E2E_TRACE;
+        if (!selected)
+            return;
+        try {
+            if (!admit(selected))
+                return;
+            const token = {
+                invocation: String(++ordinal),
+                argv: [...process.argv],
+                cwd: process.cwd(),
+                lower: new Date().toISOString(),
+                origin,
+                argv0: null,
+            };
+            if (emitAttribution?.nativeBuildFailure !== undefined) {
+                const { nativeBuildFailure, ...coordinates } = emitAttribution;
+                event(token, "runtime-source-preparation-failed", process.pid, {
+                    origin,
+                    filename,
+                    selectedFormat,
+                    emitAttribution: coordinates,
+                    status: nativeBuildFailure.status,
+                    stdout: payload(token, "runtime-build-stdout", nativeBuildFailure.stdout),
+                    stderr: payload(token, "runtime-build-stderr", nativeBuildFailure.stderr),
+                    representation: "returned-build-envelope-without-project-emit",
+                });
+                return;
+            }
+            if (source.length > PAYLOAD_LIMIT / 2) {
+                integrity(token, "payload-budget-exceeded");
+                return;
+            }
+            const sourcePayload = payload(token, "runtime-source", Buffer.from(source, "utf16le"));
+            event(token, "runtime-source-preparation", process.pid, {
+                origin,
+                filename,
+                selectedFormat,
+                source: sourcePayload,
+                emitAttribution: emitAttribution ?? null,
+                sourceEncoding: "utf16le",
+                sourceCodeUnits: source.length,
+                representation: "consumed-javascript-string",
+            });
+        }
+        catch {
+            failed = true;
+        }
+    }
+    E2ETrace.runtimePreparation = runtimePreparation;
+    /**
+     * Observe supported child events without taking transport or kill ownership.
+     * Error monitoring preserves Node's ordinary unhandled-error behavior. Close
+     * releases these listeners; an unclosed child can retain them indefinitely.
+     *
+     * @evidence contracts/common.md#principled-implementation Actual spawn, exit and close events remain distinct; native child PID and code/signal are observations, not inferred wrapper counts or descendant joins.
+     * @evidence contracts/common.md#clear-and-simple-design One token owns four observation callbacks on the actual maintained ChildProcess and removes remaining callbacks at close.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Supported event listeners and errorMonitor neither replace foreign methods nor convert an unhandled error into handled success; process streams are not consumed here.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states event ownership, error behavior and unclosed-listener retention.
+     * @evidence contracts/portability.md#os-neutral-implementation Node's spawn/exit/close events and returned native PID/code/signal supply platform observations without guessed Unix state or exact OS start time.
+     * @evidence contracts/performance.md#efficient-algorithms Four listener registrations and bounded event count add actual metadata/error-byte serialization and native sink IO; caller event-loop scheduling and child runtime remain delegated.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work One actual child's lifecycle cannot certify an equivalent second launch.
+     * @evidence contracts/performance.md#bound-retention-and-release-resources Observation callbacks retain the token/child until actual close and then remove remaining listeners. No deadline or child termination is introduced; a caller's release of event-loop reference does not prove close.
+     */
+    function asynchronous(token, child) {
+        if (token === undefined || failed)
+            return;
+        const upper = new Date().toISOString();
+        const observe = (kind, data) => {
+            try {
+                event(token, kind, child.pid ?? null, data, upper);
+            }
+            catch {
+                failed = true;
+            }
+        };
+        const onSpawn = () => observe("process-start", { origin: token.origin, started: true });
+        const onExit = (status, signal) => observe("process-exit", {
+            origin: token.origin,
+            status,
+            signal,
+            exitObserved: true,
+        });
+        const onError = (error) => observe("process-result", {
+            origin: token.origin,
+            started: child.pid !== undefined,
+            outcome: "async-error",
+            error: { name: error.name, message: error.message },
+        });
+        const onClose = (status, signal) => {
+            child.removeListener("spawn", onSpawn);
+            child.removeListener("exit", onExit);
+            child.removeListener(node_events_1.errorMonitor, onError);
+            observe("process-close", { origin: token.origin, status, signal });
+        };
+        child.once("spawn", onSpawn);
+        child.once("exit", onExit);
+        child.once(node_events_1.errorMonitor, onError);
+        child.once("close", onClose);
+    }
+    E2ETrace.asynchronous = asynchronous;
+    /**
+     * Observe exactly one caller-owned synchronous primitive, preserving its
+     * returned object and any thrown exception. A thrown call leaves an attempt
+     * without a result, which cannot certify completed process observation.
+     *
+     * @evidence contracts/common.md#principled-implementation The operation is called once and its same result is returned; observer failure cannot substitute a command outcome.
+     * @evidence contracts/common.md#clear-and-simple-design This boundary pairs the shared before/after observer around a maintained actual primitive.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts No foreign spawn method is replaced; maintained owners supply their unchanged actual call rather than reconstructed source.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states result identity, exception preservation and incomplete-attempt scope.
+     * @evidence contracts/portability.md#os-neutral-implementation Selected native command/argv/cwd accompany the actual returned Node PID/status/signal; the observer does not reinterpret the platform.
+     * @evidence contracts/performance.md#efficient-algorithms One primitive call delegates observer metadata/output-byte and native IO cost before returning; no retries or output traversals beyond the trace sink are added here.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work An independent effectful primitive call cannot be replaced with a matching historical result.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The actual call owner retains process/output authority; the namespace sink owns trace-file writes and coordinator cleanup.
+     */
+    function synchronous(command, args, options, origin, operation, coordinatorRoot = process.env.TTSC_E2E_TRACE) {
+        const token = begin(command, args, options, origin, coordinatorRoot);
+        const returned = operation();
+        result(token, returned);
+        return returned;
+    }
+    E2ETrace.synchronous = synchronous;
+    /**
+     * Observe before one actual synchronous primitive, with disabled sink IO
+     * zero. The generated private broker can pass the same coordinator root
+     * through its internal arguments without changing the target's supplied
+     * environment.
+     *
+     * @evidence contracts/common.md#principled-implementation Empty opt-in returns undefined before sink work; native call execution remains entirely with the caller.
+     * @evidence contracts/common.md#clear-and-simple-design Admission and one attempt event return a small token for the same call.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Observation failures return no token rather than changing command execution or printing to its streams.
+     * @evidence contracts/common.md#meaningful-documentation Purpose and timing are explicit in native prose and token fields.
+     * @evidence contracts/portability.md#os-neutral-implementation Node validates an absolute coordinator root; cwd preserves supplied path/URL spelling or records inherited intent.
+     * @evidence contracts/performance.md#efficient-algorithms Argument copying and cwd text plus delegated sink encoding/native IO scale with input bytes; disabled mode returns before copying.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work This observes an independent effectful call, not a reusable completed computation.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The returned metadata token owns no handle; namespace writer and actual spawn owner control resource lifetimes.
+     */
+    function begin(command, args, options, origin, coordinatorRoot = process.env.TTSC_E2E_TRACE) {
+        if (!coordinatorRoot)
+            return undefined;
+        try {
+            if (!admit(coordinatorRoot))
+                return undefined;
+            const token = {
+                invocation: String(++ordinal),
+                argv: [command, ...args],
+                cwd: options.cwd === undefined ? null : String(options.cwd),
+                lower: new Date().toISOString(),
+                origin,
+                argv0: options.argv0 ?? null,
+            };
+            event(token, "process-attempt", null, {
+                origin,
+                cwdInherited: options.cwd === undefined,
+                argv0: token.argv0,
+            });
+            return token;
+        }
+        catch {
+            failed = true;
+            return undefined;
+        }
+    }
+    E2ETrace.begin = begin;
+    /**
+     * Record a returned primitive result without claiming a child close event.
+     * Native failures may return undefined streams; both null and undefined mean
+     * absent payload, without invalidating the writer or replacing the result.
+     *
+     * @evidence contracts/common.md#principled-implementation Native returned PID/status/signal/error and original returned buffers/string values remain distinct from attempt metadata and product outcomes; null or undefined streams retain absent payload references, and encoded returned text is not certified original child bytes.
+     * @evidence contracts/common.md#clear-and-simple-design One result event connects the token to optional raw stdout/stderr payload references.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Failed or missing PID is not counted as a launch, and absent output is not fabricated as empty bytes; genuine payload or sink failure still invalidates the writer without replacing the result.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states returned-result scope, native absent-stream meaning and absence of descendant-close proof.
+     * @evidence contracts/portability.md#os-neutral-implementation Status and signal are used as returned by Node; there is no POSIX interpretation of Windows status or guessed start timestamp.
+     * @evidence contracts/performance.md#efficient-algorithms Actual returned text/buffer conversion, payload writes and metadata/error serialization scale with their bytes; budget admission does not bound prior conversion allocation.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Every returned result belongs to its own observed call and cannot stand in for another invocation.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Result observation acquires no child ownership; namespace sink closes writes and coordinator retains/reclaims files after settlement.
+     */
+    function result(token, returned) {
+        if (token === undefined || failed)
+            return;
+        const upper = new Date().toISOString();
+        try {
+            const error = returned.error;
+            const stdout = payload(token, "stdout", returned.stdout);
+            const stderr = payload(token, "stderr", returned.stderr);
+            event(token, "process-result", returned.pid > 0 ? returned.pid : null, {
+                origin: token.origin,
+                started: returned.pid > 0,
+                exitObserved: returned.status !== null || returned.signal !== null,
+                status: returned.status,
+                signal: returned.signal,
+                error: error === undefined
+                    ? null
+                    : {
+                        name: error.name,
+                        message: error.message,
+                        code: error.code,
+                        errno: error.errno,
+                        syscall: error.syscall,
+                    },
+                stdout,
+                stderr,
+            }, upper);
+        }
+        catch {
+            failed = true;
+        }
+    }
+    E2ETrace.result = result;
+})(E2ETrace || (exports.E2ETrace = E2ETrace = {}));
+const WRITER_LIMIT = 256 * 1024 * 1024;
+const PAYLOAD_LIMIT = 64 * 1024 * 1024;
+const FAILURE_RESERVE = 1024 * 1024;
+let root;
+let instance;
+let ordinal = 0;
+let sequence = 0;
+let bytes = 0;
+let failed = false;
+function admit(selected) {
+    if (failed)
+        return false;
+    if (root !== undefined)
+        return true;
+    if (!node_path_1.default.isAbsolute(selected))
+        return false;
+    instance = node_crypto_1.default.randomBytes(16).toString("hex");
+    root = selected;
+    return true;
+}
+function append(value) {
+    const fd = node_fs_1.default.openSync(node_path_1.default.join(root, `${process.pid}-${instance}.jsonl`), "a", 0o600);
+    try {
+        let offset = 0;
+        while (offset < value.length) {
+            const written = node_fs_1.default.writeSync(fd, value, offset, value.length - offset);
+            if (written <= 0)
+                throw new Error("trace short write");
+            offset += written;
+            bytes += written;
+        }
+    }
+    finally {
+        node_fs_1.default.closeSync(fd);
+    }
+}
+function event(token, kind, pid, data, upper) {
+    if (failed)
+        return;
+    const record = {
+        schema: 1,
+        event: kind,
+        writerPid: process.pid,
+        instance,
+        sequence: ++sequence,
+        at: new Date().toISOString(),
+        invocation: `${instance}:${token.invocation}`,
+        pid,
+        argv: token.argv,
+        cwd: token.cwd,
+        startLowerBound: token.lower,
+        startUpperBound: upper,
+        data: { writerRuntime: process.version, ...data },
+    };
+    const encoded = Buffer.from(JSON.stringify(record) + "\n");
+    if (bytes + encoded.length > WRITER_LIMIT - FAILURE_RESERVE) {
+        integrity(token, "writer-budget-exceeded");
+        return;
+    }
+    try {
+        append(encoded);
+    }
+    catch {
+        integrity(token, "sink-io-failed");
+    }
+}
+function payload(token, label, value) {
+    if (value === null || value === undefined || failed)
+        return null;
+    if (typeof value === "string") {
+        if (Buffer.byteLength(value) > PAYLOAD_LIMIT) {
+            integrity(token, "payload-budget-exceeded");
+            return null;
+        }
+        return { text: value, representation: "returned-string" };
+    }
+    const content = value;
+    if (content.length > PAYLOAD_LIMIT ||
+        bytes + content.length > WRITER_LIMIT - FAILURE_RESERVE) {
+        integrity(token, "payload-budget-exceeded");
+        return null;
+    }
+    const filename = `${process.pid}-${instance}-${token.invocation}-${label}.bin`;
+    try {
+        node_fs_1.default.writeFileSync(node_path_1.default.join(root, filename), content, {
+            flag: "wx",
+            mode: 0o600,
+        });
+        bytes += content.length;
+        return { path: filename, bytes: content.length };
+    }
+    catch {
+        // Charge the whole attempted payload conservatively even if its partial
+        // write length cannot be recovered, leaving room only for failure metadata.
+        bytes += content.length;
+        integrity(token, "payload-io-failed");
+        return null;
+    }
+}
+function integrity(token, reason) {
+    failed = true;
+    try {
+        const encoded = Buffer.from("\n" +
+            JSON.stringify({
+                schema: 1,
+                event: "integrity-failure",
+                writerPid: process.pid,
+                instance,
+                sequence: ++sequence,
+                at: new Date().toISOString(),
+                invocation: `${instance}:${token.invocation}`,
+                pid: null,
+                argv: [],
+                cwd: null,
+                data: { outcome: reason, writerRuntime: process.version },
+            }) +
+            "\n");
+        if (bytes + encoded.length <= WRITER_LIMIT)
+            append(encoded);
+    }
+    catch {
+        /* Missing/invalid sink remains a measurement failure. */
+    }
+}
+//# sourceMappingURL=E2ETrace.js.map

package/lib/internal/E2ETrace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"E2ETrace.js","sourceRoot":"","sources":["../../src/internal/E2ETrace.ts"],"names":[],"mappings":"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"}

package/lib/internal/IJavaScriptRuntimeCapabilities.d.ts

@@ -0,0 +1,48 @@
+/**
+ * What a JavaScript runtime executable can do, as measured by running it.
+ *
+ * Produced by {@link javascriptRuntimeCapabilities}, which asks the interpreter
+ * itself rather than inferring from the host process: a `node` found on `PATH`,
+ * a version-manager shim, and Bun can all stand in for the runtime a plugin
+ * descriptor is evaluated with, and each supports a different loader.
+ *
+ * False flags also describe unsuccessful or malformed probes; the shape does
+ * not distinguish inability to observe a feature from observed unavailability.
+ * The optional executable is absent unless the probe returned an absolute
+ * path.
+ *
+ * @evidence contracts/common.md#principled-implementation Independent Bun and synchronous-hook flags represent measured runtime capabilities rather than assuming the host's runtime; an optional executable preserves unknown interpreter identity and false conservatively includes unsuccessful observation.
+ * @evidence contracts/common.md#clear-and-simple-design One small result separates loader family, hook capability and executable identity without embedding probe process state or feature-detection policy.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The producer runs its feature query and conservatively maps absent or nonmatching fields to unsupported states; runtime names or host version numbers do not manufacture support flags in this representation.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain measured origin, wrapper identity, failure/false ambiguity and executable absence; member comments describe loader consequences with documentation-skill member and tag separation.
+ * @evidence contracts/portability.md#os-neutral-implementation Actual interpreter capabilities and its native absolute executable path cross the process boundary explicitly; the type does not infer feature availability from operating-system names or path extensions.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+ */
+export type IJavaScriptRuntimeCapabilities = {
+    /**
+     * The probe reports `typeof globalThis.Bun === "object"`. The evaluator
+     * selects its Bun loader lane from this flag; this value is not an
+     * independently certified executable family. That lane loads TypeScript
+     * descriptors, and the descriptor evaluator isolates it from Bun's own
+     * config, `.env` loading, and network auto-install. The ttsx runtime-hook
+     * preload is gated separately, on the measured {@link registerHooks}, so Bun
+     * receives it only if it ever reports that hook.
+     */
+    bun: boolean;
+    /**
+     * The absolute path the runtime reports as its own `process.execPath`, when
+     * the probe returned an absolute spelling. A wrapper candidate may differ
+     * from this reported executable, letting the evaluator select the reported
+     * interpreter instead of the wrapper spelling. This field alone is not a
+     * physical-identity or immutable-runtime certificate.
+     */
+    executable?: string;
+    /**
+     * The probe reports `typeof Module.registerHooks === "function"` for
+     * `node:module`. This presence check selects the synchronous-hook lane;
+     * installation can still fail and is owned by the runtime-hook installer.
+     */
+    registerHooks: boolean;
+};

package/lib/internal/IJavaScriptRuntimeCapabilities.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IJavaScriptRuntimeCapabilities.js.map

package/lib/internal/IJavaScriptRuntimeCapabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IJavaScriptRuntimeCapabilities.js","sourceRoot":"","sources":["../../src/internal/IJavaScriptRuntimeCapabilities.ts"],"names":[],"mappings":""}