@pome-sh/cli 0.2.0 → 0.4.0

package/node_modules/@pome-sh/twin-gmail/node_modules/@pome-sh/shared-types/dist/otel/legacy-shim.d.ts

@@ -0,0 +1,100 @@
+/**
+ * otel/legacy-shim — legacy event → `OtelSpanEvent` translation (M1.2 / FDRS-481).
+ *
+ * The compatibility layer for the transition window: the CLI keeps uploading its
+ * current JSONL (no flag day), and OTel-aware downstream (M3 correlation, the
+ * native waterfall) reads `OtelSpanEvent`. This shim translates the three legacy
+ * variants — `TwinHttpEvent`, `LlmCallEvent`, `ToolUseEvent` — up into spans so
+ * legacy and new data share one path.
+ *
+ * Guarantees:
+ *   - **Lossless.** The ENTIRE original record is preserved verbatim as a JSON
+ *     string under `attributes["pome.legacy.record_json"]` — serialized from the
+ *     raw input BEFORE Zod strips any additive fields (review finding #3). The
+ *     mapped fields are ALSO written as canonical OTel attributes, from which
+ *     the typed projections are derived by the SAME projector the schema checks.
+ *   - **Deterministic.** No clock, no randomness. Same record (+ same `run_id`
+ *     option) → byte-identical span, every run.
+ *   - **OTel-correct status** (review findings #5/#9). HTTP client spans: 1xx–3xx
+ *     leave status UNSET; 4xx/5xx and transport errors are ERROR. (OTel does not
+ *     set OK on a merely-successful span.)
+ *
+ * IDs are namespaced `legacy:<source-id>` so a stored span always declares it
+ * originated from a pre-OTel record (the canonical schema accepts either real
+ * W3C ids or `legacy:` ids).
+ *
+ * Pinned convention: the shim targets `OTEL_GENAI_SCHEMA_VERSION` (see `./semconv`).
+ */
+import { z } from "zod";
+import { type OtelSpanEvent } from "./span-event.js";
+export declare const LEGACY_SHIM_SEMCONV_VERSION: "1.42.0";
+export declare const LEGACY_ATTR_NAMESPACE: "pome.legacy";
+export declare const LEGACY_ID_PREFIX: "legacy:";
+export declare const shimmableLegacyEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    ts: z.ZodString;
+    run_id: z.ZodString;
+    twin: z.ZodString;
+    request_id: z.ZodString;
+    correlation_id: z.ZodOptional<z.ZodString>;
+    task_step_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    scenario_step_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    step_id: z.ZodNullable<z.ZodString>;
+    tool_call_id: z.ZodNullable<z.ZodString>;
+    method: z.ZodString;
+    path: z.ZodString;
+    request_body: z.ZodUnknown;
+    status: z.ZodNumber;
+    response_body: z.ZodUnknown;
+    latency_ms: z.ZodNumber;
+    fidelity: z.ZodEnum<{
+        semantic: "semantic";
+        unsupported: "unsupported";
+    }>;
+    state_mutation: z.ZodBoolean;
+    state_delta: z.ZodNullable<z.ZodObject<{
+        before: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        after: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    idempotency_dedupe: z.ZodOptional<z.ZodBoolean>;
+    error: z.ZodNullable<z.ZodString>;
+    kind: z.ZodLiteral<"TwinHttpEvent">;
+    event_id: z.ZodString;
+    parent_id: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"LlmCallEvent">;
+    host: z.ZodString;
+    port: z.ZodNumber;
+    latency_ms: z.ZodNumber;
+    bytes_in: z.ZodNumber;
+    bytes_out: z.ZodNumber;
+    url: z.ZodNullable<z.ZodString>;
+    method: z.ZodNullable<z.ZodString>;
+    status: z.ZodNullable<z.ZodNumber>;
+    model: z.ZodNullable<z.ZodString>;
+    prompt_tokens: z.ZodNullable<z.ZodNumber>;
+    completion_tokens: z.ZodNullable<z.ZodNumber>;
+    cost_usd: z.ZodNullable<z.ZodNumber>;
+    ts: z.ZodString;
+    event_id: z.ZodString;
+    parent_id: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"ToolUseEvent">;
+    tool_use_id: z.ZodString;
+    tool_name: z.ZodString;
+    input: z.ZodUnknown;
+    ts: z.ZodString;
+    event_id: z.ZodString;
+    parent_id: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>], "kind">;
+export type ShimmableLegacyEvent = z.infer<typeof shimmableLegacyEventSchema>;
+export interface LegacyShimOptions {
+    run_id?: string;
+}
+/**
+ * Translate a single legacy `TwinHttpEvent` / `LlmCallEvent` / `ToolUseEvent`
+ * into a validated `OtelSpanEvent`.
+ *
+ * Throws a typed `ZodError` if `rawRecord` is not one of those three shapes,
+ * or a plain `Error` if an LLM/tool record is missing the required `run_id`.
+ */
+export declare function shimLegacyEventToSpan(rawRecord: unknown, options?: LegacyShimOptions): OtelSpanEvent;

package/node_modules/@pome-sh/twin-gmail/node_modules/@pome-sh/shared-types/dist/otel/legacy-shim.js

@@ -0,0 +1,193 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * otel/legacy-shim — legacy event → `OtelSpanEvent` translation (M1.2 / FDRS-481).
+ *
+ * The compatibility layer for the transition window: the CLI keeps uploading its
+ * current JSONL (no flag day), and OTel-aware downstream (M3 correlation, the
+ * native waterfall) reads `OtelSpanEvent`. This shim translates the three legacy
+ * variants — `TwinHttpEvent`, `LlmCallEvent`, `ToolUseEvent` — up into spans so
+ * legacy and new data share one path.
+ *
+ * Guarantees:
+ *   - **Lossless.** The ENTIRE original record is preserved verbatim as a JSON
+ *     string under `attributes["pome.legacy.record_json"]` — serialized from the
+ *     raw input BEFORE Zod strips any additive fields (review finding #3). The
+ *     mapped fields are ALSO written as canonical OTel attributes, from which
+ *     the typed projections are derived by the SAME projector the schema checks.
+ *   - **Deterministic.** No clock, no randomness. Same record (+ same `run_id`
+ *     option) → byte-identical span, every run.
+ *   - **OTel-correct status** (review findings #5/#9). HTTP client spans: 1xx–3xx
+ *     leave status UNSET; 4xx/5xx and transport errors are ERROR. (OTel does not
+ *     set OK on a merely-successful span.)
+ *
+ * IDs are namespaced `legacy:<source-id>` so a stored span always declares it
+ * originated from a pre-OTel record (the canonical schema accepts either real
+ * W3C ids or `legacy:` ids).
+ *
+ * Pinned convention: the shim targets `OTEL_GENAI_SCHEMA_VERSION` (see `./semconv`).
+ */
+import { z } from "zod";
+import { llmCallEventSchema, toolUseEventSchema, twinHttpEventSchema, } from "../recorder-events.js";
+import { msToNanos, nanosToIso } from "./nano.js";
+import { projectAttributes, } from "./project.js";
+import { ERROR_TYPE, GEN_AI_OPERATION_NAME, GEN_AI_REQUEST_MODEL, GEN_AI_TOOL_NAME, GEN_AI_USAGE_INPUT_TOKENS, GEN_AI_USAGE_OUTPUT_TOKENS, HTTP_REQUEST_METHOD, HTTP_RESPONSE_STATUS_CODE, OTEL_GENAI_SCHEMA_VERSION, SERVER_ADDRESS, SERVER_PORT, URL_FULL, URL_PATH, } from "./semconv.js";
+import { otelSpanEventSchema } from "./span-event.js";
+// The shim targets this pinned GenAI convention version (from M1.1). This
+// re-export makes the pin explicit and testable.
+export const LEGACY_SHIM_SEMCONV_VERSION = OTEL_GENAI_SCHEMA_VERSION;
+// The documented namespace for legacy provenance. `record_json` is the lossless
+// source of truth; `kind` records the originating legacy variant.
+export const LEGACY_ATTR_NAMESPACE = "pome.legacy";
+export const LEGACY_ID_PREFIX = "legacy:";
+const ATTR_LEGACY_KIND = `${LEGACY_ATTR_NAMESPACE}.kind`;
+const ATTR_LEGACY_RECORD_JSON = `${LEGACY_ATTR_NAMESPACE}.record_json`;
+// The legacy variants this shim accepts. Discriminated on `kind`.
+//
+// NOT-SHIMMABLE-IN-M1: `HookEvent`, `ToolResultEvent`, `SubagentSpawnEvent`, and
+// `LlmTurnEvent` (F-766) are intentionally absent. They are captured into
+// events.jsonl but not projected to spans yet — the M2 projection layer adds
+// full coverage (LlmTurnEvent → a `chat` span carrying the cache-token
+// attributes; ToolResult pairs into its execute_tool span; etc.). Until then
+// `shimLegacyEventToSpan` rejects these kinds with a typed ZodError rather than
+// emitting a lossy span. The otel-legacy-shim test locks this deliberately.
+export const shimmableLegacyEventSchema = z.discriminatedUnion("kind", [
+    twinHttpEventSchema,
+    llmCallEventSchema,
+    toolUseEventSchema,
+]);
+// `legacy:`-namespace a non-OTel source id. Idempotent if already namespaced.
+function legacyId(sourceId) {
+    return sourceId.startsWith(LEGACY_ID_PREFIX) ? sourceId : `${LEGACY_ID_PREFIX}${sourceId}`;
+}
+// Resolve the legacy run id used as the trace grouping key.
+function resolveRunId(options, record) {
+    if (options.run_id !== undefined) {
+        return options.run_id;
+    }
+    if (record.kind === "TwinHttpEvent") {
+        return record.run_id;
+    }
+    // No run context — LLM/tool rows carry none internally. Refusing here keeps
+    // related rows from each landing in their own orphan trace.
+    throw new Error(`legacy-shim: ${record.kind} requires options.run_id for trace context`);
+}
+// Drop null/undefined entries so the bag stays a valid attribute record (the
+// attribute schema has no null member — an absent attribute is omitted).
+function buildBag(entries) {
+    const bag = {};
+    for (const [key, value] of Object.entries(entries)) {
+        if (value !== null && value !== undefined)
+            bag[key] = value;
+    }
+    return bag;
+}
+// OTel HTTP client span status: success (incl. redirects) stays UNSET; 4xx/5xx
+// and transport errors are ERROR (review #9). Returns the status + the
+// low-cardinality `error.type` token to stamp on the bag.
+function httpStatus(status, error) {
+    if (error !== null)
+        return { code: "ERROR", errorType: "network_error" };
+    if (status >= 400)
+        return { code: "ERROR", errorType: String(status) };
+    return { code: "UNSET", errorType: null };
+}
+/**
+ * Translate a single legacy `TwinHttpEvent` / `LlmCallEvent` / `ToolUseEvent`
+ * into a validated `OtelSpanEvent`.
+ *
+ * Throws a typed `ZodError` if `rawRecord` is not one of those three shapes,
+ * or a plain `Error` if an LLM/tool record is missing the required `run_id`.
+ */
+export function shimLegacyEventToSpan(rawRecord, options = {}) {
+    const record = shimmableLegacyEventSchema.parse(rawRecord);
+    const startMs = Date.parse(record.ts);
+    const startNano = msToNanos(startMs);
+    const traceId = legacyId(resolveRunId(options, record));
+    const spanId = legacyId(record.event_id);
+    const parentSpanId = record.parent_id !== null ? legacyId(record.parent_id) : null;
+    // Lossless: serialize the RAW input (not the Zod-stripped record) so additive
+    // legacy fields survive round-trip.
+    const legacyNamespace = {
+        [ATTR_LEGACY_KIND]: record.kind,
+        [ATTR_LEGACY_RECORD_JSON]: JSON.stringify(rawRecord),
+    };
+    let name;
+    let spanKind;
+    let endNano;
+    let statusCode;
+    let statusMessage;
+    let semanticAttrs;
+    if (record.kind === "TwinHttpEvent") {
+        const status = httpStatus(record.status, record.error);
+        // Low-cardinality span name: HTTP method only (the concrete path is a high-
+        // cardinality URL, not a route template) — review #4.
+        name = record.method;
+        spanKind = "CLIENT";
+        endNano = msToNanos(startMs + record.latency_ms);
+        statusCode = status.code;
+        statusMessage = record.error;
+        semanticAttrs = buildBag({
+            [HTTP_REQUEST_METHOD]: record.method,
+            [HTTP_RESPONSE_STATUS_CODE]: record.status,
+            [URL_PATH]: record.path,
+            [ERROR_TYPE]: status.errorType,
+        });
+    }
+    else if (record.kind === "LlmCallEvent") {
+        // Asymmetry vs TwinHttpEvent (intentional, M1): a legacy LlmCallEvent has no
+        // transport-error field, so only an HTTP >=400 status drives ERROR here —
+        // a connection-level failure with a null status stays UNSET. M3 unifies on
+        // real OTel span status; until then LLM rows may under-report errors vs HTTP.
+        const errored = record.status !== null && record.status >= 400;
+        name = record.model !== null ? `chat ${record.model}` : "chat";
+        spanKind = "CLIENT";
+        endNano = msToNanos(startMs + record.latency_ms);
+        statusCode = errored ? "ERROR" : "UNSET";
+        statusMessage = null;
+        semanticAttrs = buildBag({
+            [GEN_AI_OPERATION_NAME]: "chat",
+            [GEN_AI_REQUEST_MODEL]: record.model,
+            [GEN_AI_USAGE_INPUT_TOKENS]: record.prompt_tokens,
+            [GEN_AI_USAGE_OUTPUT_TOKENS]: record.completion_tokens,
+            [HTTP_REQUEST_METHOD]: record.method,
+            [HTTP_RESPONSE_STATUS_CODE]: record.status,
+            [URL_FULL]: record.url,
+            [SERVER_ADDRESS]: record.host,
+            [SERVER_PORT]: record.port,
+            [ERROR_TYPE]: errored ? String(record.status) : null,
+        });
+    }
+    else {
+        // ToolUseEvent
+        name = `execute_tool ${record.tool_name}`;
+        spanKind = "INTERNAL";
+        endNano = null;
+        statusCode = "UNSET";
+        statusMessage = null;
+        semanticAttrs = buildBag({
+            [GEN_AI_OPERATION_NAME]: "execute_tool",
+            [GEN_AI_TOOL_NAME]: record.tool_name,
+        });
+    }
+    const attributes = { ...semanticAttrs, ...legacyNamespace };
+    const candidate = {
+        ts: nanosToIso(startNano),
+        event_id: spanId,
+        parent_id: parentSpanId,
+        kind: "OtelSpanEvent",
+        trace_id: traceId,
+        span_id: spanId,
+        parent_span_id: parentSpanId,
+        name,
+        span_kind: spanKind,
+        start_time_unix_nano: startNano,
+        end_time_unix_nano: endNano,
+        status_code: statusCode,
+        status_message: statusMessage,
+        ...projectAttributes(attributes),
+        attributes,
+    };
+    // Re-validate so the shim's output is provably a canonical `OtelSpanEvent`.
+    return otelSpanEventSchema.parse(candidate);
+}
+//# sourceMappingURL=legacy-shim.js.map

package/node_modules/@pome-sh/twin-gmail/node_modules/@pome-sh/shared-types/dist/otel/legacy-shim.js.map

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

package/node_modules/@pome-sh/twin-gmail/node_modules/@pome-sh/shared-types/dist/otel/map-span.d.ts

@@ -0,0 +1,64 @@
+/**
+ * otel/map-span — pure OTel span → `OtelSpanEvent` mapping (M1.1 / FDRS-480).
+ *
+ * Deterministic: same input → byte-identical event, every run. Has no clock,
+ * no randomness; `ts` is derived from the span's start time.
+ *
+ * Input is a NORMALIZED span: real W3C trace context (lowercase-hex ids) and a
+ * flat `attributes` `Record<string, value>`. Decoding raw OTLP/JSON `AnyValue`
+ * (`{ stringValue }`, kvlist, bytes) and the `[{ key, value }]` attribute array
+ * into this flat record is M2's job (the `@opentelemetry/otlp-transformer`
+ * dependency) — keeping M1.1 free of an OTLP decoder keeps the schema
+ * self-testable.
+ *
+ * Round-trip example:
+ *
+ *   mapOtelSpanToEvent({
+ *     trace_id: "4bf92f3577b34da6a3ce929d0e0e4736",
+ *     span_id: "00f067aa0ba902b7",
+ *     name: "chat google/gemini-2.5-flash",
+ *     start_time_unix_nano: "1700000000000000000",
+ *     attributes: {
+ *       "gen_ai.provider.name": "google",
+ *       "gen_ai.request.model": "gemini-2.5-flash",
+ *       "gen_ai.usage.input_tokens": 42,
+ *     },
+ *   })
+ *   // → { ts: "2023-11-14T22:13:20.000Z", event_id: "00f067aa0ba902b7", … }
+ */
+import { z } from "zod";
+import { type OtelSpanEvent } from "./span-event.js";
+export declare const otelSpanInputSchema: z.ZodObject<{
+    trace_id: z.ZodString;
+    span_id: z.ZodString;
+    parent_span_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    name: z.ZodString;
+    kind: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        UNSPECIFIED: "UNSPECIFIED";
+        INTERNAL: "INTERNAL";
+        SERVER: "SERVER";
+        CLIENT: "CLIENT";
+        PRODUCER: "PRODUCER";
+        CONSUMER: "CONSUMER";
+    }>, z.ZodNumber]>>;
+    start_time_unix_nano: z.ZodString;
+    end_time_unix_nano: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodOptional<z.ZodObject<{
+        code: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            UNSET: "UNSET";
+            OK: "OK";
+            ERROR: "ERROR";
+        }>, z.ZodNumber]>>;
+        message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    attributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>>>;
+}, z.core.$strip>;
+export type OtelSpanInput = z.infer<typeof otelSpanInputSchema>;
+/**
+ * Map a normalized OTLP span onto a validated `OtelSpanEvent`.
+ *
+ * Throws a `ZodError` (typed; names the offending field) when the input is
+ * malformed — a non-hex `trace_id`, an out-of-range unix-nano, a reversed span
+ * (end < start), a non-finite attribute value, etc.
+ */
+export declare function mapOtelSpanToEvent(rawSpan: unknown): OtelSpanEvent;

package/node_modules/@pome-sh/twin-gmail/node_modules/@pome-sh/shared-types/dist/otel/map-span.js

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * otel/map-span — pure OTel span → `OtelSpanEvent` mapping (M1.1 / FDRS-480).
+ *
+ * Deterministic: same input → byte-identical event, every run. Has no clock,
+ * no randomness; `ts` is derived from the span's start time.
+ *
+ * Input is a NORMALIZED span: real W3C trace context (lowercase-hex ids) and a
+ * flat `attributes` `Record<string, value>`. Decoding raw OTLP/JSON `AnyValue`
+ * (`{ stringValue }`, kvlist, bytes) and the `[{ key, value }]` attribute array
+ * into this flat record is M2's job (the `@opentelemetry/otlp-transformer`
+ * dependency) — keeping M1.1 free of an OTLP decoder keeps the schema
+ * self-testable.
+ *
+ * Round-trip example:
+ *
+ *   mapOtelSpanToEvent({
+ *     trace_id: "4bf92f3577b34da6a3ce929d0e0e4736",
+ *     span_id: "00f067aa0ba902b7",
+ *     name: "chat google/gemini-2.5-flash",
+ *     start_time_unix_nano: "1700000000000000000",
+ *     attributes: {
+ *       "gen_ai.provider.name": "google",
+ *       "gen_ai.request.model": "gemini-2.5-flash",
+ *       "gen_ai.usage.input_tokens": 42,
+ *     },
+ *   })
+ *   // → { ts: "2023-11-14T22:13:20.000Z", event_id: "00f067aa0ba902b7", … }
+ */
+import { z } from "zod";
+import { nanosToIso } from "./nano.js";
+import { otelAttributeValueSchema, projectAttributes } from "./project.js";
+import { OTEL_SPAN_KINDS, OTEL_STATUS_CODES, otelSpanEventSchema, otelSpanKindSchema, otelStatusCodeSchema, unixNanoSchema, w3cSpanIdSchema, w3cTraceIdSchema, } from "./span-event.js";
+// Normalized OTLP span input. IDs are strict W3C trace context (real OTel
+// always emits hex). `kind` / `status.code` accept either the OTLP integer
+// (0–5 / 0–2) or the name; everything else is already decoded.
+export const otelSpanInputSchema = z.object({
+    trace_id: w3cTraceIdSchema,
+    span_id: w3cSpanIdSchema,
+    parent_span_id: w3cSpanIdSchema.nullable().optional(),
+    name: z.string().min(1),
+    kind: z.union([otelSpanKindSchema, z.number().int().min(0).max(5)]).optional(),
+    start_time_unix_nano: unixNanoSchema,
+    end_time_unix_nano: unixNanoSchema.nullable().optional(),
+    status: z
+        .object({
+        code: z.union([otelStatusCodeSchema, z.number().int().min(0).max(2)]).optional(),
+        message: z.string().nullable().optional(),
+    })
+        .optional(),
+    attributes: z.record(z.string(), otelAttributeValueSchema).default({}),
+});
+function normalizeSpanKind(kind) {
+    if (kind === undefined) {
+        // OTel SDKs default an unset kind to INTERNAL.
+        return "INTERNAL";
+    }
+    if (typeof kind === "number") {
+        // Bounded 0–5 by `otelSpanInputSchema`; `!` avoids an unreachable branch.
+        return OTEL_SPAN_KINDS[kind];
+    }
+    return kind;
+}
+function normalizeStatusCode(code) {
+    if (code === undefined) {
+        return "UNSET";
+    }
+    if (typeof code === "number") {
+        // Bounded 0–2 by `otelSpanInputSchema`; `!` avoids an unreachable branch.
+        return OTEL_STATUS_CODES[code];
+    }
+    return code;
+}
+/**
+ * Map a normalized OTLP span onto a validated `OtelSpanEvent`.
+ *
+ * Throws a `ZodError` (typed; names the offending field) when the input is
+ * malformed — a non-hex `trace_id`, an out-of-range unix-nano, a reversed span
+ * (end < start), a non-finite attribute value, etc.
+ */
+export function mapOtelSpanToEvent(rawSpan) {
+    const span = otelSpanInputSchema.parse(rawSpan);
+    const attributes = span.attributes;
+    const parentSpanId = span.parent_span_id ?? null;
+    const candidate = {
+        ts: nanosToIso(span.start_time_unix_nano),
+        // The span id IS the canonical row id for an OTel event; the base
+        // parent-chain mirrors span parentage so downstream union readers and M3
+        // correlation agree.
+        event_id: span.span_id,
+        parent_id: parentSpanId,
+        kind: "OtelSpanEvent",
+        trace_id: span.trace_id,
+        span_id: span.span_id,
+        parent_span_id: parentSpanId,
+        name: span.name,
+        span_kind: normalizeSpanKind(span.kind),
+        start_time_unix_nano: span.start_time_unix_nano,
+        end_time_unix_nano: span.end_time_unix_nano ?? null,
+        status_code: normalizeStatusCode(span.status?.code),
+        status_message: span.status?.message ?? null,
+        // Verbatim bag plus its single-source projection. The schema re-derives the
+        // projection and rejects drift, so this is the only place it is computed.
+        ...projectAttributes(attributes),
+        attributes,
+    };
+    // Re-validate the assembled event so the canonical model is always schema-
+    // valid. This DOES fire for bad input the input schema let through (e.g. a
+    // reversed span), surfacing a typed ZodError instead of a silent bad row.
+    return otelSpanEventSchema.parse(candidate);
+}
+//# sourceMappingURL=map-span.js.map

package/node_modules/@pome-sh/twin-gmail/node_modules/@pome-sh/shared-types/dist/otel/map-span.js.map

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

package/node_modules/@pome-sh/twin-gmail/node_modules/@pome-sh/shared-types/dist/otel/nano.d.ts

@@ -0,0 +1,26 @@
+/**
+ * otel/nano — uint64 decimal-string arithmetic + nanosecond↔ISO conversion
+ * (M1.1 / FDRS-480).
+ *
+ * OTLP encodes `*_unix_nano` timestamps as uint64 decimal STRINGS because the
+ * values exceed Number.MAX_SAFE_INTEGER. These helpers validate and compare
+ * them WITHOUT `BigInt` — the dashboard compiles this source directly under a
+ * pre-ES2020 target where `BigInt` literals fail to typecheck (review-era
+ * portability fix). Everything here is pure and deterministic.
+ */
+export declare const UINT64_MAX = "18446744073709551615";
+/** True iff `value` is a non-negative decimal integer string within uint64. */
+export declare function isUint64(value: string): boolean;
+/**
+ * Compare two uint64 decimal strings. Returns <0 if a<b, 0 if equal, >0 if a>b.
+ * Assumes both are valid digit strings (callers validate via `isUint64` first).
+ */
+export declare function compareUint64(a: string, b: string): number;
+export declare function msToNanos(millis: number): string;
+/**
+ * uint64 nanoseconds → ISO-8601 (UTC). Floors to milliseconds by dropping the
+ * last 6 decimal digits of the (uint64-validated) integer string. The resulting
+ * ms value is within Date's safe range for any valid uint64, so this never
+ * throws for input that passed `isUint64`. String-slicing avoids `BigInt`.
+ */
+export declare function nanosToIso(unixNano: string): string;

package/node_modules/@pome-sh/twin-gmail/node_modules/@pome-sh/shared-types/dist/otel/nano.js

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * otel/nano — uint64 decimal-string arithmetic + nanosecond↔ISO conversion
+ * (M1.1 / FDRS-480).
+ *
+ * OTLP encodes `*_unix_nano` timestamps as uint64 decimal STRINGS because the
+ * values exceed Number.MAX_SAFE_INTEGER. These helpers validate and compare
+ * them WITHOUT `BigInt` — the dashboard compiles this source directly under a
+ * pre-ES2020 target where `BigInt` literals fail to typecheck (review-era
+ * portability fix). Everything here is pure and deterministic.
+ */
+// 2^64 - 1. A unix-nano timestamp must fit in a uint64; a longer/larger decimal
+// string is rejected so it can never reach `nanosToIso` and throw a RangeError
+// (review finding #4).
+export const UINT64_MAX = "18446744073709551615";
+// Strip leading zeros, keeping a single "0" for an all-zero string. The
+// `(?=\d)` lookahead guarantees at least one digit remains, so for any digit
+// string (callers validate via the `^\d+$` test first) the result is non-empty.
+// Lets us compare normalized decimals by (length, then lexicographic).
+function normalizeDigits(value) {
+    return value.replace(/^0+(?=\d)/, "");
+}
+/** True iff `value` is a non-negative decimal integer string within uint64. */
+export function isUint64(value) {
+    if (!/^\d+$/.test(value))
+        return false;
+    const normalized = normalizeDigits(value);
+    if (normalized.length !== UINT64_MAX.length) {
+        return normalized.length < UINT64_MAX.length;
+    }
+    return normalized <= UINT64_MAX;
+}
+/**
+ * Compare two uint64 decimal strings. Returns <0 if a<b, 0 if equal, >0 if a>b.
+ * Assumes both are valid digit strings (callers validate via `isUint64` first).
+ */
+export function compareUint64(a, b) {
+    const na = normalizeDigits(a);
+    const nb = normalizeDigits(b);
+    if (na.length !== nb.length)
+        return na.length - nb.length;
+    if (na === nb)
+        return 0;
+    return na < nb ? -1 : 1;
+}
+// Unix-milliseconds → uint64 unix-nanoseconds decimal string. Legacy timestamps
+// are millisecond-precision, so this is exact: append six zeros. Deterministic.
+export function msToNanos(millis) {
+    return `${millis}000000`;
+}
+/**
+ * uint64 nanoseconds → ISO-8601 (UTC). Floors to milliseconds by dropping the
+ * last 6 decimal digits of the (uint64-validated) integer string. The resulting
+ * ms value is within Date's safe range for any valid uint64, so this never
+ * throws for input that passed `isUint64`. String-slicing avoids `BigInt`.
+ */
+export function nanosToIso(unixNano) {
+    const millis = Number(unixNano.slice(0, -6) || "0");
+    return new Date(millis).toISOString();
+}
+//# sourceMappingURL=nano.js.map

package/node_modules/@pome-sh/twin-gmail/node_modules/@pome-sh/shared-types/dist/otel/nano.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nano.js","sourceRoot":"","sources":["../../src/otel/nano.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC;;;;;;;;;GASG;AAEH,gFAAgF;AAChF,+EAA+E;AAC/E,uBAAuB;AACvB,MAAM,CAAC,MAAM,UAAU,GAAG,sBAAsB,CAAC;AAEjD,wEAAwE;AACxE,6EAA6E;AAC7E,gFAAgF;AAChF,uEAAuE;AACvE,SAAS,eAAe,CAAC,KAAa;IACpC,OAAO,KAAK,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;AACxC,CAAC;AAED,+EAA+E;AAC/E,MAAM,UAAU,QAAQ,CAAC,KAAa;IACpC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACvC,MAAM,UAAU,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC;IAC1C,IAAI,UAAU,CAAC,MAAM,KAAK,UAAU,CAAC,MAAM,EAAE,CAAC;QAC5C,OAAO,UAAU,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC;IAC/C,CAAC;IACD,OAAO,UAAU,IAAI,UAAU,CAAC;AAClC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,CAAS,EAAE,CAAS;IAChD,MAAM,EAAE,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;IAC9B,MAAM,EAAE,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;IAC9B,IAAI,EAAE,CAAC,MAAM,KAAK,EAAE,CAAC,MAAM;QAAE,OAAO,EAAE,CAAC,MAAM,GAAG,EAAE,CAAC,MAAM,CAAC;IAC1D,IAAI,EAAE,KAAK,EAAE;QAAE,OAAO,CAAC,CAAC;IACxB,OAAO,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC1B,CAAC;AAED,gFAAgF;AAChF,gFAAgF;AAChF,MAAM,UAAU,SAAS,CAAC,MAAc;IACtC,OAAO,GAAG,MAAM,QAAQ,CAAC;AAC3B,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,UAAU,CAAC,QAAgB;IACzC,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC;IACpD,OAAO,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,WAAW,EAAE,CAAC;AACxC,CAAC"}

package/node_modules/@pome-sh/twin-gmail/node_modules/@pome-sh/shared-types/dist/otel/project.d.ts

@@ -0,0 +1,42 @@
+/**
+ * otel/project — the single attribute→projection function (M1.1 / FDRS-480).
+ *
+ * The typed `gen_ai_*` / `http_*` / `url_*` / `server_*` / `error_type` fields
+ * on an `OtelSpanEvent` are PROJECTIONS of the verbatim `attributes` bag, never
+ * an independent source of truth. This module is the ONE place that derivation
+ * lives, so:
+ *   - the span mapper (`map-span.ts`) builds projections from `attributes`,
+ *   - the legacy shim (`legacy-shim.ts`) builds them the same way, and
+ *   - the schema (`span-event.ts`) re-derives them in a `superRefine` and
+ *     rejects any event whose typed fields drift from `attributes`
+ *     (review finding #4 — projection drift; finding #7 — centralize).
+ *
+ * Pure and deterministic. Reads only the pinned attribute names from `semconv`.
+ */
+import { z } from "zod";
+export declare const otelAttributeValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>;
+export type OtelAttributeValue = z.infer<typeof otelAttributeValueSchema>;
+export type OtelAttributeBag = Record<string, OtelAttributeValue>;
+export declare const OTEL_PROJECTION_KEYS: readonly ["gen_ai_provider_name", "gen_ai_operation_name", "gen_ai_request_model", "gen_ai_agent_name", "gen_ai_agent_id", "gen_ai_tool_name", "gen_ai_usage_input_tokens", "gen_ai_usage_output_tokens", "http_request_method", "http_response_status_code", "url_full", "url_path", "server_address", "server_port", "error_type"];
+export type OtelProjections = {
+    gen_ai_provider_name: string | null;
+    gen_ai_operation_name: string | null;
+    gen_ai_request_model: string | null;
+    gen_ai_agent_name: string | null;
+    gen_ai_agent_id: string | null;
+    gen_ai_tool_name: string | null;
+    gen_ai_usage_input_tokens: number | null;
+    gen_ai_usage_output_tokens: number | null;
+    http_request_method: string | null;
+    http_response_status_code: number | null;
+    url_full: string | null;
+    url_path: string | null;
+    server_address: string | null;
+    server_port: number | null;
+    error_type: string | null;
+};
+/**
+ * Derive the flat typed projections from a verbatim attribute bag. Canonical
+ * names win; deprecated/pre-1.27 aliases are accepted as fallbacks.
+ */
+export declare function projectAttributes(attributes: OtelAttributeBag): OtelProjections;