@tickernelz/paperclip-pro-adapter-utils 2026.925.0

package/dist/acpx-engine/startup-timing.js

@@ -0,0 +1,616 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createHash } from "node:crypto";
+/**
+ * Structured event emitted once per named sandbox run-startup boundary so the
+ * duration of each bring-up step lands in the `heartbeat_run_events` stream
+ * (jsonb `payload`) beside the existing "run started" / "adapter invocation"
+ * anchors. Observability-only — it rides the existing
+ * `ctx.onEvent → onAdapterEvent → appendRunEvent` bridge with no schema change.
+ */
+export const RUN_STARTUP_STEP_EVENT_TYPE = "run.startup.step";
+/**
+ * The public built-in sandbox provider families. A key in this set is safe to
+ * emit as a low-cardinality span attribute. Any other key is operator-defined
+ * (plugin-backed) and unbounded, so `normalizeProviderFamily` maps it to the
+ * generic value `plugin`. Keep this list closed and small.
+ */
+const BUILT_IN_PROVIDER_FAMILIES = new Set([
+    "daytona",
+    "kubernetes",
+    "e2b",
+    "cloudflare",
+    "exe-dev",
+    "modal",
+    "novita",
+]);
+/** The generic family for any provider key outside the built-in list. */
+const PLUGIN_PROVIDER_FAMILY = "plugin";
+/**
+ * Map a raw provider key to a low-cardinality public family. Return the key
+ * unchanged when it is a built-in family. Return `plugin` for every other
+ * value, so an operator-defined plugin key never becomes an unbounded span
+ * attribute. A missing or empty key also maps to `plugin`.
+ */
+export function normalizeProviderFamily(key) {
+    if (key && BUILT_IN_PROVIDER_FAMILIES.has(key))
+        return key;
+    return PLUGIN_PROVIDER_FAMILY;
+}
+/**
+ * The common prefix for every sandbox-startup span attribute. One prefix keeps
+ * the attribute namespace closed and easy to find in the OpenTelemetry backend.
+ */
+export const SANDBOX_STARTUP_SPAN_ATTR_PREFIX = "paperclip.sandbox.startup.";
+/**
+ * The closed attribute-name contract for every sandbox-startup span. This is
+ * the single source of truth for the harness span attributes. Each name uses
+ * the `paperclip.sandbox.startup.` prefix and a type suffix:
+ *
+ * - `*.wall_ms` — one wall-clock time in float milliseconds.
+ * - `*.count` — a count.
+ *
+ * The producer sets only these keys. It never sets a free-form key, so a
+ * command, a path, an argument, or an environment value can never ride a span.
+ */
+export const SANDBOX_STARTUP_SPAN_ATTRS = {
+    /** The low-cardinality provider family (through `normalizeProviderFamily`). */
+    provider: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}provider`,
+    /** The step or execution outcome: `ok`, `skipped`, or `failed`. */
+    outcome: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}outcome`,
+    /** The wall-clock time of one measured step. */
+    stepWallMs: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}step.wall_ms`,
+    /** The clamped `argv[0]` command label of one execution. */
+    execCommand: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}exec.command`,
+    /** The numeric process exit code of one execution. */
+    execExitCode: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}exec.exit_code`,
+    /** The host-measured wall time of one execution. */
+    execWallMs: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}exec.wall_ms`,
+    /** The provider handle-fetch wait before one execution ran. */
+    execWaitBeforeMs: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}exec.wait_before_ms`,
+    /** The in-sandbox run time of one execution. */
+    execSandboxMs: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}exec.sandbox_ms`,
+    /** The transport time the host adds around one execution. */
+    execNetworkMs: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}exec.network_ms`,
+    /** Whether one execution sits on the startup critical path. */
+    execCriticalPath: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}exec.critical_path`,
+    /** Whether the provider served the sandbox handle from its warm cache. */
+    execCacheHit: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}exec.cache_hit`,
+    /** The root-span wall time of the whole bring-up. */
+    rootWallMs: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}root.wall_ms`,
+    /** The sum of the step wall times of the whole bring-up. */
+    rootWorkMs: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}root.work_ms`,
+    /** The difference between the work sum and the wall time (overlap). */
+    rootDiffMs: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}root.diff_ms`,
+    /** Whether this bring-up is a cold start (no warm handle). */
+    coldStart: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}cold_start`,
+    /** The clamped region label (through `clampSpanLabel`). */
+    region: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}region`,
+    /** The hashed image-id label (through `clampSpanLabel`). */
+    imageId: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}image_id`,
+    /** The hashed sandbox-id label (through `clampSpanLabel`). */
+    sandboxId: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}sandbox_id`,
+    /** The hashed lease-id label (through `clampSpanLabel`). */
+    leaseId: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}lease_id`,
+    /** The create-runtime sub-time of the `acp.handshake` step. */
+    handshakeCreateRuntimeWallMs: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}handshake.create_runtime.wall_ms`,
+    /** The ensure-session sub-time of the `acp.handshake` step. */
+    handshakeEnsureSessionWallMs: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}handshake.ensure_session.wall_ms`,
+    /** A shared low-cardinality tag that marks two steps as one parallel batch. */
+    batch: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}batch`,
+    /** The host-local wall time of the pack step (build the tarball). */
+    packWallMs: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}pack.wall_ms`,
+    /** The wall time of the transfer step (upload the files to the sandbox). */
+    transferWallMs: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}transfer.wall_ms`,
+    /** The number of serial guard round trips before one transfer. */
+    transferGuardCount: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}transfer.guard.count`,
+    /** The transfer direction: `inbound` for an upload to the sandbox, `outbound`
+     * for a download from the sandbox. The parent span carries operation identity,
+     * so the transfer span never carries an operation label. The value stays in a
+     * closed set, so the attribute cardinality is bounded. */
+    transferDirection: `${SANDBOX_STARTUP_SPAN_ATTR_PREFIX}transfer.direction`,
+};
+/** The closed value set for the `outcome` attribute. */
+export const SANDBOX_STARTUP_OUTCOME = {
+    ok: "ok",
+    skipped: "skipped",
+    failed: "failed",
+};
+/**
+ * The known command labels. A raw `argv[0]` outside this set maps to `other`,
+ * so a full command line, a path, or an argument never rides a span. Keep this
+ * list closed and small; a new command that is safe to name adds one entry.
+ */
+const KNOWN_COMMAND_LABELS = new Set([
+    "sh",
+    "bash",
+    "env",
+    "mkdir",
+    "rm",
+    "mv",
+    "cp",
+    "ln",
+    "cat",
+    "echo",
+    "printf",
+    "test",
+    "chmod",
+    "true",
+    "tar",
+    "git",
+    "node",
+    "npm",
+    "pnpm",
+    "sudo",
+    "bwrap",
+]);
+/**
+ * The known region labels. A raw region outside this set maps to `unknown`, so
+ * a free-form region string never widens the attribute cardinality. Keep this
+ * list closed; a new supported region adds one entry.
+ */
+const KNOWN_REGION_LABELS = new Set([
+    "us-east-1",
+    "us-east-2",
+    "us-west-1",
+    "us-west-2",
+    "eu-west-1",
+    "eu-central-1",
+    "ap-southeast-1",
+    "ap-southeast-2",
+    "ap-northeast-1",
+]);
+/** The fallback value for a raw command outside the known-command allowlist. */
+const OTHER_COMMAND_LABEL = "other";
+/** The fallback value for a raw region outside the known-region allowlist. */
+const UNKNOWN_REGION_LABEL = "unknown";
+/**
+ * Map a raw label value to a non-reversible short hash. An id or an image
+ * reference can hold an internal codename or a secret-like string, so the span
+ * carries a hash, never the raw value. The hash is a stable 12-hex-character
+ * prefix of the SHA-256 digest; it is not reversible and it is low-collision
+ * for correlation.
+ */
+function hashLabelValue(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+/**
+ * Bound a span label value to a closed, low-cardinality set. This is the one
+ * boundary function for every free-form label. It is a hard-coded per-label
+ * map, the same pattern as `normalizeProviderFamily`:
+ *
+ * - `command` — a known command basename maps to itself; any other value maps
+ *   to `other`, so a full command line, a path, or an argument never leaks.
+ * - `region` — a known region maps to itself; any other value maps to
+ *   `unknown`.
+ * - `image_id` / `sandbox_id` / `lease_id` — the raw value maps to a
+ *   non-reversible short hash, because it can hold an internal codename or a
+ *   secret-like string, and the telemetry backend may index it.
+ *
+ * An unknown label name returns `undefined`, so the caller drops it. A missing
+ * value for a hashed label returns `undefined` too (fail open — never a raw
+ * value, never an empty attribute).
+ */
+export function clampSpanLabel(name, value) {
+    switch (name) {
+        case "command":
+            return value !== undefined && KNOWN_COMMAND_LABELS.has(value)
+                ? value
+                : OTHER_COMMAND_LABEL;
+        case "region":
+            return value !== undefined && KNOWN_REGION_LABELS.has(value)
+                ? value
+                : UNKNOWN_REGION_LABEL;
+        case "image_id":
+        case "sandbox_id":
+        case "lease_id":
+            return value && value.length > 0 ? hashLabelValue(value) : undefined;
+        default:
+            return undefined;
+    }
+}
+/**
+ * The value of `SpanStatusCode.ERROR` in `@opentelemetry/api`. `adapter-utils`
+ * stays OTel-free, so the timing helper uses the numeric value directly. A real
+ * injected OTel span reads it as the error status.
+ */
+const SPAN_STATUS_CODE_ERROR = 2;
+/** A shared no-op span. It implements the structural span contract and does
+ * nothing, so a caller with no injected tracer changes no behavior. */
+export const NOOP_STARTUP_SPAN = {
+    setAttribute() { },
+    setStatus() { },
+    end() { },
+};
+const NOOP_SPAN = NOOP_STARTUP_SPAN;
+/**
+ * The default tracer. It opens no real span, so `measureStartupStep` behaves
+ * exactly as before when the caller injects no tracer.
+ */
+const NOOP_TRACER = {
+    startSpan: () => NOOP_SPAN,
+};
+/**
+ * The default trace context. Its tracer is a no-op and it produces no parent
+ * token, so the engine emits no spans until the server injects a real
+ * implementation.
+ */
+export const NOOP_STARTUP_TRACE_CONTEXT = {
+    tracer: NOOP_TRACER,
+    contextWithSpan: () => undefined,
+};
+/**
+ * The one storage for the active step context. `measureStartupStep` runs the
+ * step body inside it; inner code reads it with `getActiveStepContext()`. It is
+ * a module-level singleton, so the value propagates across `await` boundaries
+ * and across package boundaries that share this module.
+ */
+const activeStepContextStorage = new AsyncLocalStorage();
+/**
+ * Return the active step context, or `null` when no measured step is running.
+ * Inner code parents a child span to the step span through
+ * `getActiveStepContext()?.parentContext`. A `null` result is a no-op: the
+ * caller opens no child span or opens an unparented span.
+ */
+export function getActiveStepContext() {
+    return activeStepContextStorage.getStore() ?? null;
+}
+/**
+ * Run `work` with no active step context, then restore the previous store. A
+ * bridge boundary uses this to start its long-lived poll timer and socket
+ * handlers outside the measured step store.
+ *
+ * Node snapshots the active store on each async resource at creation time. So a
+ * timer or a handler scheduled inside a measured step body keeps that step store
+ * after the step span ends. A later run-time exec then reads the ended step and
+ * parents its `sandbox.exec` span to a dead startup step, and it copies the
+ * step's `criticalPath` flag. This helper resets the store for the wrapped work,
+ * so each continuation reads an empty store. Each run-time exec then opens an
+ * unparented span with no stale `criticalPath` flag.
+ *
+ * The helper forwards only the opaque store, so this package stays free of
+ * `@opentelemetry/api`. It needs no Node version gate.
+ */
+export function runWithoutActiveStep(work) {
+    return activeStepContextStorage.run(undefined, work);
+}
+/**
+ * Build the minimal active step context that the store publishes. The step path
+ * and `runWithRuntimeParent` share this builder, so both write the same shape.
+ */
+function buildActiveStepContext(span, parentContext, criticalPath) {
+    return { span, parentContext, criticalPath };
+}
+/**
+ * Run `work` under a given parent-context token, then restore the previous
+ * store. A run-time exec that reads `getActiveStepContext()` inside `work`
+ * parents its span to `parentContext`, not to a startup step. The store carries
+ * the no-op span, because there is no open step span at run time. It sets
+ * `criticalPath` to `false`, because a run-time exec is not on the startup
+ * critical path.
+ *
+ * When `parentContext` is `undefined`, the helper empties the store, exactly
+ * like `runWithoutActiveStep`. Inner code then reads `null` and opens an
+ * unparented span.
+ *
+ * The helper forwards only the opaque token, so this package stays free of
+ * `@opentelemetry/api`.
+ */
+export function runWithRuntimeParent(parentContext, work) {
+    if (parentContext === undefined) {
+        return activeStepContextStorage.run(undefined, work);
+    }
+    const activeStep = buildActiveStepContext(NOOP_SPAN, parentContext, false);
+    return activeStepContextStorage.run(activeStep, work);
+}
+/**
+ * Build a {@link RuntimeSpanRunner} from a trace context and the run-parent
+ * getter. The runner opens the wrapper span through `traceContext.tracer`, and
+ * it derives the wrapper span's child parent token through
+ * `traceContext.contextWithSpan`. A no-op trace context yields a runner that
+ * opens no real span and runs `work` under the current run parent, so the span
+ * path stays inert until the server injects a real tracer. Every tracer call
+ * sits inside an error swallow, so a throwing tracer never changes control flow.
+ */
+export function createRuntimeSpanRunner(traceContext, getRuntimeParentContext) {
+    return async (name, work) => {
+        const parentContext = getRuntimeParentContext();
+        let span;
+        try {
+            span = traceContext.tracer.startSpan(name, undefined, parentContext);
+        }
+        catch {
+            // A throwing tracer must not change control flow; run `work` unwrapped.
+            return runWithRuntimeParent(parentContext, work);
+        }
+        let childContext;
+        try {
+            childContext = traceContext.contextWithSpan(span);
+        }
+        catch {
+            childContext = parentContext;
+        }
+        let failed = false;
+        try {
+            return await runWithRuntimeParent(childContext, work);
+        }
+        catch (err) {
+            failed = true;
+            throw err;
+        }
+        finally {
+            try {
+                if (failed)
+                    span.setStatus({ code: SPAN_STATUS_CODE_ERROR });
+                span.end();
+            }
+            catch {
+                // Observability must not change control flow.
+            }
+        }
+    };
+}
+/**
+ * Set a numeric span attribute only when the value is a finite number. A reader
+ * that returns `undefined` (the counter is unavailable) yields no attribute,
+ * never `NaN` and never a misleading `0`. This mirrors the host counter guard
+ * at `environment-execution-target.ts`.
+ */
+function setFiniteNumberAttr(span, key, value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        span.setAttribute(key, value);
+    }
+}
+function buildStepEvent(payload) {
+    const step = String(payload.step);
+    const durationMs = payload.durationMs;
+    return {
+        eventType: RUN_STARTUP_STEP_EVENT_TYPE,
+        stream: "system",
+        level: "info",
+        message: `startup step: ${step} (${durationMs}ms)`,
+        payload,
+    };
+}
+/**
+ * Time `fn` with the injected `now` clock and emit exactly one
+ * `run.startup.step` event carrying only the high-level `{ step, durationMs,
+ * outcome }`. The event fires in a `finally`, so a throwing step
+ * still reports its duration before the error is re-thrown. `now` is injected
+ * (never `Date.now()` here) so callers/tests stay deterministic, and
+ * `ctx.onEvent` is optional — a missing sink is a no-op that neither throws nor
+ * swallows `fn`'s return value or error. A step skipped by a warm cache never
+ * calls this helper, so it emits no event (never a zero).
+ *
+ * When `options.tracer` is injected, the helper also opens one span at `start`
+ * and ends it in the `finally`. The span carries a closed attribute allowlist
+ * from `SANDBOX_STARTUP_SPAN_ATTRS`: the normalized `provider`, the step wall
+ * time, and the outcome (`ok` or `failed`). The step name rides the span name.
+ * A throwing `fn` sets the span error status before the span ends and the
+ * outcome is `failed`. The round-trip and provider-duration detail rides the
+ * spans, not the payload. The tracer
+ * defaults to a no-op, so a caller with no tracer changes nothing. Every span
+ * call sits inside the same error swallow as the event sink, so a throwing
+ * tracer never changes startup control flow.
+ */
+export async function measureStartupStep(ctx, now, step, fn, options = {}) {
+    const start = now();
+    // Open the span with only the low-cardinality allowlisted attributes known at
+    // the start: the normalized provider family. The span name already carries
+    // the step name, so no redundant `step` attribute rides the span.
+    const tracer = options.tracer ?? NOOP_TRACER;
+    const startAttributes = {};
+    if (options.provider !== undefined) {
+        startAttributes[SANDBOX_STARTUP_SPAN_ATTRS.provider] = normalizeProviderFamily(options.provider);
+    }
+    if (options.batch !== undefined) {
+        startAttributes[SANDBOX_STARTUP_SPAN_ATTRS.batch] = options.batch;
+    }
+    let span;
+    try {
+        span = tracer.startSpan(step, { attributes: startAttributes }, options.parentContext);
+    }
+    catch {
+        // A throwing tracer must not change startup control flow.
+        span = NOOP_SPAN;
+    }
+    // Publish the active step context while `fn` runs. Inner code (the host→
+    // sandbox exec seam) reads it to parent an exec span to this step span. The
+    // parent token is the step span's own child context; a missing
+    // `contextWithSpan` (no injected trace context) yields `undefined`, so an
+    // inner exec span opens unparented — a no-op when tracing is off. The
+    // `contextWithSpan` call is guarded, so a throwing helper never changes
+    // startup control flow.
+    let stepChildContext;
+    try {
+        stepChildContext = options.contextWithSpan?.(span);
+    }
+    catch {
+        stepChildContext = undefined;
+    }
+    const activeStep = buildActiveStepContext(span, stepChildContext, options.criticalPath ?? true);
+    let stepFailed = false;
+    try {
+        return await activeStepContextStorage.run(activeStep, fn);
+    }
+    catch (err) {
+        stepFailed = true;
+        throw err;
+    }
+    finally {
+        const durationMs = now() - start;
+        // The step outcome. A throwing `fn` is `failed`; a settled `fn` is `ok`. A
+        // step that a warm cache skips uses `emitSkippedStartupStep` instead.
+        const outcome = stepFailed
+            ? SANDBOX_STARTUP_OUTCOME.failed
+            : SANDBOX_STARTUP_OUTCOME.ok;
+        // The payload carries only the high-level fields. The detailed per-step
+        // round-trip and provider-duration numbers ride the OTel spans now, so the
+        // run-log copy is gone.
+        const payload = { step, durationMs, outcome };
+        try {
+            if (stepFailed)
+                span.setStatus({ code: SPAN_STATUS_CODE_ERROR });
+            // The step span carries only the step wall time and the outcome. The
+            // per-execution `sandbox.exec` child spans now carry the round-trip and
+            // provider-duration detail, so the step span no longer duplicates them.
+            setFiniteNumberAttr(span, SANDBOX_STARTUP_SPAN_ATTRS.stepWallMs, durationMs);
+            span.setAttribute(SANDBOX_STARTUP_SPAN_ATTRS.outcome, outcome);
+            if (options.spanWallTimes) {
+                // Map each named sub-time to a hard-coded, closed attribute key, so a
+                // caller cannot widen the span allowlist with a free-form key.
+                const sub = options.spanWallTimes();
+                setFiniteNumberAttr(span, SANDBOX_STARTUP_SPAN_ATTRS.handshakeCreateRuntimeWallMs, sub.createRuntime);
+                setFiniteNumberAttr(span, SANDBOX_STARTUP_SPAN_ATTRS.handshakeEnsureSessionWallMs, sub.ensureSession);
+            }
+            span.end();
+        }
+        catch {
+            // Observability must not change startup control flow.
+        }
+        try {
+            options.onWallMs?.(durationMs);
+        }
+        catch {
+            // Observability must not change startup control flow.
+        }
+        try {
+            await ctx.onEvent?.(buildStepEvent(payload));
+        }
+        catch {
+            // Observability must not change startup control flow.
+        }
+    }
+}
+/**
+ * Assemble every root-span (`sandbox.startup`) attribute in one place. This is
+ * the single producer-side boundary for the root span: it sets only the closed
+ * `paperclip.sandbox.startup.` allowlist. It records the wall, work, and diff
+ * times, and the bounded context. A raw id, an image reference, or a region
+ * never rides the span un-bounded, and an absent value sets no attribute.
+ */
+export function setSandboxRootSpanAttributes(span, timings, context) {
+    const A = SANDBOX_STARTUP_SPAN_ATTRS;
+    setFiniteNumberAttr(span, A.rootWallMs, timings.wallMs);
+    setFiniteNumberAttr(span, A.rootWorkMs, timings.workMs);
+    setFiniteNumberAttr(span, A.rootDiffMs, timings.workMs - timings.wallMs);
+    if (context.coldStart !== undefined)
+        span.setAttribute(A.coldStart, context.coldStart);
+    if (context.provider !== undefined) {
+        span.setAttribute(A.provider, normalizeProviderFamily(context.provider));
+    }
+    // A region rides only when a value is present; an unknown region maps to
+    // `unknown`, never a free-form string.
+    if (context.region !== undefined) {
+        const region = clampSpanLabel("region", context.region);
+        if (region !== undefined)
+            span.setAttribute(A.region, region);
+    }
+    // The image id and the ids ride only as non-reversible hashes.
+    const imageId = clampSpanLabel("image_id", context.imageId);
+    if (imageId !== undefined)
+        span.setAttribute(A.imageId, imageId);
+    const sandboxId = clampSpanLabel("sandbox_id", context.sandboxId);
+    if (sandboxId !== undefined)
+        span.setAttribute(A.sandboxId, sandboxId);
+    const leaseId = clampSpanLabel("lease_id", context.leaseId);
+    if (leaseId !== undefined)
+        span.setAttribute(A.leaseId, leaseId);
+}
+/**
+ * Emit one `run.startup.step` span and event for a step that a warm cache
+ * skips, with `outcome = skipped` and a zero wall time. A skipped step runs no
+ * work, so this helper opens and ends the span without a body. It shows the
+ * skip as a real, distinct outcome, never a misleading zero-work `ok` step.
+ *
+ * The span and the event carry the closed allowlist: the step name (the span
+ * name), the normalized `provider` (when given), `step.wall_ms = 0`, and
+ * `outcome = skipped`. Every tracer and sink call sits inside an error swallow,
+ * so a throwing tracer or sink never changes startup control flow. The tracer
+ * defaults to a no-op, so a caller with no tracer only emits the event.
+ */
+export async function emitSkippedStartupStep(ctx, step, options = {}) {
+    const tracer = options.tracer ?? NOOP_TRACER;
+    const startAttributes = {};
+    if (options.provider !== undefined) {
+        startAttributes[SANDBOX_STARTUP_SPAN_ATTRS.provider] = normalizeProviderFamily(options.provider);
+    }
+    let span;
+    try {
+        span = tracer.startSpan(step, { attributes: startAttributes }, options.parentContext);
+    }
+    catch {
+        span = NOOP_SPAN;
+    }
+    try {
+        span.setAttribute(SANDBOX_STARTUP_SPAN_ATTRS.stepWallMs, 0);
+        span.setAttribute(SANDBOX_STARTUP_SPAN_ATTRS.outcome, SANDBOX_STARTUP_OUTCOME.skipped);
+        span.end();
+    }
+    catch {
+        // Observability must not change startup control flow.
+    }
+    try {
+        await ctx.onEvent?.(buildStepEvent({ step, durationMs: 0, outcome: SANDBOX_STARTUP_OUTCOME.skipped }));
+    }
+    catch {
+        // Observability must not change startup control flow.
+    }
+}
+/**
+ * Structured event emitted once per named run-lifecycle phase, so the duration
+ * and the outcome of each phase land in the run-events stream. It is a
+ * run-log event and rides the existing `ctx.onEvent` bridge. It never changes
+ * startup control flow. The payload is a closed shape: exactly `phase`,
+ * `durationMs`, and `outcome`. The phase name is from a closed allowlist, so
+ * the event never carries a command, an argument, a path, an environment
+ * value, or a raw identifier.
+ */
+export const RUN_PHASE_TIMING_EVENT_TYPE = "run.phase.timing";
+/**
+ * The closed set of run-lifecycle phase names. A phase-timing event may name only
+ * one of these. The list is fixed and low-cardinality; it never derives from run
+ * or user data.
+ */
+export const RUN_PHASE_NAMES = [
+    "place_workspace",
+    "start_transport",
+    "create_runtime",
+    "ensure_session",
+    "configure_session",
+    "prepare_turn",
+    "turn",
+    "end_session",
+    "settle_reuse",
+    "stop_transport",
+    "sync_back",
+    "release_staging_lease",
+];
+const RUN_PHASE_NAME_SET = new Set(RUN_PHASE_NAMES);
+/**
+ * Emit exactly one `run.phase.timing` event for a run-lifecycle phase. The
+ * payload carries only `phase`, `durationMs`, and `outcome`. It never carries a
+ * command, an argument, a path, an environment value, or a raw identifier. The
+ * phase name must be one member of the closed allowlist; a name outside the
+ * allowlist emits nothing, so a free-form label can never reach the stream. A
+ * negative or a non-finite duration clamps to 0. Every sink call sits inside an
+ * error swallow, so a throwing telemetry sink never fails the run.
+ */
+export async function emitRunPhaseTiming(ctx, phase, durationMs, outcome) {
+    if (!RUN_PHASE_NAME_SET.has(phase))
+        return;
+    const safeDuration = Number.isFinite(durationMs) && durationMs > 0 ? durationMs : 0;
+    const event = {
+        eventType: RUN_PHASE_TIMING_EVENT_TYPE,
+        stream: "system",
+        level: "info",
+        message: `run phase: ${phase} (${safeDuration}ms)`,
+        payload: { phase, durationMs: safeDuration, outcome },
+    };
+    try {
+        await ctx.onEvent?.(event);
+    }
+    catch {
+        // Telemetry never fails the run.
+    }
+}
+//# sourceMappingURL=startup-timing.js.map

package/dist/acpx-engine/startup-timing.js.map

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

package/dist/acpx-engine/startup-timing.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=startup-timing.test.d.ts.map

package/dist/acpx-engine/startup-timing.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startup-timing.test.d.ts","sourceRoot":"","sources":["../../src/acpx-engine/startup-timing.test.ts"],"names":[],"mappings":""}