wowdump 0.2.1 → 0.3.2

package/dist/focused-session.js

@@ -1,1357 +0,0 @@
-import { createHash } from "node:crypto";
-import { z } from "zod";
-export const TargetKindSchema = z.enum([
-    "lua_wrapper",
-    "cpp_function",
-    "data_source",
-    "object",
-    "address_range",
-]);
-const HexSchema = z.string().regex(/^0x[0-9a-fA-F]+$/);
-const SelectorRangeSchema = z
-    .object({ rva: HexSchema, size: z.number().int().positive().max(0x7fffffff) })
-    .strict();
-export const FocusSelectorSchema = z
-    .object({
-    schema: z.literal("selector-schema.v1").default("selector-schema.v1"),
-    kind: TargetKindSchema,
-    combine: z.enum(["all", "any"]).default("any"),
-    apis: z.array(z.string().min(1)).max(256).optional(),
-    namespaces: z.array(z.string().min(1)).max(256).optional(),
-    globs: z.array(z.string().min(1)).max(256).optional(),
-    rvas: z.array(HexSchema).max(256).optional(),
-    dataSourceIds: z.array(z.string().min(1)).max(256).optional(),
-    objectIds: z.array(z.string().min(1)).max(256).optional(),
-    ranges: z.array(SelectorRangeSchema).max(256).optional(),
-    maxTargets: z.number().int().min(1).max(256).default(64),
-    // Compatibility inputs are normalized into the plural v1 fields.
-    namespace: z.string().min(1).optional(),
-    glob: z.string().min(1).optional(),
-    rva: HexSchema.optional(),
-    address: HexSchema.optional(),
-    start: HexSchema.optional(),
-    end: HexSchema.optional(),
-})
-    .strict();
-const VERBATIM_KEYS = new Set([
-    "combine",
-    "apis",
-    "namespaces",
-    "globs",
-    "rvas",
-    "dataSourceIds",
-    "objectIds",
-    "ranges",
-    "maxTargets",
-]);
-export function validateSelector(input, targetKind) {
-    if (!input || typeof input !== "object" || Array.isArray(input))
-        throw new Error("selector must be an object");
-    if (targetKind)
-        for (const key of Object.keys(input))
-            if (!VERBATIM_KEYS.has(key))
-                throw new Error(`selector field ${key} is not allowed`);
-    const parsed = FocusSelectorSchema.parse(targetKind ? { ...input, kind: targetKind } : input);
-    const apis = utf8Sorted(parsed.apis ?? []);
-    const namespaces = utf8Sorted([
-        ...(parsed.namespaces ?? []),
-        ...(parsed.namespace ? [parsed.namespace] : []),
-    ]);
-    const globs = utf8Sorted([
-        ...(parsed.globs ?? []),
-        ...(parsed.glob ? [parsed.glob] : []),
-    ]);
-    for (const glob of globs)
-        validateGlob(glob);
-    const rvas = hexSorted([
-        ...(parsed.rvas ?? []),
-        ...(parsed.rva ? [parsed.rva] : []),
-    ]);
-    const dataSourceIds = utf8Sorted(parsed.dataSourceIds ?? []);
-    const objectIds = utf8Sorted(parsed.objectIds ?? []);
-    const ranges = normalizeRanges(parsed.ranges ?? [], parsed.start, parsed.end);
-    const populated = {
-        apis,
-        namespaces,
-        globs,
-        rvas,
-        dataSourceIds,
-        objectIds,
-        ranges,
-    };
-    const allowed = {
-        lua_wrapper: new Set(["apis", "namespaces", "globs", "rvas"]),
-        cpp_function: new Set(["rvas"]),
-        data_source: new Set(["dataSourceIds"]),
-        object: new Set(["objectIds"]),
-        address_range: new Set(["ranges"]),
-    };
-    for (const [field, values] of Object.entries(populated)) {
-        if (values.length > 0 && !allowed[parsed.kind].has(field))
-            throw new Error(`${field} is incompatible with ${parsed.kind}`);
-    }
-    if (parsed.kind === "cpp_function" && rvas.length === 0)
-        throw new Error("cpp_function requires rvas");
-    if (parsed.kind === "data_source" && dataSourceIds.length === 0)
-        throw new Error("data_source requires dataSourceIds");
-    if (parsed.kind === "object" && objectIds.length === 0 && !parsed.address)
-        throw new Error("object requires objectIds");
-    if (parsed.kind === "address_range" && ranges.length === 0)
-        throw new Error("address_range requires ranges");
-    if (parsed.kind === "lua_wrapper" &&
-        apis.length + namespaces.length + globs.length + rvas.length === 0)
-        throw new Error("selector must identify a target");
-    const resolvedCount = apis.length +
-        namespaces.length +
-        globs.length +
-        rvas.length +
-        dataSourceIds.length +
-        objectIds.length +
-        ranges.length;
-    if (resolvedCount > parsed.maxTargets)
-        throw new Error(`selector resolves to ${resolvedCount} inputs, exceeding maxTargets=${parsed.maxTargets}`);
-    return {
-        schema: "selector-schema.v1",
-        kind: parsed.kind,
-        combine: parsed.combine,
-        ...(apis.length ? { apis } : {}),
-        ...(namespaces.length ? { namespaces } : {}),
-        ...(globs.length ? { globs } : {}),
-        ...(rvas.length ? { rvas, rva: rvas[0] } : {}),
-        ...(dataSourceIds.length ? { dataSourceIds } : {}),
-        ...(objectIds.length ? { objectIds } : {}),
-        ...(ranges.length
-            ? {
-                ranges,
-                start: ranges[0].rva,
-                end: canonicalHex(BigInt(ranges[0].rva) + BigInt(ranges[0].size)),
-            }
-            : {}),
-        ...(parsed.address ? { address: canonicalHex(parsed.address) } : {}),
-        maxTargets: parsed.maxTargets,
-    };
-}
-/** Canonical byte representation used for selector identity and replay checks. */
-export const canonicalizeSelector = (input) => {
-    const record = input;
-    const explicitKind = record && !record.kind && typeof record.targetKind === "string"
-        ? TargetKindSchema.parse(record.targetKind)
-        : undefined;
-    const { targetKind: _targetKind, ...selector } = record ?? {};
-    const value = validateSelector(selector, explicitKind);
-    return JSON.stringify({
-        schemaVersion: value.schema,
-        targetKind: value.kind,
-        combine: value.combine,
-        apis: value.apis ?? [],
-        namespaces: value.namespaces ?? [],
-        globs: value.globs ?? [],
-        rvas: value.rvas ?? [],
-        dataSourceIds: value.dataSourceIds ?? [],
-        objectIds: value.objectIds ?? [],
-        ranges: value.ranges ?? [],
-        maxTargets: value.maxTargets,
-    });
-};
-function canonicalHex(value) {
-    return `0x${BigInt(value).toString(16).toUpperCase()}`;
-}
-function utf8Sorted(values) {
-    return [...new Set(values)].sort((left, right) => Buffer.compare(Buffer.from(left, "utf8"), Buffer.from(right, "utf8")));
-}
-function hexSorted(values) {
-    return [...new Set(values.map(canonicalHex))].sort((left, right) => BigInt(left) < BigInt(right) ? -1 : BigInt(left) > BigInt(right) ? 1 : 0);
-}
-function normalizeRanges(values, start, end) {
-    const ranges = values.map((value) => ({
-        rva: canonicalHex(value.rva),
-        size: value.size,
-    }));
-    if (start || end) {
-        if (!start || !end || BigInt(end) <= BigInt(start))
-            throw new Error("address_range requires start < end");
-        const size = Number(BigInt(end) - BigInt(start));
-        if (!Number.isSafeInteger(size) || size <= 0)
-            throw new Error("address range size is invalid");
-        ranges.push({ rva: canonicalHex(start), size });
-    }
-    const unique = new Map(ranges.map((range) => [`${range.rva}:${range.size}`, range]));
-    return [...unique.values()].sort((left, right) => BigInt(left.rva) < BigInt(right.rva)
-        ? -1
-        : BigInt(left.rva) > BigInt(right.rva)
-            ? 1
-            : left.size - right.size);
-}
-function validateGlob(value) {
-    let escaped = false;
-    for (const character of value) {
-        if (escaped) {
-            escaped = false;
-            continue;
-        }
-        if (character === "\\") {
-            escaped = true;
-            continue;
-        }
-    }
-    if (escaped)
-        throw new Error("glob cannot end with an isolated escape");
-}
-const JsonValueSchema = z.lazy(() => z.union([
-    z.null(),
-    z.boolean(),
-    z.number().finite(),
-    z.string(),
-    z.array(JsonValueSchema),
-    z.record(JsonValueSchema),
-]));
-const TriggerActionSchema = z.union([
-    z.string().min(1),
-    z
-        .object({
-        userAction: z.string().min(1).optional(),
-        expectedTransition: z
-            .union([z.string().min(1), JsonValueSchema])
-            .optional(),
-        description: z.string().min(1).optional(),
-    })
-        .strict(),
-]);
-const TriggerPhaseSchema = z
-    .object({
-    phase: z.enum(["before", "during", "after"]),
-    phaseIndex: z.number().int().nonnegative(),
-    actions: z.array(TriggerActionSchema).default([]),
-    userAction: z.string().min(1).optional(),
-    expectedTransition: z
-        .union([z.string().min(1), JsonValueSchema])
-        .optional(),
-})
-    .strict();
-const RawTriggerPlanSchema = z
-    .object({
-    planVersion: z.string().min(1).default("trigger-plan.v1"),
-    workloadId: z.string().min(1),
-    description: z.string().optional(),
-    phases: z.array(TriggerPhaseSchema).optional(),
-    before: z.array(TriggerActionSchema).default([]),
-    during: z.array(TriggerActionSchema).default([]),
-    after: z.array(TriggerActionSchema).default([]),
-    expectedChanges: z.array(z.string()).default([]),
-})
-    .strict();
-export const TriggerPlanSchema = RawTriggerPlanSchema.transform((value) => ({
-    ...value,
-    phases: value.phases ?? [
-        ...value.before.map((_, phaseIndex) => ({
-            phase: "before",
-            phaseIndex,
-            actions: [value.before[phaseIndex]],
-        })),
-        ...value.during.map((_, phaseIndex) => ({
-            phase: "during",
-            phaseIndex,
-            actions: [value.during[phaseIndex]],
-        })),
-        ...value.after.map((_, phaseIndex) => ({
-            phase: "after",
-            phaseIndex,
-            actions: [value.after[phaseIndex]],
-        })),
-    ],
-}));
-export function canonicalizeEnvironment(input) {
-    const parsedInput = z.record(JsonValueSchema).parse(input);
-    const parsed = {
-        descriptorVersion: "environment.v1",
-        capturedAt: "1970-01-01T00:00:00.000Z",
-        ...parsedInput,
-    };
-    const canonical = stableJson(parsed);
-    return {
-        value: parsed,
-        canonical,
-        sha256: createHash("sha256").update(canonical).digest("hex"),
-    };
-}
-function stableJson(value) {
-    if (Array.isArray(value))
-        return `[${value.map(stableJson).join(",")}]`;
-    if (value !== null && typeof value === "object")
-        return `{${Object.keys(value)
-            .sort((a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)))
-            .map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`)
-            .join(",")}}`;
-    return JSON.stringify(value);
-}
-const systemClock = {
-    now: () => Date.now(),
-    monotonicNow: () => performance.now(),
-};
-export class FocusedSession {
-    state = "created";
-    seq = 0;
-    ingressOrdinal = 0;
-    bytes = 0;
-    hooks = [];
-    stacks = new Map();
-    invocationCounter = 0;
-    phase = "before";
-    droppedEvents = 0;
-    droppedBytes = 0;
-    droppedReasons = {};
-    dropWindows = {};
-    externalDroppedEvents = 0;
-    externalDroppedBytes = 0;
-    externalDroppedReasons = {};
-    startedAt = 0;
-    stoppedAt;
-    pausedAt;
-    pauseGaps = [];
-    cleanupStatus = { hooks: 0, scripts: 0, interceptors: 0 };
-    cleanupPromise;
-    cleanupCoreComplete = false;
-    cleanupCoreFailed = false;
-    cleanupTerminalComplete = false;
-    cleanupDetachRetryable = false;
-    cleanupIntendedTerminal;
-    cleanupStreamPrefixes = [];
-    cleanupFragment;
-    terminalStatus;
-    cleanupSteps = [];
-    environmentInfo;
-    plan;
-    failureClass;
-    errorCode;
-    fatalNotified = new Set();
-    selector;
-    verbatimSelector;
-    receiveOpen = true;
-    frozen = false;
-    draining = false;
-    appendTail = Promise.resolve();
-    appendInFlight = 0;
-    appendControllers = new Set();
-    appendTransactionsAborted = false;
-    cleanupDetachedOperations = [];
-    cleanupLateCompletions = 0;
-    options;
-    constructor(options) {
-        this.verbatimSelector =
-            options.selectorVerbatim ?? stripSelectorMetadata(options.target);
-        this.selector = validateSelector(stripSelectorMetadata(options.target), options.targetKind ?? options.target.kind);
-        if (!Number.isInteger(options.pid) || options.pid <= 0)
-            throw new Error("pid must be positive");
-        if (!options.sessionId || !options.buildKey)
-            throw new Error("sessionId and buildKey are required");
-        if (options.cleanupTimeoutMs !== undefined &&
-            (!Number.isFinite(options.cleanupTimeoutMs) ||
-                options.cleanupTimeoutMs < 0))
-            throw new Error("cleanupTimeoutMs must be a non-negative finite number");
-        if (options.cleanupDeadline !== undefined &&
-            !Number.isFinite(options.cleanupDeadline))
-            throw new Error("cleanupDeadline must be finite");
-        this.environmentInfo = canonicalizeEnvironment(options.environment);
-        this.plan = TriggerPlanSchema.parse(options.triggerPlan);
-        this.options = options;
-    }
-    get status() {
-        return this.state;
-    }
-    get resolvedSelector() {
-        return this.selector;
-    }
-    async validateIdentity() {
-        await this.revalidate();
-    }
-    get manifest() {
-        return {
-            schema: "wow.focus-session.v1",
-            sessionId: this.options.sessionId,
-            pid: this.options.pid,
-            buildKey: this.options.buildKey,
-            moduleBase: this.options.moduleBase,
-            imageBase: this.options.imageBase,
-            processStartTime: this.options.processStartTime ?? null,
-            moduleIdentity: this.options.moduleIdentity ?? null,
-            targetKind: this.selector.kind,
-            selector: this.verbatimSelector,
-            selectorVerbatim: this.verbatimSelector,
-            selectorCanonical: canonicalizeSelector({
-                ...this.verbatimSelector,
-                targetKind: this.selector.kind,
-            }),
-            resolvedTargets: selectorTargets(this.selector),
-            environment: this.environmentInfo.value,
-            environmentSha256: this.environmentInfo.sha256,
-            triggerPlan: this.plan,
-            triggerPhase: this.phase,
-            effectiveLimits: {
-                snapshotIntervalMs: this.options.snapshotIntervalMs ?? 1000,
-                maxEvents: this.options.maxEvents ?? 10_000,
-                maxBytes: this.options.maxBytes ?? 8 * 1024 * 1024,
-                durationMs: this.options.durationMs ?? 0,
-                sampling: this.options.sampling ?? 1,
-            },
-            startTime: this.startedAt ? new Date(this.startedAt).toISOString() : null,
-            stopTime: this.stoppedAt ? new Date(this.stoppedAt).toISOString() : null,
-            hookIds: this.hooks,
-            eventCount: this.seq,
-            ingressCount: this.ingressOrdinal,
-            eventBytes: this.bytes,
-            droppedEventCount: this.droppedEvents,
-            droppedByteCount: this.droppedBytes,
-            droppedByReason: this.droppedReasons,
-            dropWindows: this.dropWindows,
-            pauseGaps: this.pauseGaps,
-            cleanupStatus: this.cleanupStatus,
-            cleanupSteps: this.cleanupSteps,
-            cleanupDetachedOperations: this.cleanupDetachedOperations,
-            cleanupLateCompletions: this.cleanupLateCompletions,
-            frozen: this.frozen,
-            failureClass: this.failureClass ?? null,
-            errorCode: this.errorCode ?? null,
-            state: this.state,
-            ...(this.terminalStatus ? { terminalStatus: this.terminalStatus } : {}),
-        };
-    }
-    async start() {
-        if (this.state !== "created")
-            throw new Error("session already started");
-        this.state = "attaching";
-        let captureStage = "attachment";
-        try {
-            await this.revalidate();
-            await this.options.transport.attach?.(this.identity());
-            captureStage = "capture";
-            this.hooks = await this.options.transport.installHooks(this.selector, {
-                captureArgs: this.options.captureArgs === true,
-                captureReturns: this.options.captureReturns === true,
-                captureCallStack: this.options.captureCallStack === true,
-                captureMemoryWrites: this.options.captureMemoryWrites === true,
-                captureObjectDiff: this.options.captureObjectDiff === true,
-                snapshotIntervalMs: this.options.snapshotIntervalMs ?? 1000,
-                maxEvents: this.options.maxEvents ?? 10_000,
-                maxBytes: this.options.maxBytes ?? 8 * 1024 * 1024,
-                sampling: this.options.sampling ?? 1,
-            });
-            this.state = "armed";
-            this.startedAt = this.clock.now();
-            const before = await this.options.transport.snapshot?.("before");
-            if (before !== undefined)
-                await this.rawControlEvent("snapshot", {
-                    trigger: {
-                        phase: "before",
-                        workloadId: this.plan.workloadId,
-                        snapshotPhase: "before",
-                    },
-                    before,
-                    status: "confirmed",
-                });
-            await this.options.transport.resumeProducer?.();
-            await this.writeManifest();
-            this.state = "running";
-            await this.writeManifest();
-            return this.manifest;
-        }
-        catch (error) {
-            this.markFailure(captureStage === "capture" ? "capture_fatal" : "attachment_fatal", error);
-            try {
-                await this.cleanup("start_failure");
-            }
-            catch (cleanupError) {
-                // A failed start remains a failed observation, but its cleanup evidence
-                // is still terminal and reviewable when all owned resources reached zero.
-                if (!this.frozen || this.terminalStatus !== "frozen")
-                    throw cleanupError;
-            }
-            throw error;
-        }
-    }
-    async pause() {
-        await this.revalidate();
-        if (this.state !== "running")
-            throw new Error("session is not running");
-        await this.options.transport.pauseProducer?.();
-        this.pausedAt = this.clock.now();
-        await this.controlEvent("pause");
-        this.state = "paused";
-        await this.writeManifest();
-    }
-    async resume() {
-        await this.revalidate();
-        if (this.state !== "paused")
-            throw new Error("session is not paused");
-        const end = this.clock.now();
-        const start = this.pausedAt ?? end;
-        await this.options.transport.resumeProducer?.();
-        this.state = "running";
-        this.pauseGaps.push({
-            start: new Date(start).toISOString(),
-            end: new Date(end).toISOString(),
-            durationMs: end - start,
-        });
-        await this.controlEvent("resume", {
-            before: { timestamp: new Date(start).toISOString() },
-            after: { timestamp: new Date(end).toISOString() },
-            diff: { durationMs: end - start, continuityClaimed: false },
-        });
-        this.pausedAt = undefined;
-        await this.writeManifest();
-    }
-    async checkpoint(label = "checkpoint", trigger = {}, snapshotNow = false) {
-        await this.revalidate();
-        if (this.state !== "running")
-            throw new Error("CHECKPOINT_SESSION_NOT_RUNNING");
-        const snapshot = snapshotNow
-            ? await this.options.transport.snapshot?.("checkpoint")
-            : undefined;
-        await this.emit({
-            target: { kind: this.selector.kind },
-            trigger: {
-                phase: this.phase,
-                workloadId: this.plan.workloadId,
-                ...trigger,
-            },
-            status: "dynamic",
-            event: { kind: "checkpoint", depth: 0 },
-            ...(snapshot !== undefined ? { after: snapshot } : {}),
-        });
-        const prefixes = (await this.options.eventSink.prefixes?.()) ?? [];
-        await this.writeManifest({
-            checkpoint: label,
-            seq: this.seq,
-            streamPrefixes: prefixes,
-        });
-        return { ...this.manifest, streamPrefixes: prefixes };
-    }
-    async mergeExternalDrops(snapshot, source = "transport") {
-        const totalEvents = safeNonNegativeInteger(snapshot.droppedEventCount);
-        const totalBytes = safeNonNegativeInteger(snapshot.droppedByteCount);
-        const eventDelta = Math.max(0, totalEvents - this.externalDroppedEvents);
-        const byteDelta = Math.max(0, totalBytes - this.externalDroppedBytes);
-        const reasons = isRecord(snapshot.droppedByReason)
-            ? snapshot.droppedByReason
-            : {};
-        if (isRecord(snapshot.dropWindows))
-            for (const [reason, window] of Object.entries(snapshot.dropWindows))
-                this.dropWindows[`${source}:${reason}`] = window;
-        const reasonDelta = {};
-        for (const [reason, raw] of Object.entries(reasons)) {
-            const value = safeNonNegativeInteger(raw);
-            const delta = Math.max(0, value - (this.externalDroppedReasons[reason] ?? 0));
-            if (delta)
-                reasonDelta[reason] = delta;
-            this.externalDroppedReasons[reason] = value;
-        }
-        this.externalDroppedEvents = Math.max(this.externalDroppedEvents, totalEvents);
-        this.externalDroppedBytes = Math.max(this.externalDroppedBytes, totalBytes);
-        if (!eventDelta && !byteDelta && !Object.keys(reasonDelta).length)
-            return;
-        this.droppedEvents += eventDelta;
-        this.droppedBytes += byteDelta;
-        for (const [reason, delta] of Object.entries(reasonDelta))
-            this.droppedReasons[`${source}:${reason}`] =
-                (this.droppedReasons[`${source}:${reason}`] ?? 0) + delta;
-        if (["running", "paused"].includes(this.state))
-            await this.rawControlEvent("overflow", {
-                diff: {
-                    source,
-                    droppedEvents: eventDelta,
-                    droppedBytes: byteDelta,
-                    droppedByReason: reasonDelta,
-                },
-            });
-    }
-    async emit(input) {
-        const ingressOrdinal = ++this.ingressOrdinal;
-        if (!this.receiveOpen || this.state !== "running")
-            return this.drop("not_running", Buffer.byteLength(JSON.stringify(input)), ingressOrdinal);
-        return this.enqueue(async () => this.persistInput(input, ingressOrdinal));
-    }
-    async emitTransport(input) {
-        const ingressOrdinal = ++this.ingressOrdinal;
-        if (!this.receiveOpen || this.state !== "running")
-            return this.drop("not_running", Buffer.byteLength(JSON.stringify(input)), ingressOrdinal);
-        return this.enqueue(async () => this.persistInput(input, ingressOrdinal));
-    }
-    async persistInput(input, ingressOrdinal) {
-        if (this.frozen)
-            return this.drop("artifact_frozen", Buffer.byteLength(JSON.stringify(input)), ingressOrdinal);
-        const phase = phaseOf(input.trigger);
-        if (!this.advancePhase(phase))
-            return this.drop("phase_regression", Buffer.byteLength(JSON.stringify(input)));
-        if (this.options.sampling !== undefined &&
-            this.options.sampling < 1 &&
-            (this.options.random ?? Math.random)() > this.options.sampling)
-            return this.drop("sampling", Buffer.byteLength(JSON.stringify(input)));
-        const event = this.makeEvent(input.event.kind, input, ingressOrdinal, this.seq + 1);
-        const size = Buffer.byteLength(JSON.stringify(event));
-        if (this.options.maxEvents && this.seq >= this.options.maxEvents)
-            return this.drop("max_events", size);
-        if (this.options.maxBytes && this.bytes + size > this.options.maxBytes)
-            return this.drop("max_bytes", size);
-        this.seq++;
-        this.bytes += size;
-        try {
-            await this.appendEvent(event);
-        }
-        catch (error) {
-            this.seq--;
-            this.bytes -= size;
-            this.drop(error instanceof Error && error.name === "AbortError"
-                ? "append_aborted"
-                : "writer_failure", size, ingressOrdinal, false);
-            throw error;
-        }
-        return true;
-    }
-    async appendEvent(event) {
-        const controller = new AbortController();
-        this.appendControllers.add(controller);
-        if (this.appendTransactionsAborted)
-            controller.abort();
-        try {
-            await this.options.eventSink.append(event, controller.signal);
-        }
-        finally {
-            this.appendControllers.delete(controller);
-        }
-    }
-    async enter(threadId, input) {
-        const stack = this.stacks.get(threadId) ?? [];
-        const invocationId = `${this.options.sessionId}:${++this.invocationCounter}`;
-        const parentInvocationId = stack.at(-1);
-        stack.push(invocationId);
-        this.stacks.set(threadId, stack);
-        return this.emit({
-            ...input,
-            event: {
-                kind: "enter",
-                threadId,
-                depth: stack.length,
-                invocationId,
-                parentInvocationId,
-                recursive: stack.length > 1,
-            },
-        });
-    }
-    async leave(threadId, input) {
-        const stack = this.stacks.get(threadId) ?? [];
-        const invocationId = stack.at(-1);
-        const parentInvocationId = stack.at(-2);
-        const ok = await this.emit({
-            ...input,
-            event: {
-                kind: "leave",
-                threadId,
-                depth: Math.max(1, stack.length),
-                invocationId,
-                parentInvocationId,
-                recursive: stack.length > 1,
-            },
-        });
-        stack.pop();
-        if (!stack.length)
-            this.stacks.delete(threadId);
-        return ok;
-    }
-    async captureDiff(kind, before, after, base) {
-        if (!this.options.diffValidator)
-            throw new Error("DIFF_VALIDATOR_REQUIRED");
-        const diff = await this.options.diffValidator.diff(kind, before, after);
-        const validation = await this.options.diffValidator.validate(kind, before, after, diff);
-        return this.emit({
-            ...base,
-            before,
-            after,
-            diff: { value: diff, validation },
-            status: validation.valid ? base.status : "partial",
-            event: { kind: `${kind}_change`, depth: 0 },
-        });
-    }
-    async targetExited(cleanupDeadline) {
-        if (["stopped", "stopping"].includes(this.state))
-            return this.manifest;
-        this.state = "target_exited";
-        await this.rawControlEvent("exception", {
-            diff: { reason: "target_exit" },
-        });
-        try {
-            await this.cleanup("target_exit", cleanupDeadline);
-        }
-        catch (error) {
-            if (isAbortError(error) || String(error).includes("CAPTURE_CLEANUP_INCOMPLETE"))
-                throw new Error("CAPTURE_CLEANUP_INCOMPLETE");
-            throw error;
-        }
-        return this.manifest;
-    }
-    async stop(cleanupDeadline) {
-        try {
-            await this.cleanup("requested", cleanupDeadline);
-        }
-        catch (error) {
-            if (isAbortError(error) || String(error).includes("CAPTURE_CLEANUP_INCOMPLETE"))
-                throw new Error("CAPTURE_CLEANUP_INCOMPLETE");
-            throw error;
-        }
-        return this.manifest;
-    }
-    get clock() {
-        return this.options.clock ?? systemClock;
-    }
-    identity() {
-        return {
-            pid: this.options.pid,
-            buildKey: this.options.buildKey,
-            moduleBase: this.options.moduleBase,
-            imageBase: this.options.imageBase,
-            processStartTime: this.options.processStartTime,
-            moduleIdentity: this.options.moduleIdentity,
-        };
-    }
-    async revalidate() {
-        const actual = await this.options.transport.revalidateIdentity(this.identity());
-        if (actual.pid !== this.options.pid ||
-            actual.buildKey !== this.options.buildKey ||
-            actual.moduleBase.toLowerCase() !==
-                this.options.moduleBase.toLowerCase() ||
-            (this.options.processStartTime !== undefined &&
-                actual.processStartTime !== this.options.processStartTime) ||
-            (this.options.moduleIdentity !== undefined &&
-                actual.moduleIdentity !== this.options.moduleIdentity)) {
-            this.markFailure("attachment_fatal", new Error("TARGET_IDENTITY_CHANGED"));
-            throw new Error("TARGET_IDENTITY_CHANGED");
-        }
-    }
-    advancePhase(next) {
-        const rank = { before: 0, during: 1, after: 2 };
-        if (rank[next] < rank[this.phase])
-            return false;
-        this.phase = next;
-        return true;
-    }
-    drop(reason, bytes, ingressOrdinal = this.ingressOrdinal, emitOverflow = true) {
-        this.droppedEvents++;
-        this.droppedBytes += bytes;
-        this.droppedReasons[reason] = (this.droppedReasons[reason] ?? 0) + 1;
-        const timestamp = new Date(this.clock.now()).toISOString();
-        const current = isRecord(this.dropWindows[reason])
-            ? this.dropWindows[reason]
-            : {
-                firstLostIngressOrdinal: ingressOrdinal,
-                firstTimestamp: timestamp,
-                producer: "host",
-                threadIds: [],
-                chainCompletenessAffected: true,
-            };
-        current.lastLostIngressOrdinal = ingressOrdinal;
-        current.lastTimestamp = timestamp;
-        this.dropWindows[reason] = current;
-        if (emitOverflow && this.receiveOpen && !this.frozen)
-            void this.rawControlEvent("overflow", {
-                diff: {
-                    reason,
-                    truncation: reason === "max_bytes",
-                    droppedEvents: this.droppedEvents,
-                    droppedBytes: this.droppedBytes,
-                    dropWindow: current,
-                },
-            });
-        return false;
-    }
-    async controlEvent(kind, extra = {}) {
-        return this.emit({
-            target: { kind: this.selector.kind },
-            trigger: { phase: this.phase, workloadId: this.plan.workloadId },
-            status: "dynamic",
-            event: { kind, depth: 0 },
-            ...extra,
-        });
-    }
-    async rawControlEvent(kind, extra = {}) {
-        const ingressOrdinal = ++this.ingressOrdinal;
-        return this.enqueue(async () => {
-            if (this.frozen)
-                return;
-            const event = this.makeEvent(kind, extra, ingressOrdinal, this.seq + 1);
-            const size = Buffer.byteLength(JSON.stringify(event));
-            this.seq++;
-            this.bytes += size;
-            try {
-                await this.appendEvent(event);
-            }
-            catch (error) {
-                this.seq--;
-                this.bytes -= size;
-                this.drop(error instanceof Error && error.name === "AbortError"
-                    ? "append_aborted"
-                    : "writer_failure", size, ingressOrdinal, false);
-                throw error;
-            }
-        });
-    }
-    markFailure(kind, error) {
-        this.failureClass = kind;
-        this.errorCode = {
-            capture_fatal: "CAPTURE_FATAL",
-            attachment_fatal: "ATTACHMENT_FATAL",
-            broker_fatal: "BROKER_FATAL",
-        }[kind];
-        this.state = "failed";
-        if (!this.fatalNotified.has(kind)) {
-            this.fatalNotified.add(kind);
-            try {
-                void Promise.resolve(this.options.onFatal?.({
-                    failureClass: kind,
-                    errorCode: this.errorCode,
-                    sessionId: this.options.sessionId,
-                    pid: this.options.pid,
-                    buildKey: this.options.buildKey,
-                    error,
-                })).catch(() => undefined);
-            }
-            catch { /* reporting cannot mask the originating failure */ }
-        }
-    }
-    async cleanup(reason, requestedCleanupDeadline) {
-        if (this.cleanupTerminalComplete && this.cleanupPromise)
-            return this.cleanupPromise;
-        if (this.cleanupPromise)
-            return this.cleanupPromise;
-        this.receiveOpen = false;
-        this.draining = true;
-        this.cleanupPromise = (async () => {
-            if (!this.cleanupIntendedTerminal) {
-                this.cleanupIntendedTerminal =
-                    this.state === "target_exited"
-                        ? "target_exited"
-                        : this.state === "failed"
-                            ? "failed"
-                            : "stopped";
-            }
-            const terminal = this.cleanupIntendedTerminal;
-            if (!this.cleanupCoreComplete) {
-                this.state = "stopping";
-                this.stoppedAt = this.clock.now();
-            }
-            const cleanupNow = () => this.clock.monotonicNow?.() ?? this.clock.now();
-            const cleanupStartedAt = cleanupNow();
-            const cleanupBudgetMs = Math.min(2_000, this.options.cleanupTimeoutMs ?? 2_000);
-            const localDeadline = cleanupStartedAt + cleanupBudgetMs;
-            const deadline = Math.min(localDeadline, requestedCleanupDeadline ?? localDeadline, this.options.cleanupDeadline ?? localDeadline);
-            const effectiveCleanupBudgetMs = Math.max(0, deadline - cleanupStartedAt);
-            const remainingCleanupMs = () => Math.max(0, deadline - cleanupNow());
-            const errors = [];
-            const steps = this.cleanupSteps;
-            if (!this.cleanupCoreComplete)
-                steps.push({
-                    step: "stop_accepting_events",
-                    status: "passed",
-                    remainingMs: effectiveCleanupBudgetMs,
-                });
-            let bestEffortTail = Promise.resolve();
-            let tailDetached = false;
-            const detachedOperations = [];
-            const run = async (step, operation) => {
-                const remaining = remainingCleanupMs();
-                const pending = (tailDetached ? Promise.resolve() : bestEffortTail).then(operation);
-                let timedOut = false;
-                void pending.then(() => {
-                    if (timedOut)
-                        this.cleanupLateCompletions++;
-                }, () => {
-                    if (timedOut)
-                        this.cleanupLateCompletions++;
-                });
-                bestEffortTail = pending.then(() => undefined, () => undefined);
-                if (remaining === 0) {
-                    // Invoke the remaining best-effort operation even when its wait budget is exhausted.
-                    timedOut = true;
-                    tailDetached = true;
-                    detachedOperations.push({ step, promise: pending });
-                    bestEffortTail = Promise.resolve();
-                    this.cleanupDetachedOperations.push({
-                        step,
-                        status: "detached",
-                        detachedAt: this.clock.now(),
-                    });
-                    const failure = {
-                        step,
-                        errorCode: "CLEANUP_TIMEOUT",
-                        remainingMs: 0,
-                    };
-                    errors.push(failure);
-                    steps.push({ ...failure, status: "failed" });
-                    return undefined;
-                }
-                let timer;
-                try {
-                    const deadlineWait = this.clock.sleep
-                        ? Promise.resolve()
-                            // Give the queued operation its first microtask before a
-                            // deterministic clock advances the aggregate deadline.
-                            .then(() => this.clock.sleep(remaining))
-                            .then(() => Promise.reject(new Error("CLEANUP_TIMEOUT")))
-                        : new Promise((_, reject) => {
-                            timer = setTimeout(() => reject(new Error("CLEANUP_TIMEOUT")), remaining);
-                        });
-                    const result = await Promise.race([
-                        pending,
-                        deadlineWait,
-                    ]);
-                    steps.push({
-                        step,
-                        status: "passed",
-                        remainingMs: remainingCleanupMs(),
-                    });
-                    return result;
-                }
-                catch (error) {
-                    const code = String(error).includes("CLEANUP_TIMEOUT")
-                        ? "CLEANUP_TIMEOUT"
-                        : "CLEANUP_STEP_FAILED";
-                    if (code === "CLEANUP_TIMEOUT") {
-                        timedOut = true;
-                        tailDetached = true;
-                        detachedOperations.push({ step, promise: pending });
-                        bestEffortTail = Promise.resolve();
-                        this.cleanupDetachedOperations.push({
-                            step,
-                            status: "detached",
-                            detachedAt: this.clock.now(),
-                        });
-                    }
-                    const failure = {
-                        step,
-                        errorCode: code,
-                        error: String(error),
-                        remainingMs: remainingCleanupMs(),
-                    };
-                    errors.push(failure);
-                    steps.push({ ...failure, status: "failed" });
-                    return undefined;
-                }
-                finally {
-                    if (timer)
-                        clearTimeout(timer);
-                }
-            };
-            if (!this.cleanupCoreComplete) {
-                const after = await run("after_snapshot", () => this.options.transport.snapshot?.("after"));
-                if (after !== undefined)
-                    await run("append_after_snapshot", () => this.rawControlEvent("snapshot", {
-                        trigger: {
-                            phase: "after",
-                            workloadId: this.plan.workloadId,
-                            snapshotPhase: "after",
-                        },
-                        after,
-                        status: "confirmed",
-                    }));
-                const cleaned = await run("trace_hook_script_cleanup", () => this.options.transport.cleanup(this.hooks));
-                this.cleanupStatus = cleaned ?? {
-                    hooks: this.hooks.length,
-                    scripts: 1,
-                    interceptors: this.hooks.length,
-                    residualErrors: errors,
-                };
-                await run("append_cleanup_evidence", () => this.rawControlEvent("cleanup", {
-                    diff: { reason, ...this.cleanupStatus, steps, errors },
-                }));
-                await run("drain_append_queue", () => this.appendTail);
-                if (this.appendInFlight > 0 &&
-                    detachedOperations.some(operation => operation.step === "drain_append_queue")) {
-                    this.abortPendingAppends();
-                    void this.appendTail.then(() => { this.cleanupLateCompletions++; }, () => { this.cleanupLateCompletions++; });
-                    errors.push({
-                        step: "append_abort",
-                        errorCode: "CLEANUP_TIMEOUT",
-                        error: "append queue was aborted and detached at the aggregate cleanup deadline",
-                        remainingMs: 0,
-                    });
-                }
-                const residual = this.cleanupStatus.hooks !== 0 ||
-                    this.cleanupStatus.scripts !== 0 ||
-                    this.cleanupStatus.interceptors !== 0 ||
-                    (this.cleanupStatus.residualErrors?.length ?? 0) > 0;
-                this.cleanupCoreFailed = residual || errors.length > 0;
-                if (this.cleanupCoreFailed)
-                    this.markFailure("capture_fatal");
-                else
-                    this.state = terminal;
-                this.cleanupStreamPrefixes =
-                    (await run("stream_prefixes", () => this.options.eventSink.prefixes?.() ?? [])) ?? [];
-                this.cleanupFragment = (await run("write_manifest", () => this.writeManifest({
-                    streamPrefixes: this.cleanupStreamPrefixes,
-                    cleanupDeadlineMs: effectiveCleanupBudgetMs,
-                    cleanupSteps: steps,
-                    cleanupDetachedOperations: this.cleanupDetachedOperations,
-                    cleanupLateCompletions: this.cleanupLateCompletions,
-                }))) ?? {
-                    ...this.manifest,
-                    streamPrefixes: this.cleanupStreamPrefixes,
-                    cleanupDeadlineMs: effectiveCleanupBudgetMs,
-                    cleanupSteps: steps,
-                    cleanupDetachedOperations: this.cleanupDetachedOperations,
-                    cleanupLateCompletions: this.cleanupLateCompletions,
-                };
-                this.cleanupCoreComplete = true;
-            }
-            const streamPrefixes = this.cleanupStreamPrefixes;
-            const fragment = this.cleanupFragment ?? { ...this.manifest, streamPrefixes };
-            let detachSucceeded = this.options.detachOnCleanup === false;
-            if (this.options.detachOnCleanup === false) {
-                if (!steps.some(entry => entry.step === "detach_deferred_to_broker"))
-                    steps.push({
-                        step: "detach_deferred_to_broker",
-                        status: "deferred",
-                        ownership: "broker",
-                        remainingMs: remainingCleanupMs(),
-                    });
-            }
-            else {
-                const beforeDetachErrors = errors.length;
-                await run("detach", () => this.options.transport.detach?.());
-                detachSucceeded = errors.length === beforeDetachErrors;
-            }
-            if (!detachSucceeded) {
-                const detachResidual = {
-                    step: "detach",
-                    errorCode: "CLEANUP_STEP_FAILED",
-                    residual: true,
-                };
-                this.cleanupStatus = {
-                    ...this.cleanupStatus,
-                    residualErrors: [
-                        ...(this.cleanupStatus.residualErrors ?? []),
-                        detachResidual,
-                    ],
-                };
-                if (!steps.some(entry => entry.step === "detach" && entry.status === "failed")) {
-                    steps.push({
-                        step: "detach",
-                        status: "failed",
-                        errorCode: "CLEANUP_STEP_FAILED",
-                        residual: true,
-                        remainingMs: remainingCleanupMs(),
-                    });
-                }
-                this.cleanupDetachRetryable = !this.cleanupCoreFailed;
-                this.markFailure("capture_fatal");
-            }
-            else {
-                this.cleanupDetachRetryable = false;
-                if (this.cleanupStatus.residualErrors)
-                    this.cleanupStatus = {
-                        ...this.cleanupStatus,
-                        residualErrors: this.cleanupStatus.residualErrors.filter(entry => !isRecord(entry) || entry.step !== "detach"),
-                    };
-                if (!this.cleanupCoreFailed) {
-                    this.failureClass = undefined;
-                    this.errorCode = undefined;
-                    this.state = terminal;
-                }
-            }
-            let freezeSucceeded = false;
-            let freezeFailure;
-            const freezeController = new AbortController();
-            let finalPrefixes = streamPrefixes;
-            if (detachSucceeded && !this.cleanupCoreFailed && errors.length === 0 && this.appendInFlight === 0) {
-                finalPrefixes =
-                    (await run("final_stream_prefixes", () => this.options.eventSink.prefixes?.() ?? streamPrefixes)) ?? streamPrefixes;
-            }
-            const freezeRemaining = remainingCleanupMs();
-            // Preserve part of the same aggregate deadline for publishing canonical
-            // failure evidence if freeze hangs. Detach remains best-effort even if
-            // both publication steps consume their bounded waits.
-            // Reserve explicit time in the same absolute deadline for terminal
-            // failure commit and publication quiescence. A freeze must not consume
-            // the entire cleanup window.
-            const FAILURE_COMMIT_RESERVE_MS = 500;
-            const QUIESCENCE_RESERVE_MS = 100;
-            const freezeWaitMs = Math.max(0, freezeRemaining - FAILURE_COMMIT_RESERVE_MS - QUIESCENCE_RESERVE_MS);
-            if (detachSucceeded && !this.cleanupCoreFailed && errors.length === 0 && this.appendInFlight === 0 && freezeWaitMs > 0) {
-                let timer;
-                let freezeTimedOut = false;
-                try {
-                    const frozenFragment = {
-                        ...fragment,
-                        ...this.manifest,
-                        streamPrefixes: finalPrefixes,
-                    };
-                    const pending = this.options.manifestSink?.freeze
-                        ? Promise.resolve(this.options.manifestSink.freeze(frozenFragment, freezeController.signal))
-                        : Promise.resolve(this.options.manifestSink?.write(frozenFragment)).then(() => ({
-                            committed: true,
-                            terminalStatus: "frozen",
-                        }));
-                    void pending.then(() => { if (freezeTimedOut)
-                        this.cleanupLateCompletions++; }, () => { if (freezeTimedOut)
-                        this.cleanupLateCompletions++; });
-                    const timeout = this.clock.sleep
-                        ? this.clock.sleep(freezeWaitMs).then(() => { throw new Error("FREEZE_TIMEOUT"); })
-                        : new Promise((_, reject) => {
-                            timer = setTimeout(() => reject(new Error("FREEZE_TIMEOUT")), freezeWaitMs);
-                        });
-                    const receipt = await Promise.race([pending, timeout]);
-                    if (!receipt?.committed || receipt.terminalStatus !== "frozen")
-                        throw new Error(`TERMINAL_FREEZE_NOT_COMMITTED:${receipt?.terminalStatus ?? "unknown"}`);
-                    freezeSucceeded = true;
-                    this.terminalStatus = "frozen";
-                    this.frozen = true;
-                    steps.push({ step: "freeze_artifacts", status: "passed", remainingMs: remainingCleanupMs() });
-                }
-                catch (error) {
-                    freezeFailure = error;
-                    if (String(error).includes("FREEZE_TIMEOUT")) {
-                        freezeTimedOut = true;
-                        this.cleanupDetachedOperations.push({
-                            step: "freeze_artifacts",
-                            status: "detached",
-                            detachedAt: this.clock.now(),
-                        });
-                    }
-                    freezeController.abort(error);
-                    steps.push({ step: "freeze_artifacts", status: "failed", errorCode: String(error).includes("FREEZE_TIMEOUT") ? "CLEANUP_TIMEOUT" : "CLEANUP_STEP_FAILED", error: String(error), remainingMs: remainingCleanupMs() });
-                }
-                finally {
-                    if (timer)
-                        clearTimeout(timer);
-                }
-            }
-            else {
-                freezeFailure = new Error("FREEZE_PRECONDITION_FAILED");
-                freezeController.abort(freezeFailure);
-                steps.push({ step: "freeze_artifacts", status: "failed", errorCode: "FREEZE_PRECONDITION_FAILED", remainingMs: freezeRemaining });
-            }
-            if (!freezeSucceeded) {
-                freezeFailure ??= new Error("CAPTURE_TERMINAL_FREEZE_FAILED");
-                errors.push({ step: "freeze_artifacts", errorCode: String(freezeFailure).includes("FREEZE_TIMEOUT") ? "CLEANUP_TIMEOUT" : "CAPTURE_TERMINAL_FREEZE_FAILED", error: String(freezeFailure), remainingMs: remainingCleanupMs() });
-                this.markFailure("capture_fatal");
-                const terminalFailure = {
-                    ...fragment,
-                    ...this.manifest,
-                    frozen: false,
-                    terminal: true,
-                    terminalStatus: "failed",
-                    terminalFailure: {
-                        errorCode: "CAPTURE_TERMINAL_FREEZE_FAILED",
-                        error: String(freezeFailure),
-                        recoverable: true,
-                        nextAction: "retry artifact freeze from durable stream prefixes",
-                    },
-                    cleanupSteps: steps,
-                    cleanupDetachedOperations: this.cleanupDetachedOperations,
-                    cleanupLateCompletions: this.cleanupLateCompletions,
-                };
-                // Publishing failure evidence shares the aggregate cleanup deadline.
-                // A stuck sink is detached so transport detach is still issued; the
-                // frozen session state remains authoritative if that sink settles late.
-                const failureController = new AbortController();
-                const FAILURE_QUIESCENCE_RESERVE_MS = 100;
-                const failureRemaining = remainingCleanupMs();
-                const failurePublicationWaitMs = Math.max(0, failureRemaining - FAILURE_QUIESCENCE_RESERVE_MS);
-                let failureTimer;
-                let failureWaitActive = true;
-                await run("publish_terminal_failure", async () => {
-                    const publication = this.options.manifestSink?.terminalFailure
-                        ? Promise.resolve(this.options.manifestSink.terminalFailure(terminalFailure, failureController.signal))
-                        : Promise.resolve(this.options.manifestSink?.write(terminalFailure)).then(() => ({
-                            committed: true,
-                            terminalStatus: "failed",
-                        }));
-                    // Start the guarded writer before its abort timer. This gives the
-                    // publication a real commit opportunity while still reserving time
-                    // for its abort-aware unlink path before the aggregate deadline.
-                    if (failurePublicationWaitMs === 0) {
-                        failureController.abort(new Error("CLEANUP_TIMEOUT"));
-                    }
-                    else if (this.clock.sleep) {
-                        void this.clock.sleep(failurePublicationWaitMs).then(() => {
-                            if (failureWaitActive)
-                                failureController.abort(new Error("CLEANUP_TIMEOUT"));
-                        });
-                    }
-                    else {
-                        failureTimer = setTimeout(() => {
-                            if (failureWaitActive)
-                                failureController.abort(new Error("CLEANUP_TIMEOUT"));
-                        }, failurePublicationWaitMs);
-                    }
-                    const receipt = await publication;
-                    if (!receipt.committed || receipt.terminalStatus !== "failed")
-                        throw new Error(`TERMINAL_FAILURE_NOT_COMMITTED:${receipt.terminalStatus}`);
-                    this.terminalStatus = "failed";
-                    return receipt;
-                });
-                failureWaitActive = false;
-                if (failureTimer)
-                    clearTimeout(failureTimer);
-            }
-            await run("quiesce_manifest_publications", () => this.options.manifestSink?.quiesce?.());
-            this.draining = false;
-            if (!this.cleanupDetachRetryable)
-                this.cleanupTerminalComplete = true;
-            if ((errors.length || this.cleanupCoreFailed || !freezeSucceeded) && !freezeSucceeded)
-                throw new Error("CAPTURE_CLEANUP_INCOMPLETE");
-        })();
-        try {
-            await this.cleanupPromise;
-        }
-        finally {
-            if (this.cleanupDetachRetryable && !this.cleanupTerminalComplete)
-                this.cleanupPromise = undefined;
-        }
-    }
-    enqueue(operation) {
-        this.appendInFlight++;
-        const result = this.appendTail.then(async () => {
-            try {
-                return await operation();
-            }
-            finally {
-                this.appendInFlight--;
-            }
-        });
-        this.appendTail = result.then(() => undefined, () => undefined);
-        // The session owns the canonical append promise; detached callers may
-        // observe the operation rejection, but it must never become an
-        // unhandled rejection that escapes terminal cleanup.
-        void result.catch(() => undefined);
-        return result;
-    }
-    abortPendingAppends() {
-        this.appendTransactionsAborted = true;
-        for (const controller of this.appendControllers)
-            controller.abort();
-    }
-    makeEvent(kind, input, ingressOrdinal, seq) {
-        const target = isRecord(input.target) ? input.target : {};
-        const trigger = isRecord(input.trigger) ? input.trigger : {};
-        const rawEvent = isRecord(input.event) ? input.event : {};
-        return {
-            seq,
-            ingressOrdinal,
-            sessionId: this.options.sessionId,
-            buildKey: this.options.buildKey,
-            pid: this.options.pid,
-            moduleBase: this.options.moduleBase,
-            target: {
-                kind: TargetKindSchema.parse(target.kind ?? this.selector.kind),
-                name: typeof target.name === "string" ? target.name : null,
-                rva: typeof target.rva === "string" ? target.rva : null,
-                runtimeAddress: typeof target.runtimeAddress === "string"
-                    ? target.runtimeAddress
-                    : null,
-            },
-            environment: this.environmentInfo.value,
-            trigger: {
-                workloadId: typeof trigger.workloadId === "string"
-                    ? trigger.workloadId
-                    : this.plan.workloadId,
-                phase: trigger.phase ?? this.phase,
-                userAction: trigger.userAction ?? null,
-                ...trigger,
-            },
-            event: {
-                kind,
-                timestamp: new Date(this.clock.now()).toISOString(),
-                threadId: typeof rawEvent.threadId === "number" ? rawEvent.threadId : null,
-                depth: typeof rawEvent.depth === "number" ? rawEvent.depth : 0,
-                invocationId: typeof rawEvent.invocationId === "string"
-                    ? rawEvent.invocationId
-                    : null,
-                parentInvocationId: typeof rawEvent.parentInvocationId === "string"
-                    ? rawEvent.parentInvocationId
-                    : null,
-                recursive: rawEvent.recursive === true,
-                monotonicTimestamp: typeof rawEvent.monotonicTimestamp === "number"
-                    ? rawEvent.monotonicTimestamp
-                    : this.clock.monotonicNow?.() ?? this.clock.now(),
-            },
-            arguments: input.arguments ?? null,
-            returnValue: input.returnValue ?? null,
-            before: input.before ?? null,
-            after: input.after ?? null,
-            diff: input.diff ?? null,
-            callStack: Array.isArray(input.callStack) ? input.callStack : [],
-            evidence: Array.isArray(input.evidence) ? input.evidence : [],
-            status: input.status === "confirmed" ||
-                input.status === "dynamic" ||
-                input.status === "unresolved"
-                ? input.status
-                : "partial",
-        };
-    }
-    async writeManifest(extra = {}) {
-        const fragment = { ...this.manifest, ...extra };
-        if (this.options.manifestSink)
-            await this.options.manifestSink.write(fragment);
-        return fragment;
-    }
-}
-function phaseOf(trigger) {
-    const phase = trigger.phase ?? "during";
-    if (phase !== "before" && phase !== "during" && phase !== "after")
-        throw new Error("TRIGGER_PHASE_INVALID");
-    return phase;
-}
-function safeNonNegativeInteger(value) {
-    return Number.isSafeInteger(value) && Number(value) >= 0 ? Number(value) : 0;
-}
-function isAbortError(value) {
-    return !!value && typeof value === "object" &&
-        ("name" in value && value.name === "AbortError");
-}
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function stripSelectorMetadata(selector) {
-    return {
-        combine: selector.combine,
-        ...(selector.apis?.length ? { apis: selector.apis } : {}),
-        ...(selector.namespaces?.length || selector.namespace
-            ? {
-                namespaces: [
-                    ...(selector.namespaces ?? []),
-                    ...(selector.namespace ? [selector.namespace] : []),
-                ],
-            }
-            : {}),
-        ...(selector.globs?.length || selector.glob
-            ? {
-                globs: [
-                    ...(selector.globs ?? []),
-                    ...(selector.glob ? [selector.glob] : []),
-                ],
-            }
-            : {}),
-        ...(selector.rvas?.length || selector.rva
-            ? {
-                rvas: [
-                    ...(selector.rvas ?? []),
-                    ...(selector.rva ? [selector.rva] : []),
-                ],
-            }
-            : {}),
-        ...(selector.dataSourceIds?.length
-            ? { dataSourceIds: selector.dataSourceIds }
-            : {}),
-        ...(selector.objectIds?.length ? { objectIds: selector.objectIds } : {}),
-        ...(selector.ranges?.length ? { ranges: selector.ranges } : {}),
-        maxTargets: selector.maxTargets,
-    };
-}
-function selectorTargets(selector) {
-    return [
-        ...(selector.apis ?? []).map((value) => ({ api: value })),
-        ...(selector.namespaces ?? []).map((value) => ({ namespace: value })),
-        ...(selector.globs ?? []).map((value) => ({ glob: value })),
-        ...(selector.rvas ?? []).map((value) => ({ rva: value })),
-        ...(selector.dataSourceIds ?? []).map((value) => ({ dataSourceId: value })),
-        ...(selector.objectIds ?? []).map((value) => ({ objectId: value })),
-        ...(selector.ranges ?? []).map((value) => ({ ...value })),
-    ];
-}