@noego/wood 0.4.6 → 0.4.7

package/dist/tracing/types/wood_trace_batch.types.d.cts

@@ -0,0 +1,124 @@
+import { MetadataSnapshotLimits } from '@noego/telemetry/core';
+import { a as TraceEvent, b as TraceInput, c as TraceLevel } from '../../trace_hub-Cob54qRx.cjs';
+import 'rxjs';
+
+type WoodRendererTraceInput = Readonly<Omit<TraceInput, 'payload'> & {
+    readonly level: TraceLevel;
+    readonly payload?: Readonly<Record<string, unknown>>;
+}>;
+type WoodRendererTraceEvent = Readonly<Omit<TraceEvent, 'payload'> & {
+    readonly payload?: Readonly<Record<string, unknown>>;
+}>;
+type WoodTraceBatch = Readonly<{
+    kind: 'wood.trace.batch';
+    protocolVersion: 1;
+    producerId: string;
+    batchId: string;
+    sequenceStart: number;
+    sequenceEnd: number;
+    events: readonly WoodRendererTraceEvent[];
+}>;
+type WoodTraceBatchAcknowledgement = 
+/** The injected receiver's durable terminal committed every event. */
+Readonly<{
+    kind: 'committed';
+    batchId: string;
+    committedAtMs: number;
+    acceptedEvents: number;
+}> | Readonly<{
+    kind: 'retryable';
+    batchId: string;
+    reason: string;
+    retryAfterMs: number;
+}> | Readonly<{
+    kind: 'rejected';
+    batchId: string;
+    reason: string;
+}>;
+type WoodTraceBatchRuntimeContext = Readonly<{
+    windowId?: string;
+    webContentsId?: number;
+    routeKey?: string;
+    harnessId?: string;
+}>;
+type WoodTraceBatchReceiver = (batch: WoodTraceBatch, context: WoodTraceBatchRuntimeContext) => Promise<WoodTraceBatchAcknowledgement>;
+type WoodTraceBatchAdmissionResult = Readonly<{
+    kind: 'admitted';
+    sequence: number;
+}> | Readonly<{
+    kind: 'dropped';
+    sequence: number;
+    reason: 'capacity' | 'closed';
+}>;
+type WoodTraceBatchTransportStatus = Readonly<{
+    state: 'accepting' | 'draining' | 'stopped';
+    producerId: string;
+    nextSequence: number;
+    queuedEvents: number;
+    inFlightBatchId: string | null;
+    droppedCapacity: number;
+    droppedClosed: number;
+    droppedRejected: number;
+    droppedRetryExhausted: number;
+    metadataTruncatedValues: number;
+    metadataRedactedValues: number;
+    metadataSerializationFailures: number;
+    committedBatches: number;
+    retryAttempts: number;
+}>;
+interface WoodTraceBatchPort {
+    postMessage(batch: WoodTraceBatch): void;
+    subscribe(listener: (message: unknown) => void): () => void;
+    close(): void;
+}
+type WoodTraceBatchTransportOptions = Readonly<{
+    producerId: string;
+    maxQueuedEvents: number;
+    maxBatchEvents: number;
+    acknowledgementTimeoutMs: number;
+    retryLimit: number;
+    retryBaseDelayMs: number;
+    now: () => number;
+    schedule: (work: () => void) => void;
+    delay: (durationMs: number) => Promise<void>;
+    metadataSnapshotLimits?: MetadataSnapshotLimits;
+}>;
+type WoodTraceBatchParseResult = Readonly<{
+    kind: 'not-batch';
+}> | Readonly<{
+    kind: 'invalid';
+    batchId: string | null;
+    reason: string;
+}> | Readonly<{
+    kind: 'valid';
+    batch: WoodTraceBatch;
+}>;
+type WoodTraceAcknowledgementParseResult = Readonly<{
+    ok: true;
+    acknowledgement: WoodTraceBatchAcknowledgement;
+}> | Readonly<{
+    ok: false;
+    reason: string;
+}>;
+type WoodTraceEventParseResult = Readonly<{
+    kind: 'valid';
+    event: WoodRendererTraceEvent;
+}> | Readonly<{
+    kind: 'invalid';
+    reason: string;
+}>;
+type WoodTraceEventsParseResult = Readonly<{
+    kind: 'valid';
+    events: readonly WoodRendererTraceEvent[];
+}> | Readonly<{
+    kind: 'invalid';
+    reason: string;
+}>;
+type WoodTraceIdentityValidationResult = Readonly<{
+    kind: 'valid';
+}> | Readonly<{
+    kind: 'invalid';
+    reason: string;
+}>;
+
+export type { WoodRendererTraceEvent, WoodRendererTraceInput, WoodTraceAcknowledgementParseResult, WoodTraceBatch, WoodTraceBatchAcknowledgement, WoodTraceBatchAdmissionResult, WoodTraceBatchParseResult, WoodTraceBatchPort, WoodTraceBatchReceiver, WoodTraceBatchRuntimeContext, WoodTraceBatchTransportOptions, WoodTraceBatchTransportStatus, WoodTraceEventParseResult, WoodTraceEventsParseResult, WoodTraceIdentityValidationResult };

package/dist/tracing/types/wood_trace_batch.types.d.ts

@@ -0,0 +1,124 @@
+import { MetadataSnapshotLimits } from '@noego/telemetry/core';
+import { a as TraceEvent, b as TraceInput, c as TraceLevel } from '../../trace_hub-Cob54qRx.js';
+import 'rxjs';
+
+type WoodRendererTraceInput = Readonly<Omit<TraceInput, 'payload'> & {
+    readonly level: TraceLevel;
+    readonly payload?: Readonly<Record<string, unknown>>;
+}>;
+type WoodRendererTraceEvent = Readonly<Omit<TraceEvent, 'payload'> & {
+    readonly payload?: Readonly<Record<string, unknown>>;
+}>;
+type WoodTraceBatch = Readonly<{
+    kind: 'wood.trace.batch';
+    protocolVersion: 1;
+    producerId: string;
+    batchId: string;
+    sequenceStart: number;
+    sequenceEnd: number;
+    events: readonly WoodRendererTraceEvent[];
+}>;
+type WoodTraceBatchAcknowledgement = 
+/** The injected receiver's durable terminal committed every event. */
+Readonly<{
+    kind: 'committed';
+    batchId: string;
+    committedAtMs: number;
+    acceptedEvents: number;
+}> | Readonly<{
+    kind: 'retryable';
+    batchId: string;
+    reason: string;
+    retryAfterMs: number;
+}> | Readonly<{
+    kind: 'rejected';
+    batchId: string;
+    reason: string;
+}>;
+type WoodTraceBatchRuntimeContext = Readonly<{
+    windowId?: string;
+    webContentsId?: number;
+    routeKey?: string;
+    harnessId?: string;
+}>;
+type WoodTraceBatchReceiver = (batch: WoodTraceBatch, context: WoodTraceBatchRuntimeContext) => Promise<WoodTraceBatchAcknowledgement>;
+type WoodTraceBatchAdmissionResult = Readonly<{
+    kind: 'admitted';
+    sequence: number;
+}> | Readonly<{
+    kind: 'dropped';
+    sequence: number;
+    reason: 'capacity' | 'closed';
+}>;
+type WoodTraceBatchTransportStatus = Readonly<{
+    state: 'accepting' | 'draining' | 'stopped';
+    producerId: string;
+    nextSequence: number;
+    queuedEvents: number;
+    inFlightBatchId: string | null;
+    droppedCapacity: number;
+    droppedClosed: number;
+    droppedRejected: number;
+    droppedRetryExhausted: number;
+    metadataTruncatedValues: number;
+    metadataRedactedValues: number;
+    metadataSerializationFailures: number;
+    committedBatches: number;
+    retryAttempts: number;
+}>;
+interface WoodTraceBatchPort {
+    postMessage(batch: WoodTraceBatch): void;
+    subscribe(listener: (message: unknown) => void): () => void;
+    close(): void;
+}
+type WoodTraceBatchTransportOptions = Readonly<{
+    producerId: string;
+    maxQueuedEvents: number;
+    maxBatchEvents: number;
+    acknowledgementTimeoutMs: number;
+    retryLimit: number;
+    retryBaseDelayMs: number;
+    now: () => number;
+    schedule: (work: () => void) => void;
+    delay: (durationMs: number) => Promise<void>;
+    metadataSnapshotLimits?: MetadataSnapshotLimits;
+}>;
+type WoodTraceBatchParseResult = Readonly<{
+    kind: 'not-batch';
+}> | Readonly<{
+    kind: 'invalid';
+    batchId: string | null;
+    reason: string;
+}> | Readonly<{
+    kind: 'valid';
+    batch: WoodTraceBatch;
+}>;
+type WoodTraceAcknowledgementParseResult = Readonly<{
+    ok: true;
+    acknowledgement: WoodTraceBatchAcknowledgement;
+}> | Readonly<{
+    ok: false;
+    reason: string;
+}>;
+type WoodTraceEventParseResult = Readonly<{
+    kind: 'valid';
+    event: WoodRendererTraceEvent;
+}> | Readonly<{
+    kind: 'invalid';
+    reason: string;
+}>;
+type WoodTraceEventsParseResult = Readonly<{
+    kind: 'valid';
+    events: readonly WoodRendererTraceEvent[];
+}> | Readonly<{
+    kind: 'invalid';
+    reason: string;
+}>;
+type WoodTraceIdentityValidationResult = Readonly<{
+    kind: 'valid';
+}> | Readonly<{
+    kind: 'invalid';
+    reason: string;
+}>;
+
+export type { WoodRendererTraceEvent, WoodRendererTraceInput, WoodTraceAcknowledgementParseResult, WoodTraceBatch, WoodTraceBatchAcknowledgement, WoodTraceBatchAdmissionResult, WoodTraceBatchParseResult, WoodTraceBatchPort, WoodTraceBatchReceiver, WoodTraceBatchRuntimeContext, WoodTraceBatchTransportOptions, WoodTraceBatchTransportStatus, WoodTraceEventParseResult, WoodTraceEventsParseResult, WoodTraceIdentityValidationResult };

package/dist/tracing/types/wood_trace_batch.types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=wood_trace_batch.types.js.map

package/dist/tracing/types/wood_trace_batch.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/tracing/types/wood_trace_sink.types.cjs

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var wood_trace_sink_types_exports = {};
+module.exports = __toCommonJS(wood_trace_sink_types_exports);
+//# sourceMappingURL=wood_trace_sink.types.cjs.map

package/dist/tracing/types/wood_trace_sink.types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/tracing/types/wood_trace_sink.types.ts"],"sourcesContent":["import type { TraceEvent } from '../trace_hub.js';\n\n/** A caller-independent, shallow immutable Wood trace event. */\nexport type WoodTraceEventSnapshot = Readonly<\n  Omit<TraceEvent, 'payload'> & {\n    readonly payload?: Readonly<Record<string, unknown>>;\n  }\n>;\n\nexport type WoodTraceEventSink = (event: WoodTraceEventSnapshot) => void;\nexport type WoodTraceSinkDisposer = () => void;\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/tracing/types/wood_trace_sink.types.d.cts

@@ -0,0 +1,2 @@
+export { W as WoodTraceEventSink, g as WoodTraceEventSnapshot, h as WoodTraceSinkDisposer } from '../../trace_hub-Cob54qRx.cjs';
+import 'rxjs';

package/dist/tracing/types/wood_trace_sink.types.d.ts

@@ -0,0 +1,2 @@
+export { W as WoodTraceEventSink, g as WoodTraceEventSnapshot, h as WoodTraceSinkDisposer } from '../../trace_hub-Cob54qRx.js';
+import 'rxjs';

package/dist/tracing/types/wood_trace_sink.types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=wood_trace_sink.types.js.map

package/dist/tracing/types/wood_trace_sink.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/tracing/wood_trace_batch_contract.cjs

@@ -0,0 +1,229 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var wood_trace_batch_contract_exports = {};
+__export(wood_trace_batch_contract_exports, {
+  WoodTraceBatchContract: () => WoodTraceBatchContract
+});
+module.exports = __toCommonJS(wood_trace_batch_contract_exports);
+const MAX_BATCH_EVENTS = 256;
+class WoodTraceBatchContract {
+  create(producerId, sequenceStart, events) {
+    const snapshots = events.map((event) => this.snapshotEvent(event));
+    const last = snapshots[snapshots.length - 1];
+    const sequenceEnd = last ? last.traceSeq - 1 : sequenceStart - 1;
+    return Object.freeze({
+      kind: "wood.trace.batch",
+      protocolVersion: 1,
+      producerId,
+      batchId: `wtb1:${producerId}:${sequenceStart}-${sequenceEnd}`,
+      sequenceStart,
+      sequenceEnd,
+      events: Object.freeze(snapshots)
+    });
+  }
+  parse(input) {
+    if (!this.isRecord(input) || input.kind !== "wood.trace.batch") {
+      return { kind: "not-batch" };
+    }
+    const batchId = typeof input.batchId === "string" ? input.batchId : null;
+    const identity = this.validateIdentity(input);
+    if (identity.kind === "invalid") {
+      return { kind: "invalid", batchId, reason: identity.reason };
+    }
+    const producerId = input.producerId;
+    if (typeof producerId !== "string") {
+      return { kind: "invalid", batchId, reason: "Trace batch producer identity is invalid" };
+    }
+    const parsedEvents = this.parseEvents(input.events);
+    if (parsedEvents.kind === "invalid") {
+      return { kind: "invalid", batchId, reason: parsedEvents.reason };
+    }
+    const events = parsedEvents.events;
+    const parsedSequenceRange = this.parseSequenceRange(input, events);
+    if (parsedSequenceRange.kind === "invalid") {
+      return { kind: "invalid", batchId, reason: parsedSequenceRange.reason };
+    }
+    const { sequenceStart, sequenceEnd } = parsedSequenceRange;
+    const hasTraceSequenceMismatch = events.some((event, index) => {
+      const previous = events[index - 1];
+      return previous !== void 0 && event.traceSeq <= previous.traceSeq;
+    });
+    if (hasTraceSequenceMismatch) {
+      return { kind: "invalid", batchId, reason: "Trace event sequences are not strictly increasing" };
+    }
+    const expectedBatchId = `wtb1:${producerId}:${sequenceStart}-${sequenceEnd}`;
+    if (input.batchId !== expectedBatchId) {
+      return { kind: "invalid", batchId, reason: "Trace batch identity does not match its sequence range" };
+    }
+    return {
+      kind: "valid",
+      batch: this.create(producerId, sequenceStart, events)
+    };
+  }
+  parseAcknowledgement(input) {
+    if (!this.isRecord(input) || typeof input.kind !== "string" || typeof input.batchId !== "string") {
+      return { ok: false, reason: "Trace batch acknowledgement framing is invalid" };
+    }
+    if (input.kind === "committed") {
+      return this.parseCommittedAcknowledgement(input);
+    }
+    if (input.kind === "retryable") {
+      return this.parseRetryableAcknowledgement(input);
+    }
+    if (input.kind === "rejected" && typeof input.reason === "string") {
+      return {
+        ok: true,
+        acknowledgement: Object.freeze({
+          kind: "rejected",
+          batchId: input.batchId,
+          reason: input.reason
+        })
+      };
+    }
+    return { ok: false, reason: "Trace batch acknowledgement kind is invalid" };
+  }
+  parseCommittedAcknowledgement(input) {
+    const batchId = input.batchId;
+    const committedAtMs = input.committedAtMs;
+    const acceptedEvents = input.acceptedEvents;
+    const validNumbers = typeof batchId === "string" && typeof committedAtMs === "number" && Number.isFinite(committedAtMs) && typeof acceptedEvents === "number" && Number.isSafeInteger(acceptedEvents) && acceptedEvents >= 0;
+    if (!validNumbers) {
+      return { ok: false, reason: "Committed trace acknowledgement is invalid" };
+    }
+    return {
+      ok: true,
+      acknowledgement: Object.freeze({
+        kind: "committed",
+        batchId,
+        committedAtMs,
+        acceptedEvents
+      })
+    };
+  }
+  parseRetryableAcknowledgement(input) {
+    const batchId = input.batchId;
+    const retryAfterMs = input.retryAfterMs;
+    if (typeof batchId !== "string" || typeof input.reason !== "string" || typeof retryAfterMs !== "number" || !Number.isFinite(retryAfterMs) || retryAfterMs < 0) {
+      return { ok: false, reason: "Retryable trace acknowledgement is invalid" };
+    }
+    return {
+      ok: true,
+      acknowledgement: Object.freeze({
+        kind: "retryable",
+        batchId,
+        reason: input.reason,
+        retryAfterMs
+      })
+    };
+  }
+  parseEvent(input) {
+    if (!this.isRecord(input)) {
+      return { kind: "invalid", reason: "Trace event is not an object" };
+    }
+    const hasValidIdentity = this.hasValidEventIdentity(input);
+    const hasValidTiming = this.hasValidEventTiming(input);
+    if (!hasValidIdentity || !hasValidTiming) {
+      return { kind: "invalid", reason: "Trace event identity or timing is invalid" };
+    }
+    if (input.payload !== void 0 && !this.isRecord(input.payload)) {
+      return { kind: "invalid", reason: "Trace event payload is invalid" };
+    }
+    return {
+      kind: "valid",
+      event: this.snapshotEvent({
+        source: input.source,
+        type: input.type,
+        level: input.level,
+        process: "renderer",
+        timestamp: input.timestamp,
+        traceSeq: input.traceSeq,
+        ...typeof input.message === "string" ? { message: input.message } : {},
+        ...this.isConversationId(input.conversationId) ? { conversationId: input.conversationId } : {},
+        ...input.payload ? { payload: input.payload } : {},
+        ...typeof input.windowId === "string" ? { windowId: input.windowId } : {},
+        ...typeof input.webContentsId === "number" && Number.isFinite(input.webContentsId) ? { webContentsId: input.webContentsId } : {},
+        ...typeof input.routeKey === "string" ? { routeKey: input.routeKey } : {},
+        ...typeof input.harnessId === "string" ? { harnessId: input.harnessId } : {}
+      })
+    };
+  }
+  hasValidEventIdentity(input) {
+    return typeof input.source === "string" && input.source.trim().length > 0 && typeof input.type === "string" && input.type.trim().length > 0 && typeof input.level === "string" && input.level.trim().length > 0 && input.process === "renderer";
+  }
+  hasValidEventTiming(input) {
+    return typeof input.timestamp === "string" && Number.isFinite(Date.parse(input.timestamp)) && typeof input.traceSeq === "number" && Number.isSafeInteger(input.traceSeq) && input.traceSeq >= 1;
+  }
+  parseEvents(input) {
+    if (!Array.isArray(input) || input.length === 0 || input.length > MAX_BATCH_EVENTS) {
+      return { kind: "invalid", reason: "Trace batch events are invalid" };
+    }
+    const events = [];
+    for (const rawEvent of input) {
+      const parsedEvent = this.parseEvent(rawEvent);
+      if (parsedEvent.kind === "invalid") {
+        return parsedEvent;
+      }
+      events.push(parsedEvent.event);
+    }
+    return { kind: "valid", events: Object.freeze(events) };
+  }
+  parseSequenceRange(input, events) {
+    const sequenceStart = input.sequenceStart;
+    const sequenceEnd = input.sequenceEnd;
+    if (typeof sequenceStart !== "number" || typeof sequenceEnd !== "number") {
+      return { kind: "invalid", reason: "Trace batch sequence range is invalid" };
+    }
+    const firstEvent = events[0];
+    const lastEvent = events[events.length - 1];
+    const hasInvalidRange = !Number.isSafeInteger(sequenceStart) || sequenceStart < 0 || !Number.isSafeInteger(sequenceEnd) || !firstEvent || !lastEvent || firstEvent.traceSeq !== sequenceStart + 1 || lastEvent.traceSeq !== sequenceEnd + 1;
+    if (hasInvalidRange) {
+      return { kind: "invalid", reason: "Trace batch sequence range does not match its events" };
+    }
+    return { kind: "valid", sequenceStart, sequenceEnd };
+  }
+  snapshotEvent(event) {
+    return Object.freeze({
+      ...event,
+      ...event.payload ? { payload: Object.freeze({ ...event.payload }) } : {}
+    });
+  }
+  validateIdentity(input) {
+    if (input.protocolVersion !== 1) {
+      return { kind: "invalid", reason: "Trace batch protocol version is unsupported" };
+    }
+    if (typeof input.producerId !== "string" || input.producerId.trim().length === 0) {
+      return { kind: "invalid", reason: "Trace batch producer identity is invalid" };
+    }
+    if (typeof input.batchId !== "string" || input.batchId.trim().length === 0) {
+      return { kind: "invalid", reason: "Trace batch identity is invalid" };
+    }
+    return { kind: "valid" };
+  }
+  isConversationId(value) {
+    return typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+  }
+  isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WoodTraceBatchContract
+});
+//# sourceMappingURL=wood_trace_batch_contract.cjs.map

package/dist/tracing/wood_trace_batch_contract.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/tracing/wood_trace_batch_contract.ts"],"sourcesContent":["import type {\n  WoodRendererTraceEvent,\n  WoodTraceAcknowledgementParseResult,\n  WoodTraceBatch,\n  WoodTraceBatchAcknowledgement,\n  WoodTraceBatchParseResult,\n  WoodTraceEventParseResult,\n  WoodTraceEventsParseResult,\n  WoodTraceIdentityValidationResult,\n} from './types/wood_trace_batch.types.js';\n\nconst MAX_BATCH_EVENTS = 256;\n\nexport class WoodTraceBatchContract {\n  create(\n    producerId: string,\n    sequenceStart: number,\n    events: readonly WoodRendererTraceEvent[],\n  ): WoodTraceBatch {\n    const snapshots = events.map((event) => this.snapshotEvent(event));\n    const last = snapshots[snapshots.length - 1];\n    const sequenceEnd = last ? last.traceSeq - 1 : sequenceStart - 1;\n    return Object.freeze({\n      kind: 'wood.trace.batch',\n      protocolVersion: 1,\n      producerId,\n      batchId: `wtb1:${producerId}:${sequenceStart}-${sequenceEnd}`,\n      sequenceStart,\n      sequenceEnd,\n      events: Object.freeze(snapshots),\n    });\n  }\n\n  parse(input: unknown): WoodTraceBatchParseResult {\n    if (!this.isRecord(input) || input.kind !== 'wood.trace.batch') {\n      return { kind: 'not-batch' };\n    }\n\n    const batchId = typeof input.batchId === 'string' ? input.batchId : null;\n    const identity = this.validateIdentity(input);\n    if (identity.kind === 'invalid') {\n      return { kind: 'invalid', batchId, reason: identity.reason };\n    }\n    const producerId = input.producerId;\n    if (typeof producerId !== 'string') {\n      return { kind: 'invalid', batchId, reason: 'Trace batch producer identity is invalid' };\n    }\n\n    const parsedEvents = this.parseEvents(input.events);\n    if (parsedEvents.kind === 'invalid') {\n      return { kind: 'invalid', batchId, reason: parsedEvents.reason };\n    }\n    const events = parsedEvents.events;\n\n    const parsedSequenceRange = this.parseSequenceRange(input, events);\n    if (parsedSequenceRange.kind === 'invalid') {\n      return { kind: 'invalid', batchId, reason: parsedSequenceRange.reason };\n    }\n    const { sequenceStart, sequenceEnd } = parsedSequenceRange;\n    const hasTraceSequenceMismatch = events.some((event, index) => {\n      const previous = events[index - 1];\n      return previous !== undefined && event.traceSeq <= previous.traceSeq;\n    });\n    if (hasTraceSequenceMismatch) {\n      return { kind: 'invalid', batchId, reason: 'Trace event sequences are not strictly increasing' };\n    }\n    const expectedBatchId = `wtb1:${producerId}:${sequenceStart}-${sequenceEnd}`;\n    if (input.batchId !== expectedBatchId) {\n      return { kind: 'invalid', batchId, reason: 'Trace batch identity does not match its sequence range' };\n    }\n\n    return {\n      kind: 'valid',\n      batch: this.create(producerId, sequenceStart, events),\n    };\n  }\n\n  parseAcknowledgement(input: unknown): WoodTraceAcknowledgementParseResult {\n    if (!this.isRecord(input) || typeof input.kind !== 'string' || typeof input.batchId !== 'string') {\n      return { ok: false, reason: 'Trace batch acknowledgement framing is invalid' };\n    }\n\n    if (input.kind === 'committed') {\n      return this.parseCommittedAcknowledgement(input);\n    }\n    if (input.kind === 'retryable') {\n      return this.parseRetryableAcknowledgement(input);\n    }\n    if (input.kind === 'rejected' && typeof input.reason === 'string') {\n      return {\n        ok: true,\n        acknowledgement: Object.freeze({\n          kind: 'rejected',\n          batchId: input.batchId,\n          reason: input.reason,\n        }),\n      };\n    }\n    return { ok: false, reason: 'Trace batch acknowledgement kind is invalid' };\n  }\n\n  private parseCommittedAcknowledgement(\n    input: Record<string, unknown>,\n  ): WoodTraceAcknowledgementParseResult {\n    const batchId = input.batchId;\n    const committedAtMs = input.committedAtMs;\n    const acceptedEvents = input.acceptedEvents;\n    const validNumbers = typeof batchId === 'string'\n      && typeof committedAtMs === 'number'\n      && Number.isFinite(committedAtMs)\n      && typeof acceptedEvents === 'number'\n      && Number.isSafeInteger(acceptedEvents)\n      && acceptedEvents >= 0;\n    if (!validNumbers) {\n      return { ok: false, reason: 'Committed trace acknowledgement is invalid' };\n    }\n    return {\n      ok: true,\n      acknowledgement: Object.freeze({\n        kind: 'committed',\n        batchId,\n        committedAtMs,\n        acceptedEvents,\n      }),\n    };\n  }\n\n  private parseRetryableAcknowledgement(\n    input: Record<string, unknown>,\n  ): WoodTraceAcknowledgementParseResult {\n    const batchId = input.batchId;\n    const retryAfterMs = input.retryAfterMs;\n    if (typeof batchId !== 'string'\n      || typeof input.reason !== 'string'\n      || typeof retryAfterMs !== 'number'\n      || !Number.isFinite(retryAfterMs)\n      || retryAfterMs < 0) {\n      return { ok: false, reason: 'Retryable trace acknowledgement is invalid' };\n    }\n    return {\n      ok: true,\n      acknowledgement: Object.freeze({\n        kind: 'retryable',\n        batchId,\n        reason: input.reason,\n        retryAfterMs,\n      }),\n    };\n  }\n\n  private parseEvent(input: unknown): WoodTraceEventParseResult {\n    if (!this.isRecord(input)) {\n      return { kind: 'invalid', reason: 'Trace event is not an object' };\n    }\n    const hasValidIdentity = this.hasValidEventIdentity(input);\n    const hasValidTiming = this.hasValidEventTiming(input);\n    if (!hasValidIdentity || !hasValidTiming) {\n      return { kind: 'invalid', reason: 'Trace event identity or timing is invalid' };\n    }\n    if (input.payload !== undefined && !this.isRecord(input.payload)) {\n      return { kind: 'invalid', reason: 'Trace event payload is invalid' };\n    }\n    return {\n      kind: 'valid',\n      event: this.snapshotEvent({\n        source: input.source,\n        type: input.type,\n        level: input.level,\n        process: 'renderer',\n        timestamp: input.timestamp,\n        traceSeq: input.traceSeq,\n        ...(typeof input.message === 'string' ? { message: input.message } : {}),\n        ...(this.isConversationId(input.conversationId) ? { conversationId: input.conversationId } : {}),\n        ...(input.payload ? { payload: input.payload } : {}),\n        ...(typeof input.windowId === 'string' ? { windowId: input.windowId } : {}),\n        ...(typeof input.webContentsId === 'number' && Number.isFinite(input.webContentsId)\n          ? { webContentsId: input.webContentsId }\n          : {}),\n        ...(typeof input.routeKey === 'string' ? { routeKey: input.routeKey } : {}),\n        ...(typeof input.harnessId === 'string' ? { harnessId: input.harnessId } : {}),\n      }),\n    };\n  }\n\n  private hasValidEventIdentity(input: Record<string, unknown>): input is Record<string, unknown> & {\n    source: string;\n    type: string;\n    level: string;\n    process: 'renderer';\n  } {\n    return typeof input.source === 'string'\n      && input.source.trim().length > 0\n      && typeof input.type === 'string'\n      && input.type.trim().length > 0\n      && typeof input.level === 'string'\n      && input.level.trim().length > 0\n      && input.process === 'renderer';\n  }\n\n  private hasValidEventTiming(input: Record<string, unknown>): input is Record<string, unknown> & {\n    timestamp: string;\n    traceSeq: number;\n  } {\n    return typeof input.timestamp === 'string'\n      && Number.isFinite(Date.parse(input.timestamp))\n      && typeof input.traceSeq === 'number'\n      && Number.isSafeInteger(input.traceSeq)\n      && input.traceSeq >= 1;\n  }\n\n  private parseEvents(input: unknown): WoodTraceEventsParseResult {\n    if (!Array.isArray(input) || input.length === 0 || input.length > MAX_BATCH_EVENTS) {\n      return { kind: 'invalid', reason: 'Trace batch events are invalid' };\n    }\n    const events: WoodRendererTraceEvent[] = [];\n    for (const rawEvent of input) {\n      const parsedEvent = this.parseEvent(rawEvent);\n      if (parsedEvent.kind === 'invalid') {\n        return parsedEvent;\n      }\n      events.push(parsedEvent.event);\n    }\n    return { kind: 'valid', events: Object.freeze(events) };\n  }\n\n  private parseSequenceRange(\n    input: Record<string, unknown>,\n    events: readonly WoodRendererTraceEvent[],\n  ): { kind: 'invalid'; reason: string } | { kind: 'valid'; sequenceStart: number; sequenceEnd: number } {\n    const sequenceStart = input.sequenceStart;\n    const sequenceEnd = input.sequenceEnd;\n    if (typeof sequenceStart !== 'number' || typeof sequenceEnd !== 'number') {\n      return { kind: 'invalid', reason: 'Trace batch sequence range is invalid' };\n    }\n    const firstEvent = events[0];\n    const lastEvent = events[events.length - 1];\n    const hasInvalidRange = !Number.isSafeInteger(sequenceStart)\n      || sequenceStart < 0\n      || !Number.isSafeInteger(sequenceEnd)\n      || !firstEvent\n      || !lastEvent\n      || firstEvent.traceSeq !== sequenceStart + 1\n      || lastEvent.traceSeq !== sequenceEnd + 1;\n    if (hasInvalidRange) {\n      return { kind: 'invalid', reason: 'Trace batch sequence range does not match its events' };\n    }\n    return { kind: 'valid', sequenceStart, sequenceEnd };\n  }\n\n  private snapshotEvent(event: WoodRendererTraceEvent): WoodRendererTraceEvent {\n    return Object.freeze({\n      ...event,\n      ...(event.payload ? { payload: Object.freeze({ ...event.payload }) } : {}),\n    });\n  }\n\n  private validateIdentity(input: Record<string, unknown>): WoodTraceIdentityValidationResult {\n    if (input.protocolVersion !== 1) {\n      return { kind: 'invalid', reason: 'Trace batch protocol version is unsupported' };\n    }\n    if (typeof input.producerId !== 'string' || input.producerId.trim().length === 0) {\n      return { kind: 'invalid', reason: 'Trace batch producer identity is invalid' };\n    }\n    if (typeof input.batchId !== 'string' || input.batchId.trim().length === 0) {\n      return { kind: 'invalid', reason: 'Trace batch identity is invalid' };\n    }\n    return { kind: 'valid' };\n  }\n\n  private isConversationId(value: unknown): value is string | number {\n    return typeof value === 'string' || (typeof value === 'number' && Number.isFinite(value));\n  }\n\n  private isRecord(value: unknown): value is Record<string, unknown> {\n    return typeof value === 'object' && value !== null && !Array.isArray(value);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/tracing/wood_trace_batch_contract.d.cts

@@ -0,0 +1,23 @@
+import { WoodRendererTraceEvent, WoodTraceBatch, WoodTraceBatchParseResult, WoodTraceAcknowledgementParseResult } from './types/wood_trace_batch.types.cjs';
+import '@noego/telemetry/core';
+import '../trace_hub-Cob54qRx.cjs';
+import 'rxjs';
+
+declare class WoodTraceBatchContract {
+    create(producerId: string, sequenceStart: number, events: readonly WoodRendererTraceEvent[]): WoodTraceBatch;
+    parse(input: unknown): WoodTraceBatchParseResult;
+    parseAcknowledgement(input: unknown): WoodTraceAcknowledgementParseResult;
+    private parseCommittedAcknowledgement;
+    private parseRetryableAcknowledgement;
+    private parseEvent;
+    private hasValidEventIdentity;
+    private hasValidEventTiming;
+    private parseEvents;
+    private parseSequenceRange;
+    private snapshotEvent;
+    private validateIdentity;
+    private isConversationId;
+    private isRecord;
+}
+
+export { WoodTraceBatchContract };

package/dist/tracing/wood_trace_batch_contract.d.ts

@@ -0,0 +1,23 @@
+import { WoodRendererTraceEvent, WoodTraceBatch, WoodTraceBatchParseResult, WoodTraceAcknowledgementParseResult } from './types/wood_trace_batch.types.js';
+import '@noego/telemetry/core';
+import '../trace_hub-Cob54qRx.js';
+import 'rxjs';
+
+declare class WoodTraceBatchContract {
+    create(producerId: string, sequenceStart: number, events: readonly WoodRendererTraceEvent[]): WoodTraceBatch;
+    parse(input: unknown): WoodTraceBatchParseResult;
+    parseAcknowledgement(input: unknown): WoodTraceAcknowledgementParseResult;
+    private parseCommittedAcknowledgement;
+    private parseRetryableAcknowledgement;
+    private parseEvent;
+    private hasValidEventIdentity;
+    private hasValidEventTiming;
+    private parseEvents;
+    private parseSequenceRange;
+    private snapshotEvent;
+    private validateIdentity;
+    private isConversationId;
+    private isRecord;
+}
+
+export { WoodTraceBatchContract };