larkin 0.2.70

package/dist/platform/telemetry-tracing.mjs

@@ -0,0 +1,596 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { context, SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { TelemetrySpool } from "./telemetry-spool.mjs";
+import { startTelemetryUploader } from "./telemetry-uploader.mjs";
+import { inspectProcess } from "./process-state.mjs";
+const nanos = ([seconds, nanoseconds]) => (BigInt(seconds) * 1000000000n + BigInt(nanoseconds)).toString();
+// OTel JS uses zero-based SpanKind values while OTLP's enum starts at 1.
+const kind = (value) => value + 1;
+const attributeValue = (value) => {
+    if (typeof value === "boolean")
+        return { boolValue: value };
+    if (typeof value === "number" && Number.isInteger(value))
+        return { intValue: String(value) };
+    if (typeof value === "number")
+        return { doubleValue: value };
+    if (Array.isArray(value))
+        return { arrayValue: { values: value.map(attributeValue) } };
+    return { stringValue: String(value) };
+};
+const attributes = (values) => Object.entries(values)
+    .filter(([, value]) => value !== undefined && value !== null)
+    .map(([key, value]) => ({ key, value: attributeValue(value) }));
+function serializeSpan(span) {
+    const resourceAttributes = span.resource.attributes;
+    const spanContext = span.spanContext();
+    return { resourceSpans: [{
+                resource: { attributes: attributes(resourceAttributes) },
+                scopeSpans: [{ scope: { name: span.instrumentationScope.name, version: span.instrumentationScope.version }, spans: [{
+                                traceId: spanContext.traceId, spanId: spanContext.spanId,
+                                ...(span.parentSpanContext?.spanId ? { parentSpanId: span.parentSpanContext.spanId } : {}),
+                                name: span.name, kind: kind(span.kind), startTimeUnixNano: nanos(span.startTime), endTimeUnixNano: nanos(span.endTime),
+                                attributes: attributes(span.attributes),
+                                links: span.links.map((link) => ({ traceId: link.context.traceId, spanId: link.context.spanId,
+                                    traceState: link.context.traceState?.serialize(), flags: link.context.traceFlags,
+                                    attributes: attributes((link.attributes ?? {})) })),
+                                status: { code: span.status.code }, flags: spanContext.traceFlags,
+                            }] }],
+            }] };
+}
+class DurableSpanExporter {
+    spool;
+    diagnostic;
+    constructor(spool, diagnostic) {
+        this.spool = spool;
+        this.diagnostic = diagnostic;
+    }
+    export(spans, callback) {
+        try {
+            for (const span of spans)
+                this.spool.enqueue(serializeSpan(span));
+            callback({ code: 0 });
+        }
+        catch {
+            this.diagnostic?.("spool");
+            callback({ code: 1 });
+        }
+    }
+    async shutdown() { }
+}
+const NOOP = {
+    beginMessage() { }, async phase(_id, _name, _kind, operation) { return operation(); }, filterMessage() { }, delivery() { }, runtimeEvent() { },
+    externalPhase(_agent, _state, _name, _kind, operation) { return operation(); }, async shutdown() { },
+};
+const safeHash = (value) => crypto.createHash("sha256").update(value).digest("hex").slice(0, 24);
+const activeContextFile = (stateDir) => path.join(stateDir, "telemetry-active-context.json");
+const generationFile = (stateDir) => path.join(stateDir, "telemetry-runtime-generation.json");
+function atomicStateWrite(file, value) {
+    const temporary = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    try {
+        fs.writeFileSync(temporary, JSON.stringify(value), { mode: 0o600, flag: "wx" });
+        fs.renameSync(temporary, file);
+        fs.chmodSync(file, 0o600);
+        const directory = fs.openSync(path.dirname(file), fs.constants.O_RDONLY);
+        try {
+            fs.fsyncSync(directory);
+        }
+        finally {
+            fs.closeSync(directory);
+        }
+    }
+    finally {
+        try {
+            fs.unlinkSync(temporary);
+        }
+        catch { /* isolated */ }
+    }
+}
+function readStateJson(file) {
+    const descriptor = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+    try {
+        const stat = fs.fstatSync(descriptor);
+        if (!stat.isFile())
+            throw new Error("invalid state");
+        return JSON.parse(fs.readFileSync(descriptor, "utf8"));
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+}
+function writeActiveContext(stateDir, value, generation, now) {
+    if (!stateDir)
+        return;
+    const file = activeContextFile(stateDir);
+    try {
+        fs.mkdirSync(stateDir, { recursive: true, mode: 0o700 });
+        if (!value) {
+            try {
+                fs.unlinkSync(file);
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+            return;
+        }
+        atomicStateWrite(file, { version: 2, generation, traceId: value.traceId, spanId: value.spanId, traceFlags: value.traceFlags,
+            expiresAt: now + 30 * 60 * 1000 });
+    }
+    catch { /* telemetry cannot alter business behavior */ }
+}
+function readActiveContext(stateDir, now, inspectOwner) {
+    try {
+        const file = activeContextFile(stateDir);
+        const stat = fs.lstatSync(file);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            return null;
+        const value = readStateJson(file);
+        const generationStat = fs.lstatSync(generationFile(stateDir));
+        if (!generationStat.isFile() || generationStat.isSymbolicLink())
+            return null;
+        const owner = readStateJson(generationFile(stateDir));
+        const ownerPid = Number(owner.pid);
+        if (value.version !== 2 || owner.version !== 1 || value.generation !== owner.generation
+            || Number(value.expiresAt) <= now || Number(owner.expiresAt) <= now
+            || !Number.isSafeInteger(ownerPid) || ownerPid <= 0
+            || !/^[0-9a-f]{32}$/.test(String(value.traceId)) || !/^[0-9a-f]{16}$/.test(String(value.spanId)))
+            return null;
+        const inspected = inspectOwner(ownerPid);
+        if (!inspected.ok || !inspected.startToken || inspected.startToken !== owner.processStartToken)
+            return null;
+        return { traceId: String(value.traceId), spanId: String(value.spanId), traceFlags: Number(value.traceFlags) || 1, isRemote: true };
+    }
+    catch {
+        return null;
+    }
+}
+export function createTelemetryRuntime(config, options = {}) {
+    const spool = new TelemetrySpool(config);
+    const exporter = new DurableSpanExporter(spool);
+    const runtimeGeneration = crypto.randomUUID();
+    const startupId = crypto.randomUUID();
+    const now = options.now ?? Date.now;
+    const inspectOwner = options.inspectOwner ?? ((pid) => inspectProcess(pid));
+    const processStartToken = options.processStartToken ?? inspectOwner(process.pid).startToken;
+    const initializedStateDirs = new Set();
+    const initializeStateDir = (stateDir) => {
+        if (initializedStateDirs.has(stateDir))
+            return;
+        try {
+            fs.mkdirSync(stateDir, { recursive: true, mode: 0o700 });
+            try {
+                fs.unlinkSync(activeContextFile(stateDir));
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+            atomicStateWrite(generationFile(stateDir), { version: 1, generation: runtimeGeneration, pid: process.pid,
+                processStartToken, expiresAt: now() + 24 * 60 * 60 * 1000 });
+            initializedStateDirs.add(stateDir);
+        }
+        catch { /* isolated */ }
+    };
+    const renewStateDir = (stateDir) => {
+        try {
+            const owner = readStateJson(generationFile(stateDir));
+            if (owner.generation === runtimeGeneration && Number(owner.expiresAt) - now() < 12 * 60 * 60 * 1000) {
+                atomicStateWrite(generationFile(stateDir), { version: 1, generation: runtimeGeneration, pid: process.pid,
+                    processStartToken, expiresAt: now() + 24 * 60 * 60 * 1000 });
+            }
+        }
+        catch { /* isolated */ }
+    };
+    const writeContext = (agentId, value) => {
+        const stateDir = options.stateDirFor?.(agentId);
+        if (!stateDir)
+            return;
+        initializeStateDir(stateDir);
+        renewStateDir(stateDir);
+        writeActiveContext(stateDir, value, runtimeGeneration, now());
+    };
+    for (const stateDir of options.stateDirs ?? []) {
+        initializeStateDir(stateDir);
+    }
+    const provider = new NodeTracerProvider({
+        resource: resourceFromAttributes({ "service.name": "larkin", "service.version": options.serviceVersion ?? "dev",
+            "service.instance.id": startupId }),
+        spanProcessors: [new SimpleSpanProcessor(exporter)],
+        spanLimits: { attributeCountLimit: 16, attributeValueLengthLimit: 96, eventCountLimit: 0, linkCountLimit: 8 },
+    });
+    provider.register();
+    const tracer = provider.getTracer("larkin.telemetry", "1.0.0");
+    const messages = new Map();
+    const activeByAgent = new Map();
+    // Runtime observations can precede the acceptance receipt. Correlate them
+    // without publishing or changing the authoritative active delivery state.
+    const observingByAgent = new Map();
+    const observingHead = (agentId) => observingByAgent.get(agentId)?.[0];
+    const enqueueObserving = (current) => {
+        const queue = observingByAgent.get(current.agentId) ?? [];
+        if (!queue.includes(current))
+            queue.push(current);
+        observingByAgent.set(current.agentId, queue);
+    };
+    const removeObserving = (current) => {
+        const queue = observingByAgent.get(current.agentId);
+        if (!queue)
+            return;
+        const next = queue.filter((candidate) => candidate !== current);
+        if (next.length > 0)
+            observingByAgent.set(current.agentId, next);
+        else
+            observingByAgent.delete(current.agentId);
+    };
+    const ownershipTimer = setInterval(() => {
+        for (const stateDir of initializedStateDirs)
+            renewStateDir(stateDir);
+        for (const [agentId, current] of activeByAgent)
+            writeContext(agentId, current.turn?.spanContext() ?? current.root.spanContext());
+    }, options.maintenanceIntervalMs ?? 10 * 60 * 1000);
+    ownershipTimer.unref?.();
+    const uploader = startTelemetryUploader(spool, config);
+    const closeActivity = (current) => {
+        current.activitySpan?.end();
+        delete current.activitySpan;
+        delete current.activityName;
+    };
+    const closePi = (current, failed = false) => {
+        const state = current.pi;
+        if (!state)
+            return;
+        for (const key of ["promptWaitSpan", "compactionSpan", "rpcSpan", "lifecycleSpan", "outputWaitSpan", "generationSpan", "toolSpan", "settleSpan"]) {
+            const span = state[key];
+            if (!span)
+                continue;
+            if (failed)
+                span.setStatus({ code: SpanStatusCode.ERROR });
+            span.end();
+            delete state[key];
+        }
+    };
+    const endTrace = (current, failed = false) => {
+        closeActivity(current);
+        closePi(current, failed);
+        if (current.turn) {
+            if (failed)
+                current.turn.setStatus({ code: SpanStatusCode.ERROR });
+            current.turn.end();
+        }
+        if (failed)
+            current.root.setStatus({ code: SpanStatusCode.ERROR });
+        current.root.end();
+        for (const [messageId, candidate] of messages)
+            if (candidate === current)
+                messages.delete(messageId);
+        if (activeByAgent.get(current.agentId) === current) {
+            activeByAgent.delete(current.agentId);
+            writeContext(current.agentId, null);
+        }
+        removeObserving(current);
+    };
+    return {
+        beginMessage(agentId, messageId, source = "im") {
+            try {
+                if (messages.has(messageId))
+                    return;
+                const active = activeByAgent.get(agentId) ?? observingHead(agentId);
+                const linkedContext = active?.turn?.spanContext() ?? active?.root.spanContext();
+                const root = tracer.startSpan("larkin.message.process", { kind: SpanKind.CONSUMER,
+                    attributes: { "larkin.agent.id_hash": safeHash(agentId), "messaging.message.id_hash": safeHash(messageId),
+                        "larkin.message.source": source,
+                        ...(linkedContext ? { "larkin.message.relation": "fan_in" } : {}) },
+                    ...(linkedContext ? { links: [{ context: linkedContext }] } : {}),
+                });
+                const value = { root, context: trace.setSpan(context.active(), root), agentId, messageHash: safeHash(messageId) };
+                messages.set(messageId, value);
+            }
+            catch { /* isolated */ }
+        },
+        async phase(messageId, name, spanKind, operation) {
+            const current = messages.get(messageId);
+            if (!current)
+                return operation();
+            if (name === "runtime.deliver" && !activeByAgent.has(current.agentId))
+                enqueueObserving(current);
+            let span;
+            try {
+                span = tracer.startSpan(name, { kind: spanKind }, current.context);
+            }
+            catch {
+                removeObserving(current);
+                return operation();
+            }
+            try {
+                return await context.with(trace.setSpan(current.context, span), operation);
+            }
+            catch (error) {
+                span.setStatus({ code: SpanStatusCode.ERROR });
+                if (!name.startsWith("document.comment."))
+                    endTrace(current, true);
+                throw error;
+            }
+            finally {
+                span.end();
+                removeObserving(current);
+            }
+        },
+        filterMessage(messageId, reason) {
+            try {
+                const current = messages.get(messageId);
+                if (!current)
+                    return;
+                current.root.setAttribute("larkin.filter.reason", reason);
+                endTrace(current, false);
+            }
+            catch { /* isolated */ }
+        },
+        delivery(agentId, messageId, status) {
+            try {
+                const current = messages.get(messageId) ?? activeByAgent.get(agentId);
+                if (!current)
+                    return;
+                if (status === "accepted") {
+                    const active = activeByAgent.get(agentId) ?? observingHead(agentId);
+                    if (active && active !== current) {
+                        endTrace(current, false);
+                        return;
+                    }
+                    activeByAgent.set(agentId, current);
+                    writeContext(agentId, current.turn?.spanContext() ?? current.root.spanContext());
+                }
+                if (status === "error")
+                    endTrace(current, true);
+                if (status === "deferred")
+                    endTrace(current, true);
+                if (status === "duplicate")
+                    endTrace(current, false);
+            }
+            catch { /* isolated */ }
+        },
+        runtimeEvent(agentId, event) {
+            try {
+                const current = activeByAgent.get(agentId) ?? observingHead(agentId);
+                if (!current)
+                    return;
+                if (event.type === "runtime-observation" && event.runtime === "pi") {
+                    const state = current.pi ??= { distribution: event.distribution };
+                    state.distribution = event.distribution;
+                    const observedAt = now();
+                    if (state.settledAt !== undefined)
+                        return;
+                    const spanAttributes = { "larkin.observation.boundary": "pi_rpc", "larkin.runtime.id": "pi",
+                        "larkin.runtime.distribution": event.distribution };
+                    const startPreflight = (name, startTime) => tracer.startSpan(name, { kind: SpanKind.INTERNAL, startTime, attributes: spanAttributes }, current.context);
+                    const start = (name, startTime) => {
+                        if (!current.turnContext)
+                            return undefined;
+                        return tracer.startSpan(name, { kind: SpanKind.INTERNAL, startTime, attributes: spanAttributes }, current.turnContext);
+                    };
+                    if (event.phase === "rpc_submit" && state.submitAt === undefined && state.acceptedAt === undefined) {
+                        state.submitAt = observedAt;
+                        state.promptWaitSpan = startPreflight("pi.prompt.wait", observedAt);
+                    }
+                    else if (event.phase === "rpc_accepted" && state.submitAt !== undefined && state.acceptedAt === undefined) {
+                        state.acceptedAt = observedAt;
+                        state.promptWaitSpan?.setAttribute("larkin.pi.preflight.outcome", "accepted");
+                        state.promptWaitSpan?.end(observedAt);
+                        delete state.promptWaitSpan;
+                        state.compactionSpan?.end(observedAt);
+                        delete state.compactionSpan;
+                        if (event.distribution === "builtin") {
+                            if (state.rpcSpan) {
+                                state.rpcSpan.end(observedAt);
+                                delete state.rpcSpan;
+                            }
+                            if (current.turnContext && !state.outputWaitSpan)
+                                state.outputWaitSpan = start("pi.output.wait", observedAt);
+                        }
+                    }
+                    else if (event.phase === "compaction_start" && state.submitAt !== undefined && !state.compactionSpan) {
+                        state.promptWaitSpan?.setAttribute("larkin.pi.preflight.progress", "compaction");
+                        state.compactionSpan = startPreflight("pi.compaction", observedAt);
+                    }
+                    else if (event.phase === "compaction_end") {
+                        state.compactionSpan?.end(observedAt);
+                        delete state.compactionSpan;
+                    }
+                    else if (event.phase === "retry_progress") {
+                        state.promptWaitSpan?.setAttribute("larkin.pi.preflight.progress", "retry");
+                    }
+                    else if (event.phase === "rpc_timeout" || event.phase === "rpc_error") {
+                        const outcome = event.phase === "rpc_timeout" ? "timeout" : "error";
+                        state.promptWaitSpan?.setAttribute("larkin.pi.preflight.outcome", outcome);
+                        state.promptWaitSpan?.setStatus({ code: SpanStatusCode.ERROR });
+                        state.promptWaitSpan?.end(observedAt);
+                        delete state.promptWaitSpan;
+                        state.compactionSpan?.setStatus({ code: SpanStatusCode.ERROR });
+                        state.compactionSpan?.end(observedAt);
+                        delete state.compactionSpan;
+                    }
+                    if (event.distribution !== "builtin")
+                        return;
+                    if (event.phase === "turn_start" && state.turnStartAt === undefined)
+                        state.turnStartAt = observedAt;
+                    else if (event.phase === "first_output" && state.firstOutputAt === undefined && state.completedAt === undefined) {
+                        state.firstOutputAt = observedAt;
+                        if (state.outputWaitSpan) {
+                            state.outputWaitSpan.end(observedAt);
+                            delete state.outputWaitSpan;
+                        }
+                        if (current.turnContext && !state.generationSpan)
+                            state.generationSpan = start("pi.generation", observedAt);
+                    }
+                    else if (event.phase === "tool_call" && state.completedAt === undefined && !state.toolSpan) {
+                        state.toolSpan = start("pi.tool.wait", observedAt);
+                    }
+                    else if (event.phase === "tool_result" && state.toolSpan) {
+                        state.toolSpan.end(observedAt);
+                        delete state.toolSpan;
+                    }
+                    else if (event.phase === "completed" && state.completedAt === undefined) {
+                        state.completedAt = observedAt;
+                        if (state.generationSpan) {
+                            state.generationSpan.end(observedAt);
+                            delete state.generationSpan;
+                        }
+                        if (!state.settleSpan)
+                            state.settleSpan = start("pi.rpc.settle", observedAt);
+                    }
+                    else if (event.phase === "settled") {
+                        state.settledAt = observedAt;
+                        if (state.toolSpan) {
+                            state.toolSpan.end(observedAt);
+                            delete state.toolSpan;
+                        }
+                        if (state.generationSpan) {
+                            state.generationSpan.end(observedAt);
+                            delete state.generationSpan;
+                        }
+                        if (state.settleSpan) {
+                            state.settleSpan.end(observedAt);
+                            delete state.settleSpan;
+                        }
+                        if (state.lifecycleSpan) {
+                            state.lifecycleSpan.end(observedAt);
+                            delete state.lifecycleSpan;
+                        }
+                    }
+                }
+                else if (event.type === "turn-start") {
+                    if (current.turn)
+                        return;
+                    const pi = current.pi;
+                    current.turn = tracer.startSpan("agent.turn", { kind: SpanKind.INTERNAL,
+                        ...(pi?.submitAt !== undefined ? { startTime: pi.submitAt } : {}),
+                        attributes: { "larkin.observation.boundary": "runtime_host",
+                            ...(pi ? { "larkin.runtime.id": "pi", "larkin.runtime.distribution": pi.distribution } : {}) } }, current.context);
+                    current.turnContext = trace.setSpan(current.context, current.turn);
+                    if (pi?.distribution === "builtin") {
+                        const spanAttributes = { "larkin.observation.boundary": "pi_rpc", "larkin.runtime.id": "pi",
+                            "larkin.runtime.distribution": "builtin" };
+                        const submitAt = pi.submitAt ?? pi.turnStartAt ?? now();
+                        pi.lifecycleSpan = tracer.startSpan("pi.rpc.lifecycle", { kind: SpanKind.INTERNAL, startTime: submitAt,
+                            attributes: spanAttributes }, current.turnContext);
+                        if (pi.submitAt !== undefined) {
+                            pi.rpcSpan = tracer.startSpan("pi.rpc.submit", { kind: SpanKind.INTERNAL, startTime: pi.submitAt,
+                                attributes: spanAttributes }, current.turnContext);
+                            if (pi.acceptedAt !== undefined && pi.acceptedAt >= pi.submitAt) {
+                                pi.rpcSpan.end(pi.acceptedAt);
+                                delete pi.rpcSpan;
+                            }
+                        }
+                        const waitAt = pi.acceptedAt ?? pi.turnStartAt ?? now();
+                        pi.outputWaitSpan = tracer.startSpan("pi.output.wait", { kind: SpanKind.INTERNAL, startTime: waitAt,
+                            attributes: spanAttributes }, current.turnContext);
+                        if (pi.firstOutputAt !== undefined) {
+                            pi.outputWaitSpan.end(pi.firstOutputAt);
+                            delete pi.outputWaitSpan;
+                        }
+                    }
+                    writeContext(agentId, current.turn.spanContext());
+                }
+                else if (event.type === "activity") {
+                    const activityName = event.activity === "tool" ? "tool.execute" : "model.activity";
+                    writeContext(agentId, current.turn?.spanContext() ?? current.root.spanContext());
+                    if (current.activityName === activityName)
+                        return;
+                    closeActivity(current);
+                    const activitySpan = tracer.startSpan(activityName, { kind: SpanKind.INTERNAL,
+                        attributes: { "larkin.activity.type": event.activity, "larkin.observation.boundary": "runtime_event_interval" } }, current.turnContext ?? current.context);
+                    current.activityName = activityName;
+                    current.activitySpan = activitySpan;
+                }
+                else if (event.type === "input-error") {
+                    current.turn?.setStatus({ code: SpanStatusCode.ERROR });
+                }
+                else if (event.type === "turn-end")
+                    endTrace(current, false);
+                else if (event.type === "error" || event.type === "configuration-error" || event.type === "closed")
+                    endTrace(current, true);
+            }
+            catch { /* isolated */ }
+        },
+        externalPhase(agentId, stateDir, name, spanKind, operation, boundary = "agent_transport") {
+            let span;
+            let parentContext;
+            try {
+                const parent = readActiveContext(stateDir, now(), inspectOwner);
+                parentContext = parent ? trace.setSpanContext(context.active(), parent) : context.active();
+                span = tracer.startSpan(name, { kind: spanKind, attributes: { "larkin.agent.id_hash": safeHash(agentId),
+                        "larkin.observation.boundary": boundary } }, parentContext);
+            }
+            catch {
+                return operation();
+            }
+            let result;
+            try {
+                result = context.with(trace.setSpan(parentContext, span), operation);
+            }
+            catch (error) {
+                if (name === "document.comment.reply")
+                    span.setAttribute("larkin.operation.outcome", "error");
+                span.setStatus({ code: SpanStatusCode.ERROR });
+                span.end();
+                throw error;
+            }
+            const recordOutcome = (value) => {
+                if (name === "document.comment.reply") {
+                    const success = typeof value !== "number" || value === 0;
+                    span.setAttribute("larkin.operation.outcome", success ? "success" : "error");
+                    if (!success)
+                        span.setStatus({ code: SpanStatusCode.ERROR });
+                }
+                return value;
+            };
+            if (result && typeof result.then === "function") {
+                return Promise.resolve(result).then(recordOutcome).catch((error) => {
+                    if (name === "document.comment.reply")
+                        span.setAttribute("larkin.operation.outcome", "error");
+                    span.setStatus({ code: SpanStatusCode.ERROR });
+                    throw error;
+                })
+                    .finally(() => span.end());
+            }
+            recordOutcome(result);
+            span.end();
+            return result;
+        },
+        async shutdown() {
+            uploader?.stop();
+            clearInterval(ownershipTimer);
+            for (const current of new Set(messages.values()))
+                endTrace(current, true);
+            for (const stateDir of initializedStateDirs) {
+                try {
+                    const owner = JSON.parse(fs.readFileSync(generationFile(stateDir), "utf8"));
+                    if (owner.generation !== runtimeGeneration)
+                        continue;
+                    for (const file of [activeContextFile(stateDir), generationFile(stateDir)]) {
+                        try {
+                            fs.unlinkSync(file);
+                        }
+                        catch (error) {
+                            if (error.code !== "ENOENT")
+                                throw error;
+                        }
+                    }
+                }
+                catch { /* isolated */ }
+            }
+            await provider.forceFlush().catch(() => { });
+            await provider.shutdown().catch(() => { });
+        },
+    };
+}
+let singleton = null;
+export function telemetrySingleton(config, options) {
+    if (!singleton && config)
+        singleton = createTelemetryRuntime(config, options);
+    return singleton ?? NOOP;
+}