@smoothbricks/lmao 0.1.4 → 0.2.1

package/dist/cloudflare.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Cloudflare trace-sink adapters (specs/lmao/01u_cloudflare_trace_segments.md).
+ *
+ * Two delivery lanes over the base Tracer lifecycle, no Cloudflare types required — every
+ * platform binding (Pipelines stream send, Queues producer, collector shard) is injected
+ * structurally:
+ * - billing-grade: CollectorClient (awaited within the request; ack = DO storage commit)
+ * - diagnostic: DiagnosticDrainTracer + transports (waitUntil, fire-and-forget)
+ * - both: ClassSplitTracer routes rows per delivery class via an injected classifier
+ */
+export { type ClassSplitOptions, ClassSplitTracer, type DeliveryClass, type DeliveryClassifier, } from './lib/cloudflare/classSplit.js';
+export { COLLECTOR_ACK, type CollectorAck, type CollectorClient, type CollectorSendFailure, FakeCollectorClient, } from './lib/cloudflare/collectorClient.js';
+export { type DiagnosticDrainOptions, DiagnosticDrainTracer, type DiagnosticTransport, type PipelinesStreamSend, PipelinesStreamTransport, type QueuesFallbackOptions, QueuesFallbackTransport, type TraceChunkQueueMessage, } from './lib/cloudflare/diagnosticDrain.js';
+export { spanBufferToTraceRows, type TraceRow, type TraceRowValue } from './lib/cloudflare/traceRows.js';
+//# sourceMappingURL=cloudflare.d.ts.map

package/dist/cloudflare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare.d.ts","sourceRoot":"","sources":["../src/cloudflare.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EACL,KAAK,iBAAiB,EACtB,gBAAgB,EAChB,KAAK,aAAa,EAClB,KAAK,kBAAkB,GACxB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,aAAa,EACb,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,oBAAoB,EACzB,mBAAmB,GACpB,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EACL,KAAK,sBAAsB,EAC3B,qBAAqB,EACrB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACxB,wBAAwB,EACxB,KAAK,qBAAqB,EAC1B,uBAAuB,EACvB,KAAK,sBAAsB,GAC5B,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,qBAAqB,EAAE,KAAK,QAAQ,EAAE,KAAK,aAAa,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/cloudflare.js

@@ -0,0 +1,14 @@
+/**
+ * Cloudflare trace-sink adapters (specs/lmao/01u_cloudflare_trace_segments.md).
+ *
+ * Two delivery lanes over the base Tracer lifecycle, no Cloudflare types required — every
+ * platform binding (Pipelines stream send, Queues producer, collector shard) is injected
+ * structurally:
+ * - billing-grade: CollectorClient (awaited within the request; ack = DO storage commit)
+ * - diagnostic: DiagnosticDrainTracer + transports (waitUntil, fire-and-forget)
+ * - both: ClassSplitTracer routes rows per delivery class via an injected classifier
+ */
+export { ClassSplitTracer, } from './lib/cloudflare/classSplit.js';
+export { COLLECTOR_ACK, FakeCollectorClient, } from './lib/cloudflare/collectorClient.js';
+export { DiagnosticDrainTracer, PipelinesStreamTransport, QueuesFallbackTransport, } from './lib/cloudflare/diagnosticDrain.js';
+export { spanBufferToTraceRows } from './lib/cloudflare/traceRows.js';

package/dist/es.js

@@ -8,3 +8,4 @@ export * from './index.js';
 // Export browser-specific TraceRoot factory for Tracer construction
 //#region smoo/lmao!n/trace-root-timestamps.entry-points #es
 export { createTraceRoot } from './lib/traceRoot.es.js';
+//#endregion smoo/lmao!n/trace-root-timestamps.entry-points

package/dist/lib/JsBufferStrategy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"JsBufferStrategy.d.ts","sourceRoot":"","sources":["../../src/lib/JsBufferStrategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAQvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAS5D;;;;;;;;;;;;;GAaG;AACH,qBAAa,gBAAgB,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,CAAE,YAAW,cAAc,CAAC,CAAC,CAAC;IACzF;;;OAGG;IACH,OAAO,CAAC,oBAAoB,CAAmD;IAE/E;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAYnC,gBAAgB,CAAC,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC;IAI5G,qBAAqB,CACnB,YAAY,EAAE,UAAU,CAAC,CAAC,CAAC,EAC3B,gBAAgB,EAAE,UAAU,EAC5B,UAAU,EAAE,UAAU,EACtB,QAAQ,CAAC,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,CAAC,GACT,UAAU,CAAC,CAAC,CAAC;IAOhB,oBAAoB,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;IAI1D,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG,KAAK;IAK1C,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;CAI5C"}
+{"version":3,"file":"JsBufferStrategy.d.ts","sourceRoot":"","sources":["../../src/lib/JsBufferStrategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAQvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAS5D;;;;;;;;;;;;;GAaG;AACH,qBAAa,gBAAgB,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,CAAE,YAAW,cAAc,CAAC,CAAC,CAAC;IACzF;;;OAGG;IACH,OAAO,CAAC,oBAAoB,CAAmD;IAE/E;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAYnC,gBAAgB,CAAC,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC,CAE3G;IAED,qBAAqB,CACnB,YAAY,EAAE,UAAU,CAAC,CAAC,CAAC,EAC3B,gBAAgB,EAAE,UAAU,EAC5B,UAAU,EAAE,UAAU,EACtB,QAAQ,CAAC,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,CAAC,GACT,UAAU,CAAC,CAAC,CAAC,CAKf;IAED,oBAAoB,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAEzD;IAED,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG,KAAK,CAGzC;IAED,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAG1C;CACF"}

package/dist/lib/JsBufferStrategy.js

@@ -1,3 +1,15 @@
+/**
+ * JsBufferStrategy - Default buffer strategy using JavaScript TypedArrays.
+ *
+ * Uses GC-managed memory with zero-copy Arrow conversion via flechette.
+ *
+ * Memory characteristics:
+ * - Buffers are regular JS objects with TypedArray properties
+ * - GC handles deallocation (no explicit release needed)
+ * - Arrow conversion shares ArrayBuffer references (zero-copy)
+ *
+ * @module JsBufferStrategy
+ */
 import { convertSpanTreeToArrowTable } from './convertToArrow.js';
 import { createChildSpanBuffer as createChildSpanBufferImpl, createOverflowBuffer as createOverflowBufferImpl, createSpanBuffer as createSpanBufferImpl, getSpanBufferClass, } from './spanBuffer.js';
 function isSpanBufferConstructorForSchema(ctor, schema) {

package/dist/lib/archive/chunkEnvelope.js

@@ -53,3 +53,4 @@ function fnv1a64(input) {
     }
     return hash.toString(16).padStart(16, '0');
 }
+//#endregion smoo/lmao!n/trace-archive-envelope.build

package/dist/lib/archive/chunkRouting.js

@@ -48,3 +48,4 @@ export function splitChunkByPartition(rows, partitionOf, partitionField = 'group
         };
     });
 }
+//#endregion smoo/lmao!n/trace-archive-partition-split.split

package/dist/lib/archive/chunkStats.js

@@ -9,3 +9,4 @@ export function extractChunkStats(envelope, partitions = []) {
         duration_ms: Math.max(0, envelope.ended_at_ms - envelope.started_at_ms),
     };
 }
+//#endregion smoo/lmao!n/trace-archive-stats.chunk-level

package/dist/lib/arrow/capacityStats.js

@@ -230,3 +230,4 @@ export function createCapacityStatsTable(entriesToLog, periodStartNs, mergedSche
     }
     return tableFromColumns(cols);
 }
+//#endregion smoo/lmao!n/buffer-tuning-stats-logging

package/dist/lib/arrow/dictionaries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dictionaries.d.ts","sourceRoot":"","sources":["../../../src/lib/arrow/dictionaries.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,KAAK,OAAO,EAAyB,MAAM,mBAAmB,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD;;;GAGG;AACH,qBAAa,qBAAqB;aAEd,UAAU,EAAE,MAAM,EAAE;aACpB,OAAO,EAAE,UAAU,GAAG,WAAW,GAAG,WAAW;aAC/C,cAAc,EAAE,qBAAqB,GAAG,sBAAsB,GAAG,sBAAsB;aACvF,cAAc,EAAE,OAAO;aACvB,UAAU,EAAE,UAAU,GAAG,SAAS;aAClC,SAAS,EAAE,MAAM;gBALjB,UAAU,EAAE,MAAM,EAAE,EACpB,OAAO,EAAE,UAAU,GAAG,WAAW,GAAG,WAAW,EAC/C,cAAc,EAAE,qBAAqB,GAAG,sBAAsB,GAAG,sBAAsB,EACvF,cAAc,EAAE,OAAO,EACvB,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,SAAS,EAAE,MAAM;CAEpC;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,aAAa,EAAE,EACxB,UAAU,EAAE,MAAM,EAClB,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GACxC,qBAAqB,CAkDvB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,aAAa,EAAE,EACxB,UAAU,EAAE,MAAM,EAClB,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GACxC,qBAAqB,GAAG,IAAI,CAqE9B"}
+{"version":3,"file":"dictionaries.d.ts","sourceRoot":"","sources":["../../../src/lib/arrow/dictionaries.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,KAAK,OAAO,EAAyB,MAAM,mBAAmB,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD;;;GAGG;AACH,qBAAa,qBAAqB;aAEd,UAAU,EAAE,MAAM,EAAE;aACpB,OAAO,EAAE,UAAU,GAAG,WAAW,GAAG,WAAW;aAC/C,cAAc,EAAE,qBAAqB,GAAG,sBAAsB,GAAG,sBAAsB;aACvF,cAAc,EAAE,OAAO;aACvB,UAAU,EAAE,UAAU,GAAG,SAAS;aAClC,SAAS,EAAE,MAAM;IANnC,YACkB,UAAU,EAAE,MAAM,EAAE,EACpB,OAAO,EAAE,UAAU,GAAG,WAAW,GAAG,WAAW,EAC/C,cAAc,EAAE,qBAAqB,GAAG,sBAAsB,GAAG,sBAAsB,EACvF,cAAc,EAAE,OAAO,EACvB,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,SAAS,EAAE,MAAM,EAC/B;CACL;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,aAAa,EAAE,EACxB,UAAU,EAAE,MAAM,EAClB,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GACxC,qBAAqB,CAkDvB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,aAAa,EAAE,EACxB,UAAU,EAAE,MAAM,EAClB,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GACxC,qBAAqB,GAAG,IAAI,CAqE9B"}

package/dist/lib/buffer/Nanoseconds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Nanoseconds.d.ts","sourceRoot":"","sources":["../../../src/lib/buffer/Nanoseconds.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH;;;;;GAKG;AACH,OAAO,CAAC,MAAM,gBAAgB,EAAE,OAAO,MAAM,CAAC;AAE9C,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,CAAC,gBAAgB,CAAC,EAAE,aAAa,CAAA;CAAE,CAAC;AAOlF;;GAEG;AACH,yBAAiB,WAAW,CAAC;IAC3B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,SAAgB,GAAG,IAAI,WAAW,CAMjC;IAED;;;;;;;;;;OAUG;IACH,SAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAEtD;IAED;;;;;;;;OAQG;IACH,SAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAEjD;IAED;;;;;OAKG;IACH,SAAgB,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAEnD;IAED;;;;;OAKG;IACH,SAAgB,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAEnD;CACF"}
+{"version":3,"file":"Nanoseconds.d.ts","sourceRoot":"","sources":["../../../src/lib/buffer/Nanoseconds.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH;;;;;GAKG;AACH,OAAO,CAAC,MAAM,gBAAgB,EAAE,OAAO,MAAM,CAAC;AAE9C,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,CAAC,gBAAgB,CAAC,EAAE,aAAa,CAAA;CAAE,CAAC;AAOlF;;GAEG;AACH,yBAAiB,WAAW,CAAC,CAAC;IAC5B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,SAAgB,GAAG,IAAI,WAAW,CAMjC;IAED;;;;;;;;;;OAUG;IACH,SAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAEtD;IAED;;;;;;;;OAQG;IACH,SAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAEjD;IAED;;;;;OAKG;IACH,SAAgB,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAEnD;IAED;;;;;OAKG;IACH,SAAgB,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAEnD;CACF"}

package/dist/lib/buffer/Nanoseconds.js

@@ -1,3 +1,37 @@
+/**
+ * Nanoseconds branded type for type-safe timestamp handling
+ *
+ * Prevents accidental unit mixing (milliseconds vs nanoseconds) and provides
+ * a centralized location for timestamp conversion utilities.
+ *
+ * This is a generic buffer concept used for high-precision time-series data.
+ *
+ * **Benefits:**
+ * - Type safety prevents mixing time units
+ * - Self-documenting code - units clear from type
+ * - Zero runtime overhead on hot path (BigInt operations are fast)
+ * - Conversion functions centralized and tested
+ * - Works with Arrow's TimestampNanosecond type
+ *
+ * **Precision:**
+ * - BigInt can represent arbitrarily large integers
+ * - Nanoseconds since epoch will never overflow
+ * - Node.js: Native nanosecond precision via process.hrtime.bigint()
+ * - Browser: Microsecond precision via performance.now() (last 3 digits are 000)
+ *
+ * @module nanoseconds
+ *
+ * @example
+ * ```typescript
+ * import { Nanoseconds } from '@smoothbricks/arrow-builder';
+ *
+ * // Node.js: Native nanoseconds
+ * const timestamp = Nanoseconds.now();
+ *
+ * // Store in buffer (BigInt64Array)
+ * buffer.timestamps[idx] = timestamp; // Type-safe!
+ * ```
+ */
 function toNanoseconds(value) {
     return value;
 }

package/dist/lib/bufferStrategy.js

@@ -1 +1,22 @@
+//#region smoo/lmao!n/buffer-strategy
+/**
+ * BufferStrategy - Abstraction for SpanBuffer memory management and Arrow conversion.
+ *
+ * This interface separates memory management concerns from sink concerns (Tracer):
+ * - BufferStrategy: HOW buffers are allocated and converted (JS TypedArrays vs WASM)
+ * - Tracer (sink): WHAT happens with completed buffers (stdio, queue, test accumulation)
+ *
+ * Key responsibilities:
+ * 1. Buffer creation (root, child, overflow)
+ * 2. Arrow conversion (strategy knows optimal path)
+ * 3. Buffer release (GC for JS, freelist for WASM)
+ *
+ * The sink (Tracer subclass) controls WHEN to convert and release:
+ * - StdioTracer: prints then releases immediately
+ * - TestTracer: holds buffers until clear()
+ * - SqsTracer: accumulates, converts on flush(), then releases
+ *
+ * @module bufferStrategy
+ */
 export {};
+//#endregion smoo/lmao!n/buffer-strategy

package/dist/lib/capacityTuning.js

@@ -1,3 +1,28 @@
+/**
+ * Capacity Tuning - Self-tuning buffer capacity based on utilization
+ *
+ * Per specs/lmao/01b2_buffer_self_tuning.md:
+ * - Track row utilization = totalWrites / (spansCreated * usableRowsPerSpan)
+ * - Increase capacity if utilization > 150% (regularly overflowing)
+ * - Decrease capacity if utilization < 50% (wasting space)
+ * - Maintain power-of-2 capacities between 8 and 1024
+ *
+ * ## Utilization Model
+ *
+ * - 100% = exactly filling first buffer per span (ideal)
+ * - 150% = filling 1.5x first buffer (some spans overflow)
+ * - 200% = filling 2x first buffer (every span overflows once)
+ * - 50% = only using half the first buffer (wasting space)
+ *
+ * The 3x gap between shrink (50%) and grow (150%) thresholds prevents flip-flopping:
+ * - After grow: utilization halves → lands in stable zone
+ * - After shrink: utilization doubles → lands in stable zone
+ *
+ * ## Architecture Note
+ *
+ * Stats are on SpanBufferClass.stats (static property), NOT on LogBinding.
+ * This reduces per-instance memory and avoids sync bugs from having two stat objects.
+ */
 //#region smoo/lmao!n/buffer-tuning-capacity
 /** Minimum spans needed before tuning decisions */
 const MIN_SPANS_FOR_TUNING = 10;
@@ -64,3 +89,4 @@ export function shouldTuneCapacity(stats) {
         resetStats(stats);
     }
 }
+//#endregion smoo/lmao!n/buffer-tuning-capacity

package/dist/lib/cleanupDiagnostics.js

@@ -34,8 +34,8 @@ export function cleanupDebugActiveHandles(label) {
         if (typeof handle !== 'object' || handle === null) {
             return typeof handle;
         }
-        const constructor = Reflect.get(handle, 'constructor');
-        const name = typeof constructor === 'function' ? Reflect.get(constructor, 'name') : undefined;
+        const handleConstructor = Reflect.get(handle, 'constructor');
+        const name = typeof handleConstructor === 'function' ? Reflect.get(handleConstructor, 'name') : undefined;
         return typeof name === 'string' && name.length > 0 ? name : 'Object';
     });
     cleanupDebug(label, { activeHandleCount: handles.length, activeHandles: names });

package/dist/lib/cloudflare/classSplit.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Class-split flush adapter — routes each completed root buffer's rows by delivery class.
+ *
+ * Per specs/lmao/01u_cloudflare_trace_segments.md §Delivery Classes every trace row belongs to
+ * exactly one class:
+ * - billing-grade rows go to the CollectorClient, AWAITED within the request via
+ *   `settleBillable()` before/alongside response completion — an Err fails the billable request
+ *   (backpressure ownership: never silently queue billing-grade rows in the isolate)
+ * - diagnostic rows go to the drain transport lazily, on the waitUntil-scheduled `flush()`
+ *
+ * The classifier is an injected function: the spec fixes the CLASSES, not the classification
+ * mechanism, so the mapping from row to class stays a seam (constructor-injected like the
+ * transports).
+ *
+ * Canonical request flow (01s wrapper seam):
+ *   const settled = await tracer.settleBillable();   // before returning the response
+ *   if (settled instanceof Err) return failBillableRequest(settled.error);
+ *   ctx.waitUntil(tracer.flush());                    // diagnostics, fire-and-forget
+ */
+import type { OpContextBinding } from '../opContext/types.js';
+import { type Result } from '../result.js';
+import type { TracerOptions } from '../tracer.js';
+import { ArrayQueueTracer } from '../tracers/ArrayQueueTracer.js';
+import type { CollectorAck, CollectorClient, CollectorSendFailure } from './collectorClient.js';
+import type { DiagnosticTransport } from './diagnosticDrain.js';
+import { type TraceRow } from './traceRows.js';
+export type DeliveryClass = 'billing-grade' | 'diagnostic';
+/** Injected classification seam — decides which lane one row rides. */
+export type DeliveryClassifier = (row: TraceRow) => DeliveryClass;
+export interface ClassSplitOptions<T extends import('../schema/LogSchema.js').LogSchema = import('../schema/LogSchema.js').LogSchema> extends TracerOptions<T> {
+    collector: CollectorClient;
+    diagnostics: DiagnosticTransport;
+    classify: DeliveryClassifier;
+    /** Diagnostic-lane failure hook: emit metrics; drop is within the class's loss budget. */
+    onDiagnosticSendError?: (error: unknown, rows: readonly TraceRow[]) => void;
+    /**
+     * Billing rows found only at flush() time (the wrapper skipped settleBillable) whose late
+     * awaited send failed. This is a broken-integration alarm — page on it; the rows are lost to
+     * this isolate and only replay/reconciliation (01u §Zero-Loss Sources) can heal the gap.
+     */
+    onLateBillableSendFailure?: (failure: CollectorSendFailure, rows: readonly TraceRow[]) => void;
+}
+/**
+ * Tracer tying the two lanes together over onTraceEnd (queue) + settleBillable/flush (drain).
+ *
+ * Diagnostic rows discovered during settleBillable are held for the same request's flush() —
+ * request-scoped staging only, never cross-request accumulation of billing-grade data.
+ */
+export declare class ClassSplitTracer<B extends OpContextBinding = OpContextBinding> extends ArrayQueueTracer<B> {
+    private readonly collector;
+    private readonly diagnostics;
+    private readonly classify;
+    private readonly onDiagnosticSendError;
+    private readonly onLateBillableSendFailure;
+    private pendingDiagnosticRows;
+    constructor(binding: B, options: ClassSplitOptions<B['logBinding']['logSchema']>);
+    private partitionDrained;
+    /**
+     * Drain completed traces and durably deliver the billing-grade rows — awaited within the
+     * request. Ok(null) means no billing rows were produced; Err means the collector could not
+     * make the revenue records durable and the billable request must fail. Diagnostic rows are
+     * staged for this request's flush().
+     */
+    settleBillable(): Promise<Result<CollectorAck | null, CollectorSendFailure>>;
+    /**
+     * Lazy, waitUntil-schedulable drain: never rejects. Diagnostic rows (staged + newly drained)
+     * go to the drain transport; failures hit onDiagnosticSendError per the class's loss budget.
+     * Billing rows found here mean settleBillable was skipped — they are still sent awaited (never
+     * silently dropped or left buffered), with failures escalated via onLateBillableSendFailure.
+     */
+    flush(): Promise<void>;
+}
+//# sourceMappingURL=classSplit.d.ts.map

package/dist/lib/cloudflare/classSplit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classSplit.d.ts","sourceRoot":"","sources":["../../../src/lib/cloudflare/classSplit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAChG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAyB,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAEtE,MAAM,MAAM,aAAa,GAAG,eAAe,GAAG,YAAY,CAAC;AAE3D,uEAAuE;AACvE,MAAM,MAAM,kBAAkB,GAAG,CAAC,GAAG,EAAE,QAAQ,KAAK,aAAa,CAAC;AAKlE,MAAM,WAAW,iBAAiB,CAChC,CAAC,SAAS,OAAO,wBAAwB,EAAE,SAAS,GAAG,OAAO,wBAAwB,EAAE,SAAS,CACjG,SAAQ,aAAa,CAAC,CAAC,CAAC;IACxB,SAAS,EAAE,eAAe,CAAC;IAC3B,WAAW,EAAE,mBAAmB,CAAC;IACjC,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,0FAA0F;IAC1F,qBAAqB,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,QAAQ,EAAE,KAAK,IAAI,CAAC;IAC5E;;;;OAIG;IACH,yBAAyB,CAAC,EAAE,CAAC,OAAO,EAAE,oBAAoB,EAAE,IAAI,EAAE,SAAS,QAAQ,EAAE,KAAK,IAAI,CAAC;CAChG;AAOD;;;;;GAKG;AACH,qBAAa,gBAAgB,CAAC,CAAC,SAAS,gBAAgB,GAAG,gBAAgB,CAAE,SAAQ,gBAAgB,CAAC,CAAC,CAAC;IACtG,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkB;IAC5C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAsB;IAClD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAC9C,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAoE;IAC1G,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAE5B;IACd,OAAO,CAAC,qBAAqB,CAAkB;IAE/C,YAAY,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,CAAC,EAO/E;IAED,OAAO,CAAC,gBAAgB;IAiBxB;;;;;OAKG;IACG,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC,YAAY,GAAG,IAAI,EAAE,oBAAoB,CAAC,CAAC,CAKjF;IAED;;;;;OAKG;IACY,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAmBpC;CACF"}

package/dist/lib/cloudflare/classSplit.js

@@ -0,0 +1,101 @@
+/**
+ * Class-split flush adapter — routes each completed root buffer's rows by delivery class.
+ *
+ * Per specs/lmao/01u_cloudflare_trace_segments.md §Delivery Classes every trace row belongs to
+ * exactly one class:
+ * - billing-grade rows go to the CollectorClient, AWAITED within the request via
+ *   `settleBillable()` before/alongside response completion — an Err fails the billable request
+ *   (backpressure ownership: never silently queue billing-grade rows in the isolate)
+ * - diagnostic rows go to the drain transport lazily, on the waitUntil-scheduled `flush()`
+ *
+ * The classifier is an injected function: the spec fixes the CLASSES, not the classification
+ * mechanism, so the mapping from row to class stays a seam (constructor-injected like the
+ * transports).
+ *
+ * Canonical request flow (01s wrapper seam):
+ *   const settled = await tracer.settleBillable();   // before returning the response
+ *   if (settled instanceof Err) return failBillableRequest(settled.error);
+ *   ctx.waitUntil(tracer.flush());                    // diagnostics, fire-and-forget
+ */
+import { Err, Ok } from '../result.js';
+import { ArrayQueueTracer } from '../tracers/ArrayQueueTracer.js';
+import { spanBufferToTraceRows } from './traceRows.js';
+/** Singleton for the common "nothing billable in this request" settle outcome. */
+const SETTLED_NOTHING_BILLABLE = new Ok(null);
+/**
+ * Tracer tying the two lanes together over onTraceEnd (queue) + settleBillable/flush (drain).
+ *
+ * Diagnostic rows discovered during settleBillable are held for the same request's flush() —
+ * request-scoped staging only, never cross-request accumulation of billing-grade data.
+ */
+export class ClassSplitTracer extends ArrayQueueTracer {
+    collector;
+    diagnostics;
+    classify;
+    onDiagnosticSendError;
+    onLateBillableSendFailure;
+    pendingDiagnosticRows = [];
+    constructor(binding, options) {
+        super(binding, options);
+        this.collector = options.collector;
+        this.diagnostics = options.diagnostics;
+        this.classify = options.classify;
+        this.onDiagnosticSendError = options.onDiagnosticSendError;
+        this.onLateBillableSendFailure = options.onLateBillableSendFailure;
+    }
+    partitionDrained() {
+        const billing = [];
+        const diagnostic = [];
+        for (const buffer of this.drain()) {
+            let rows;
+            try {
+                rows = spanBufferToTraceRows(buffer);
+            }
+            finally {
+                this.bufferStrategy.releaseBuffer(buffer);
+            }
+            for (const row of rows) {
+                (this.classify(row) === 'billing-grade' ? billing : diagnostic).push(row);
+            }
+        }
+        return { billing, diagnostic };
+    }
+    /**
+     * Drain completed traces and durably deliver the billing-grade rows — awaited within the
+     * request. Ok(null) means no billing rows were produced; Err means the collector could not
+     * make the revenue records durable and the billable request must fail. Diagnostic rows are
+     * staged for this request's flush().
+     */
+    async settleBillable() {
+        const { billing, diagnostic } = this.partitionDrained();
+        this.pendingDiagnosticRows.push(...diagnostic);
+        if (billing.length === 0)
+            return SETTLED_NOTHING_BILLABLE;
+        return this.collector.send(billing);
+    }
+    /**
+     * Lazy, waitUntil-schedulable drain: never rejects. Diagnostic rows (staged + newly drained)
+     * go to the drain transport; failures hit onDiagnosticSendError per the class's loss budget.
+     * Billing rows found here mean settleBillable was skipped — they are still sent awaited (never
+     * silently dropped or left buffered), with failures escalated via onLateBillableSendFailure.
+     */
+    async flush() {
+        const { billing, diagnostic } = this.partitionDrained();
+        const diagnosticRows = this.pendingDiagnosticRows.concat(diagnostic);
+        this.pendingDiagnosticRows = [];
+        if (billing.length > 0) {
+            const result = await this.collector.send(billing);
+            if (result instanceof Err) {
+                this.onLateBillableSendFailure?.(result.error, billing);
+            }
+        }
+        if (diagnosticRows.length > 0) {
+            try {
+                await this.diagnostics.send(diagnosticRows);
+            }
+            catch (error) {
+                this.onDiagnosticSendError?.(error, diagnosticRows);
+            }
+        }
+    }
+}

package/dist/lib/cloudflare/collectorClient.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Billing-grade collector client.
+ *
+ * Per specs/lmao/01u_cloudflare_trace_segments.md §Delivery Classes / §Zero-Loss Sources:
+ * `send(rows)` resolves Ok only when the collector has ACKED — and the ack means the collector
+ * DO's transactional-storage commit completed, which IS the durability point. From that moment
+ * the rows are durable and replay-owned.
+ *
+ * Send-before-response contract: the caller awaits `send` within the request; an Err fails the
+ * billable request (same principle as any payment-gateway outage). Implementations and callers
+ * must NEVER buffer billing-grade rows in the isolate across requests — an isolate eviction
+ * between requests silently destroys revenue records.
+ *
+ * The collector DO itself is not deployed yet; this module ships the interface plus an in-memory
+ * fake with ack/fail/latency injection so lane composition is testable today.
+ */
+import { type Result } from '../result.js';
+import type { TraceRow } from './traceRows.js';
+/** Proof of collector durability: the DO transactional-storage commit completed. */
+export interface CollectorAck {
+    readonly durable: true;
+}
+/** Singleton ack — the ack carries no data, so never allocate it per send. */
+export declare const COLLECTOR_ACK: CollectorAck;
+/** Operational send failure — the caller must fail the billable request on this. */
+export interface CollectorSendFailure {
+    readonly code: 'collector-unavailable' | 'collector-rejected';
+    readonly message: string;
+}
+/**
+ * Transport to the billing-grade collector shard.
+ *
+ * `send` resolves Ok(CollectorAck) only after the collector's DO transactional-storage commit;
+ * operational failures come back as Err (never throw) so the request path can fail deliberately.
+ */
+export interface CollectorClient {
+    send(rows: readonly TraceRow[]): Promise<Result<CollectorAck, CollectorSendFailure>>;
+}
+/**
+ * In-memory CollectorClient fake with ack/fail/latency injection.
+ *
+ * Modes:
+ * - default: every send acks immediately (after optional injected latency)
+ * - `failNext(failure)`: queue an Err for upcoming sends
+ * - `holdSends()`: sends stay pending until the test calls `ackNext()`/`rejectNext()` — this is
+ *   how contract tests prove "resolves only when the collector acks"
+ */
+export declare class FakeCollectorClient implements CollectorClient {
+    /** Row batches the fake has durably acked, in ack order. */
+    readonly acked: (readonly TraceRow[])[];
+    private readonly failures;
+    private readonly held;
+    private holding;
+    private latencyMs;
+    /** Queue an Err result for the next send (FIFO across multiple calls). */
+    failNext(failure: CollectorSendFailure): void;
+    /** Inject artificial ack latency for subsequent sends. */
+    setLatency(ms: number): void;
+    /** Switch to manual mode: sends stay pending until ackNext()/rejectNext(). */
+    holdSends(): void;
+    /** Number of sends currently awaiting a manual ack. */
+    get pendingCount(): number;
+    /** Ack the oldest held send (DO commit happened). */
+    ackNext(): void;
+    /** Fail the oldest held send with an operational failure. */
+    rejectNext(failure: CollectorSendFailure): void;
+    send(rows: readonly TraceRow[]): Promise<Result<CollectorAck, CollectorSendFailure>>;
+}
+//# sourceMappingURL=collectorClient.d.ts.map

package/dist/lib/cloudflare/collectorClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectorClient.d.ts","sourceRoot":"","sources":["../../../src/lib/cloudflare/collectorClient.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,oFAAoF;AACpF,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC;CACxB;AAED,8EAA8E;AAC9E,eAAO,MAAM,aAAa,EAAE,YAAgC,CAAC;AAE7D,oFAAoF;AACpF,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,uBAAuB,GAAG,oBAAoB,CAAC;IAC9D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,IAAI,EAAE,SAAS,QAAQ,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,oBAAoB,CAAC,CAAC,CAAC;CACtF;AAOD;;;;;;;;GAQG;AACH,qBAAa,mBAAoB,YAAW,eAAe;IACzD,4DAA4D;IAC5D,QAAQ,CAAC,KAAK,EAAE,CAAC,SAAS,QAAQ,EAAE,CAAC,EAAE,CAAM;IAE7C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8B;IACvD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAkB;IACvC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAK;IAEtB,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI,CAE5C;IAED,0DAA0D;IAC1D,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAE3B;IAED,8EAA8E;IAC9E,SAAS,IAAI,IAAI,CAEhB;IAED,uDAAuD;IACvD,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,qDAAqD;IACrD,OAAO,IAAI,IAAI,CAKd;IAED,6DAA6D;IAC7D,UAAU,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI,CAI9C;IAEK,IAAI,CAAC,IAAI,EAAE,SAAS,QAAQ,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,oBAAoB,CAAC,CAAC,CAazF;CACF"}

package/dist/lib/cloudflare/collectorClient.js

@@ -0,0 +1,82 @@
+/**
+ * Billing-grade collector client.
+ *
+ * Per specs/lmao/01u_cloudflare_trace_segments.md §Delivery Classes / §Zero-Loss Sources:
+ * `send(rows)` resolves Ok only when the collector has ACKED — and the ack means the collector
+ * DO's transactional-storage commit completed, which IS the durability point. From that moment
+ * the rows are durable and replay-owned.
+ *
+ * Send-before-response contract: the caller awaits `send` within the request; an Err fails the
+ * billable request (same principle as any payment-gateway outage). Implementations and callers
+ * must NEVER buffer billing-grade rows in the isolate across requests — an isolate eviction
+ * between requests silently destroys revenue records.
+ *
+ * The collector DO itself is not deployed yet; this module ships the interface plus an in-memory
+ * fake with ack/fail/latency injection so lane composition is testable today.
+ */
+import { Err, Ok } from '../result.js';
+/** Singleton ack — the ack carries no data, so never allocate it per send. */
+export const COLLECTOR_ACK = { durable: true };
+/**
+ * In-memory CollectorClient fake with ack/fail/latency injection.
+ *
+ * Modes:
+ * - default: every send acks immediately (after optional injected latency)
+ * - `failNext(failure)`: queue an Err for upcoming sends
+ * - `holdSends()`: sends stay pending until the test calls `ackNext()`/`rejectNext()` — this is
+ *   how contract tests prove "resolves only when the collector acks"
+ */
+export class FakeCollectorClient {
+    /** Row batches the fake has durably acked, in ack order. */
+    acked = [];
+    failures = [];
+    held = [];
+    holding = false;
+    latencyMs = 0;
+    /** Queue an Err result for the next send (FIFO across multiple calls). */
+    failNext(failure) {
+        this.failures.push(failure);
+    }
+    /** Inject artificial ack latency for subsequent sends. */
+    setLatency(ms) {
+        this.latencyMs = ms;
+    }
+    /** Switch to manual mode: sends stay pending until ackNext()/rejectNext(). */
+    holdSends() {
+        this.holding = true;
+    }
+    /** Number of sends currently awaiting a manual ack. */
+    get pendingCount() {
+        return this.held.length;
+    }
+    /** Ack the oldest held send (DO commit happened). */
+    ackNext() {
+        const pending = this.held.shift();
+        if (!pending)
+            throw new Error('FakeCollectorClient.ackNext: no held send');
+        this.acked.push(pending.rows);
+        pending.resolve(new Ok(COLLECTOR_ACK));
+    }
+    /** Fail the oldest held send with an operational failure. */
+    rejectNext(failure) {
+        const pending = this.held.shift();
+        if (!pending)
+            throw new Error('FakeCollectorClient.rejectNext: no held send');
+        pending.resolve(new Err(failure));
+    }
+    async send(rows) {
+        if (this.latencyMs > 0) {
+            await new Promise((resolve) => setTimeout(resolve, this.latencyMs));
+        }
+        if (this.holding) {
+            return new Promise((resolve) => {
+                this.held.push({ rows, resolve });
+            });
+        }
+        const failure = this.failures.shift();
+        if (failure)
+            return new Err(failure);
+        this.acked.push(rows);
+        return new Ok(COLLECTOR_ACK);
+    }
+}

package/dist/lib/cloudflare/diagnosticDrain.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Diagnostic-class drain adapter.
+ *
+ * Per specs/lmao/01u_cloudflare_trace_segments.md §LMAO Sink Fit: no new abstraction — the base
+ * Tracer lifecycle (onTraceEnd queueing + flush) already models this. The drain tracer extends
+ * ArrayQueueTracer; flush() drains completed root buffers, flattens them to rows, and hands them
+ * to a constructor-injected transport.
+ *
+ * Transports (per 01u §Collection Lanes and Fallbacks):
+ * - primary: a Pipelines-stream-binding-shaped send fn (`env.TRACE_STREAM.send(rows)`) — rows,
+ *   because Pipelines owns batching and Parquet encoding for the raw tier
+ * - fallback: Cloudflare Queues — batched TraceChunkEnvelope messages built from the existing
+ *   lib/archive primitives (chunk_id idempotency); NEVER per-span messages (128 KB messages,
+ *   per-64 KB op billing make per-span ~160x more expensive)
+ *
+ * Delivery is fire-and-forget: flush() is scheduled via ctx.waitUntil and never rejects; enqueue
+ * failures surface through the onSendError hook (01s §Failure Handling — emit metrics, rely on
+ * queue policy/backoff), they never block.
+ */
+import { type TraceChunkEnvelope } from '../archive/chunkEnvelope.js';
+import type { OpContextBinding } from '../opContext/types.js';
+import type { TracerOptions } from '../tracer.js';
+import { ArrayQueueTracer } from '../tracers/ArrayQueueTracer.js';
+import { type TraceRow } from './traceRows.js';
+/** Shape of a Cloudflare Pipelines stream binding's send — promise resolves on confirmed ingest. */
+export type PipelinesStreamSend = (rows: TraceRow[]) => Promise<void>;
+/** Diagnostic-lane transport seam: delivers one drained batch of rows, at most best-effort. */
+export interface DiagnosticTransport {
+    send(rows: readonly TraceRow[]): Promise<void>;
+}
+/** Primary diagnostic transport: rows straight into the injected Pipelines stream binding. */
+export declare class PipelinesStreamTransport implements DiagnosticTransport {
+    private readonly sendToStream;
+    constructor(sendToStream: PipelinesStreamSend);
+    send(rows: readonly TraceRow[]): Promise<void>;
+}
+/** One Queues-fallback message: chunk envelope (idempotency + routing metadata) plus its rows. */
+export interface TraceChunkQueueMessage {
+    readonly envelope: TraceChunkEnvelope;
+    readonly rows: readonly TraceRow[];
+}
+export interface QueuesFallbackOptions {
+    /** Logical file reference recorded in the envelopes, e.g. 'queue://worker-name'. */
+    fileRef: string;
+    /** Max rows per queue message — bounds message size under the 128 KB Queues limit. */
+    maxRowsPerMessage: number;
+    /** Injected queue producer, e.g. (msg) => env.TRACE_QUEUE.send(msg). */
+    sendMessage: (message: TraceChunkQueueMessage) => Promise<void>;
+}
+/**
+ * Queues-fallback transport: rows are batched into chunk-envelope messages.
+ *
+ * The chunk_ref is a deterministic content hash of the batch, so a retried send of the same
+ * batch produces the same chunk_id and the consumer's chunk_id dedup makes redelivery a no-op.
+ */
+export declare class QueuesFallbackTransport implements DiagnosticTransport {
+    private readonly options;
+    constructor(options: QueuesFallbackOptions);
+    send(rows: readonly TraceRow[]): Promise<void>;
+}
+export interface DiagnosticDrainOptions<T extends import('../schema/LogSchema.js').LogSchema = import('../schema/LogSchema.js').LogSchema> extends TracerOptions<T> {
+    transport: DiagnosticTransport;
+    /** Failure hook (01s §Failure Handling): emit runtime metrics/alerts here; never rethrows. */
+    onSendError?: (error: unknown, rows: readonly TraceRow[]) => void;
+}
+/**
+ * Diagnostic-lane sink tracer: queue completed roots (ArrayQueueTracer), drain + send on flush().
+ *
+ * flush() is waitUntil-schedulable: it never rejects, and buffers are always released back to
+ * the strategy regardless of transport outcome.
+ */
+export declare class DiagnosticDrainTracer<B extends OpContextBinding = OpContextBinding> extends ArrayQueueTracer<B> {
+    private readonly transport;
+    private readonly onSendError;
+    constructor(binding: B, options: DiagnosticDrainOptions<B['logBinding']['logSchema']>);
+    flush(): Promise<void>;
+}
+//# sourceMappingURL=diagnosticDrain.d.ts.map

package/dist/lib/cloudflare/diagnosticDrain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnosticDrain.d.ts","sourceRoot":"","sources":["../../../src/lib/cloudflare/diagnosticDrain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAA2B,KAAK,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAC/F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAyB,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAEtE,oGAAoG;AACpG,MAAM,MAAM,mBAAmB,GAAG,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEtE,+FAA+F;AAC/F,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,IAAI,EAAE,SAAS,QAAQ,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAChD;AAED,8FAA8F;AAC9F,qBAAa,wBAAyB,YAAW,mBAAmB;IACtD,OAAO,CAAC,QAAQ,CAAC,YAAY;IAAzC,YAA6B,YAAY,EAAE,mBAAmB,EAAI;IAElE,IAAI,CAAC,IAAI,EAAE,SAAS,QAAQ,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAG7C;CACF;AAED,kGAAkG;AAClG,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC;IACtC,QAAQ,CAAC,IAAI,EAAE,SAAS,QAAQ,EAAE,CAAC;CACpC;AAED,MAAM,WAAW,qBAAqB;IACpC,oFAAoF;IACpF,OAAO,EAAE,MAAM,CAAC;IAChB,sFAAsF;IACtF,iBAAiB,EAAE,MAAM,CAAC;IAC1B,wEAAwE;IACxE,WAAW,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACjE;AAwBD;;;;;GAKG;AACH,qBAAa,uBAAwB,YAAW,mBAAmB;IACrD,OAAO,CAAC,QAAQ,CAAC,OAAO;IAApC,YAA6B,OAAO,EAAE,qBAAqB,EAI1D;IAEK,IAAI,CAAC,IAAI,EAAE,SAAS,QAAQ,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAcnD;CACF;AAED,MAAM,WAAW,sBAAsB,CACrC,CAAC,SAAS,OAAO,wBAAwB,EAAE,SAAS,GAAG,OAAO,wBAAwB,EAAE,SAAS,CACjG,SAAQ,aAAa,CAAC,CAAC,CAAC;IACxB,SAAS,EAAE,mBAAmB,CAAC;IAC/B,8FAA8F;IAC9F,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,QAAQ,EAAE,KAAK,IAAI,CAAC;CACnE;AAED;;;;;GAKG;AACH,qBAAa,qBAAqB,CAAC,CAAC,SAAS,gBAAgB,GAAG,gBAAgB,CAAE,SAAQ,gBAAgB,CAAC,CAAC,CAAC;IAC3G,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAsB;IAChD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoE;IAEhG,YAAY,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,sBAAsB,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,WAAW,CAAC,CAAC,EAIpF;IAEc,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAepC;CACF"}