@squasher-ai/nextjs 0.3.0 → 0.4.0

package/dist/_vendor/node-sdk/delivery-stats.d.ts

@@ -0,0 +1,40 @@
+export type DeliveryOutcomeCategory = "sent" | "network_error" | "unauthorized" | "rate_limited" | "rejected" | "server_error";
+export interface DeliveryOutcome {
+    readonly category: DeliveryOutcomeCategory;
+    readonly statusCode: number | null;
+}
+export interface DeliveryStats {
+    readonly queueDepth: number;
+    readonly queueHighWaterMark: number;
+    readonly attemptedBatches: number;
+    readonly attemptedEvents: number;
+    readonly sentBatches: number;
+    readonly sentEvents: number;
+    readonly retriedBatches: number;
+    readonly retriedEvents: number;
+    readonly droppedBatches: number;
+    readonly droppedEvents: number;
+    readonly lastOutcome: DeliveryOutcome | null;
+    readonly lastFlushDurationMs: number | null;
+}
+export declare class DeliveryStatsTracker {
+    private queueHighWaterMark;
+    private attemptedBatches;
+    private attemptedEvents;
+    private sentBatches;
+    private sentEvents;
+    private retriedBatches;
+    private retriedEvents;
+    private droppedBatches;
+    private droppedEvents;
+    private lastOutcome;
+    private lastFlushDurationMs;
+    recordQueueDepth(queueDepth: number): void;
+    recordAttempt(eventCount: number): void;
+    recordRetry(eventCount: number): void;
+    recordSent(eventCount: number, statusCode: number): void;
+    recordDropped(eventCount: number, category: Exclude<DeliveryOutcomeCategory, "sent">, statusCode: number | null): void;
+    recordFlushDuration(durationMs: number): void;
+    snapshot(queueDepth: number): DeliveryStats;
+    private setOutcome;
+}

package/dist/_vendor/node-sdk/delivery-stats.js

@@ -0,0 +1,57 @@
+export class DeliveryStatsTracker {
+    queueHighWaterMark = 0;
+    attemptedBatches = 0;
+    attemptedEvents = 0;
+    sentBatches = 0;
+    sentEvents = 0;
+    retriedBatches = 0;
+    retriedEvents = 0;
+    droppedBatches = 0;
+    droppedEvents = 0;
+    lastOutcome = null;
+    lastFlushDurationMs = null;
+    recordQueueDepth(queueDepth) {
+        this.queueHighWaterMark = Math.max(this.queueHighWaterMark, queueDepth);
+    }
+    recordAttempt(eventCount) {
+        this.attemptedBatches++;
+        this.attemptedEvents += eventCount;
+    }
+    recordRetry(eventCount) {
+        this.retriedBatches++;
+        this.retriedEvents += eventCount;
+    }
+    recordSent(eventCount, statusCode) {
+        this.sentBatches++;
+        this.sentEvents += eventCount;
+        this.setOutcome("sent", statusCode);
+    }
+    recordDropped(eventCount, category, statusCode) {
+        this.droppedBatches++;
+        this.droppedEvents += eventCount;
+        this.setOutcome(category, statusCode);
+    }
+    recordFlushDuration(durationMs) {
+        this.lastFlushDurationMs = Math.max(0, durationMs);
+    }
+    snapshot(queueDepth) {
+        const lastOutcome = this.lastOutcome ? Object.freeze({ ...this.lastOutcome }) : null;
+        return Object.freeze({
+            queueDepth,
+            queueHighWaterMark: this.queueHighWaterMark,
+            attemptedBatches: this.attemptedBatches,
+            attemptedEvents: this.attemptedEvents,
+            sentBatches: this.sentBatches,
+            sentEvents: this.sentEvents,
+            retriedBatches: this.retriedBatches,
+            retriedEvents: this.retriedEvents,
+            droppedBatches: this.droppedBatches,
+            droppedEvents: this.droppedEvents,
+            lastOutcome,
+            lastFlushDurationMs: this.lastFlushDurationMs,
+        });
+    }
+    setOutcome(category, statusCode) {
+        this.lastOutcome = { category, statusCode };
+    }
+}

package/dist/_vendor/node-sdk/http.d.ts

@@ -0,0 +1,22 @@
+import type { SquasherClient } from "./client.js";
+import type { ErrorEvent, TraceContext } from "./types.js";
+export type HttpHeadersLike = Headers | Record<string, number | string | string[] | undefined> | Iterable<readonly [string, string]>;
+export interface HttpRequestLike {
+    method?: string;
+    url?: string;
+    originalUrl?: string;
+    headers?: HttpHeadersLike;
+}
+export interface HttpResponseLike {
+    status?: number;
+    statusCode?: number;
+}
+export interface HttpRequestContext {
+    request: HttpRequestLike;
+    response?: HttpResponseLike;
+    attributes?: ErrorEvent["attributes"];
+    extra?: ErrorEvent["extra"];
+    /** Incoming or ambient trace parent. */
+    trace?: Pick<TraceContext, "span_id" | "trace_id">;
+}
+export declare function withHttpRequest<T>(client: SquasherClient, context: HttpRequestContext, handler: () => T | Promise<T>): Promise<T>;

package/dist/_vendor/node-sdk/http.js

@@ -0,0 +1,139 @@
+import { createRedactor } from "../sdk-runtime/runtime/public-sdk-runtime.js";
+import { createTraceContext } from "./trace-context.js";
+const redactRequestValue = createRedactor();
+export async function withHttpRequest(client, context, handler) {
+    const startedAt = Date.now();
+    const trace = createTraceContext(context.trace);
+    let failure;
+    try {
+        return await handler();
+    }
+    catch (cause) {
+        failure = cause instanceof Error ? cause : new Error(String(cause));
+        throw cause;
+    }
+    finally {
+        const durationMs = Date.now() - startedAt;
+        const status = readStatus(context.response) ?? (failure ? 500 : 200);
+        const request = normalizeRequest(context.request);
+        const route = readRoute(context.attributes, request.url);
+        const outcome = status >= 400 || failure ? "failure" : "success";
+        try {
+            const measurements = [
+                { name: "http.server.request.count", unit: "1", value: 1 },
+                { name: "http.server.request.duration_ms", unit: "ms", value: durationMs },
+            ];
+            if (status >= 400) {
+                measurements.push({ name: "http.server.request.failure.count", unit: "1", value: 1 });
+            }
+            const event = {
+                attributes: {
+                    "http.request.method": request.method ?? "GET",
+                    "http.response.status_code": status,
+                    "http.route": route,
+                    "squasher.operation": route,
+                    "squasher.outcome": outcome,
+                    ...context.attributes,
+                },
+                event_name: "http.request.completed",
+                extra: {
+                    ...context.extra,
+                    squasher_http: { duration_ms: durationMs, status_code: status },
+                },
+                kind: failure ? "error" : "log",
+                level: failure || status >= 500 ? "error" : status >= 400 ? "warning" : "info",
+                measurements,
+                message: `http request ${outcome}`,
+                request,
+                timestamp: new Date(startedAt).toISOString(),
+                trace: {
+                    ...trace,
+                    duration_ms: durationMs,
+                    span_kind: "server",
+                    span_name: `${request.method ?? "GET"} ${route}`,
+                    status: failure || status >= 500 ? "error" : "ok",
+                },
+            };
+            if (failure) {
+                event.stack = failure.stack;
+                event.type = failure.name;
+            }
+            await client.captureTelemetry(event);
+        }
+        catch {
+            // Telemetry must not change the request outcome.
+        }
+    }
+}
+function readRoute(attributes, url) {
+    const configured = attributes?.["http.route"];
+    return Object.prototype.toString.call(configured) === "[object String]"
+        ? String(configured)
+        : routeFromUrl(url);
+}
+function routeFromUrl(url) {
+    if (!url)
+        return "/";
+    try {
+        return new URL(url).pathname;
+    }
+    catch {
+        return url.split("?", 1)[0] || "/";
+    }
+}
+function normalizeRequest(request) {
+    return {
+        method: request.method,
+        url: sanitizeUrl(request.originalUrl ?? request.url),
+        headers: normalizeHeaders(request.headers),
+    };
+}
+function sanitizeUrl(url) {
+    if (!url)
+        return undefined;
+    try {
+        const parsed = new URL(url);
+        return `${parsed.origin}${parsed.pathname}`;
+    }
+    catch {
+        return url.split("?")[0];
+    }
+}
+function normalizeHeaders(headers) {
+    if (!headers)
+        return undefined;
+    const normalized = {};
+    if (headers instanceof Headers) {
+        headers.forEach((value, key) => {
+            normalized[key] = value;
+        });
+        return redactHeaderRecord(normalized);
+    }
+    if (Symbol.iterator in headers) {
+        for (const [key, value] of headers) {
+            normalized[key] = value;
+        }
+        return redactHeaderRecord(normalized);
+    }
+    for (const [key, value] of Object.entries(headers)) {
+        if (Array.isArray(value)) {
+            normalized[key] = value.join(", ");
+        }
+        else if (value !== undefined) {
+            normalized[key] = String(value);
+        }
+    }
+    return redactHeaderRecord(normalized);
+}
+function readStatus(response) {
+    return response?.status ?? response?.statusCode;
+}
+function redactHeaderRecord(headers) {
+    // SAFETY: createRedactor preserves object shape and replaces only leaf values.
+    const redacted = redactRequestValue(headers);
+    const result = {};
+    for (const [key, value] of Object.entries(redacted)) {
+        result[key] = String(value);
+    }
+    return result;
+}

package/dist/_vendor/node-sdk/index.d.ts

@@ -0,0 +1,36 @@
+export { SquasherClient } from "./client.js";
+export type { DeliveryOutcome, DeliveryOutcomeCategory, DeliveryStats } from "./delivery-stats.js";
+export { withHttpRequest } from "./http.js";
+export type { HttpRequestContext, HttpRequestLike, HttpResponseLike } from "./http.js";
+export { withAwsLambda } from "./aws-lambda.js";
+export type { AwsLambdaContextLike, AwsLambdaHandler, AwsLambdaOptions } from "./aws-lambda.js";
+export { createSpanId, createTraceContext, createTraceId } from "./trace-context.js";
+export { ActionableError, createActionableError, createRedactor, detectRelease, isValidRelease, parseRelease, } from "../sdk-runtime/runtime/public-sdk-runtime.js";
+export type { ActionableErrorContext, ActionableErrorInternal, ActionableErrorOptions, ParsedRelease, Redactor, RedactorOptions, } from "../sdk-runtime/runtime/public-sdk-runtime.js";
+export type { AnalyticsContext, Breadcrumb, CaptureErrorOptions, ErrorEvent, IngestBatchPayload, IngestResponse, JsonObject, JsonValue, Level, LocalEventSinkConfig, LlmContext, PageContext, RequestContext, SessionContext, SquasherConfig, StackFrame, TelemetryKind, TelemetryMeasurement, TelemetrySamplingConfig, ToolCallContext, TraceContext, UserContext, VisitorContext, } from "./types.js";
+import { SquasherClient } from "./client.js";
+import type { Breadcrumb, CaptureErrorOptions, ErrorEvent, JsonObject, Level, SquasherConfig, UserContext } from "./types.js";
+/** Initialize the global Squasher client. Throws if called twice. */
+export declare function init(config: SquasherConfig): SquasherClient;
+/** Get the global client (throws if not initialized). */
+export declare function getClient(): SquasherClient;
+export declare function captureError(error: Error, extra?: JsonObject, options?: CaptureErrorOptions): Promise<string | null>;
+export declare function captureMessage(message: string, level?: Level): Promise<string | null>;
+export declare function captureTelemetry(event: ErrorEvent): Promise<string | null>;
+export declare function track(eventName: string, properties?: JsonObject, context?: Partial<ErrorEvent>): Promise<string | null>;
+export declare function identify(distinctId: string, traits?: JsonObject, context?: Partial<ErrorEvent>): Promise<string | null>;
+export declare function page(name: string, properties?: JsonObject, context?: Partial<ErrorEvent>): Promise<string | null>;
+export declare function screen(name: string, properties?: JsonObject, context?: Partial<ErrorEvent>): Promise<string | null>;
+export declare function captureSpan(name: string, context?: Partial<ErrorEvent>): Promise<string | null>;
+export declare function captureToolCall(name: string, context?: Partial<ErrorEvent>): Promise<string | null>;
+export declare function captureGeneration(message: string, context?: Partial<ErrorEvent>): Promise<string | null>;
+export declare function setUser(user: UserContext | undefined): void;
+export declare function setTag(key: string, value: string): void;
+export declare function setTags(tags: Record<string, string>): void;
+export declare function addBreadcrumb(crumb: Omit<Breadcrumb, "timestamp">): void;
+/** Read local delivery health without sending a telemetry event. */
+export declare function getDeliveryStats(): import("./delivery-stats.js").DeliveryStats;
+export declare function flush(timeoutMs?: number): Promise<void>;
+/** Handles `uncaughtException` and `unhandledRejection` at the process level. */
+export declare function installGlobalHandlers(): void;
+export declare function close(): Promise<void>;

package/dist/_vendor/node-sdk/index.js

@@ -0,0 +1,84 @@
+export { SquasherClient } from "./client.js";
+export { withHttpRequest } from "./http.js";
+export { withAwsLambda } from "./aws-lambda.js";
+export { createSpanId, createTraceContext, createTraceId } from "./trace-context.js";
+export { ActionableError, createActionableError, createRedactor, detectRelease, isValidRelease, parseRelease, } from "../sdk-runtime/runtime/public-sdk-runtime.js";
+import { SquasherClient } from "./client.js";
+const NODE_RUNTIME_SYMBOL = Symbol.for("@squasher-ai/node/runtime");
+// SAFETY: this process-wide symbol is owned by this SDK and always receives NodeRuntimeRegistry.
+const nodeRuntimeGlobal = globalThis;
+const nodeRuntime = (nodeRuntimeGlobal[NODE_RUNTIME_SYMBOL] ??= { client: null });
+/** Initialize the global Squasher client. Throws if called twice. */
+export function init(config) {
+    if (nodeRuntime.client) {
+        throw new Error("squasher.init() called more than once. The SDK can only be initialized once.");
+    }
+    nodeRuntime.client = new SquasherClient(config);
+    return nodeRuntime.client;
+}
+/** Get the global client (throws if not initialized). */
+export function getClient() {
+    if (!nodeRuntime.client) {
+        throw new Error("Squasher not initialized. Call init() first.");
+    }
+    return nodeRuntime.client;
+}
+export async function captureError(error, extra, options) {
+    return getClient().captureError(error, extra, options);
+}
+export async function captureMessage(message, level) {
+    return getClient().captureMessage(message, level);
+}
+export async function captureTelemetry(event) {
+    return getClient().captureTelemetry(event);
+}
+export async function track(eventName, properties, context) {
+    return getClient().track(eventName, properties, context);
+}
+export async function identify(distinctId, traits, context) {
+    return getClient().identify(distinctId, traits, context);
+}
+export async function page(name, properties, context) {
+    return getClient().page(name, properties, context);
+}
+export async function screen(name, properties, context) {
+    return getClient().screen(name, properties, context);
+}
+export async function captureSpan(name, context) {
+    return getClient().captureSpan(name, context);
+}
+export async function captureToolCall(name, context) {
+    return getClient().captureToolCall(name, context);
+}
+export async function captureGeneration(message, context) {
+    return getClient().captureGeneration(message, context);
+}
+export function setUser(user) {
+    getClient().setUser(user);
+}
+export function setTag(key, value) {
+    getClient().setTag(key, value);
+}
+export function setTags(tags) {
+    getClient().setTags(tags);
+}
+export function addBreadcrumb(crumb) {
+    getClient().addBreadcrumb(crumb);
+}
+/** Read local delivery health without sending a telemetry event. */
+export function getDeliveryStats() {
+    return getClient().getDeliveryStats();
+}
+export async function flush(timeoutMs) {
+    return getClient().flush(timeoutMs);
+}
+/** Handles `uncaughtException` and `unhandledRejection` at the process level. */
+export function installGlobalHandlers() {
+    getClient().installGlobalHandlers();
+}
+export async function close() {
+    if (nodeRuntime.client) {
+        await nodeRuntime.client.close();
+        nodeRuntime.client = null;
+    }
+}

package/dist/_vendor/node-sdk/local-events/sink.d.ts

@@ -0,0 +1,6 @@
+import type { ErrorEvent, LocalEventSinkConfig } from "../types.js";
+export interface LocalEventSink {
+    write(event: ErrorEvent): void;
+}
+export declare function createLocalEventSink(config: LocalEventSinkConfig | undefined): LocalEventSink | undefined;
+export declare function normalizeLocalEventSinkConfig(config: boolean | LocalEventSinkConfig | undefined): LocalEventSinkConfig | undefined;

package/dist/_vendor/node-sdk/local-events/sink.js

@@ -0,0 +1,43 @@
+import { mkdir, appendFile } from "node:fs/promises";
+import { join } from "node:path";
+import { createRedactor } from "../../sdk-runtime/runtime/public-sdk-runtime.js";
+export function createLocalEventSink(config) {
+    if (!config?.enabled)
+        return undefined;
+    const directory = config.directory ?? join(process.cwd(), ".squasher", "events");
+    const redact = createRedactor({
+        keyMasks: ["x-squasher-key", ...(config.redactKeys ?? [])],
+        mask: config.redactionText,
+    });
+    return {
+        write(event) {
+            const line = safeSerializeRedacted(event, redact);
+            if (!line)
+                return;
+            const path = join(directory, `${new Date().toISOString().slice(0, 10)}.jsonl`);
+            void mkdir(directory, { recursive: true })
+                .then(() => appendFile(path, `${line}\n`, "utf8"))
+                .catch(() => { });
+        },
+    };
+}
+export function normalizeLocalEventSinkConfig(config) {
+    if (config === undefined || config === false)
+        return undefined;
+    if (config === true)
+        return { enabled: true };
+    return config;
+}
+function safeSerializeRedacted(event, redact) {
+    try {
+        return serializeRedacted(event, redact);
+    }
+    catch {
+        return undefined;
+    }
+}
+function serializeRedacted(event, redact) {
+    const plain = JSON.parse(JSON.stringify(event));
+    const redacted = redact(plain);
+    return JSON.stringify(redacted);
+}

package/dist/_vendor/node-sdk/trace-context.d.ts

@@ -0,0 +1,8 @@
+import type { TraceContext } from "./types.js";
+export declare function createTraceId(): string;
+export declare function createSpanId(): string;
+export declare function createTraceContext(parent?: Pick<TraceContext, "span_id" | "trace_id">): {
+    parent_span_id: string | undefined;
+    span_id: string;
+    trace_id: string;
+};

package/dist/_vendor/node-sdk/trace-context.js

@@ -0,0 +1,13 @@
+export function createTraceId() {
+    return crypto.randomUUID().replaceAll("-", "");
+}
+export function createSpanId() {
+    return crypto.randomUUID().replaceAll("-", "").slice(0, 16);
+}
+export function createTraceContext(parent) {
+    return {
+        parent_span_id: parent?.span_id,
+        span_id: createSpanId(),
+        trace_id: parent?.trace_id ?? createTraceId(),
+    };
+}

package/dist/_vendor/node-sdk/types.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Wire protocol types matching sdk-spec/protocol.schema.json.
+ * Config types matching sdk-spec/config.schema.json.
+ */
+import type { AnalyticsContext, Breadcrumb as ApiBreadcrumb, IngestEvent, IngestResponse, JsonObject, JsonValue, Level, LlmContext, PageContext, RequestContext, SessionContext, StackFrame, TelemetryKind, TelemetryMeasurement, TelemetrySamplingConfig, ToolCallContext, TraceContext, UserContext, VisitorContext } from "../telemetry-contract/sdk/public-contract.js";
+export interface SquasherConfig {
+    /** API key (sq_pk_...). Required. */
+    apiKey: string;
+    /** Project ID. Required. */
+    projectId: string;
+    /** Public edge ingestion endpoint. Default: "https://ingest.squasher.ai" */
+    endpoint?: string;
+    /** Environment tag (production, staging, development). */
+    environment?: string;
+    /** Release/version tag. */
+    release?: string;
+    /** Enable debug logging. Default: false. */
+    debug?: boolean;
+    /** Outcome-aware, deterministic sampling policy. */
+    sampling?: TelemetrySamplingConfig;
+    /**
+     * Hook invoked before every event is sent.
+     * Return the event (possibly modified) to send, or null to drop.
+     * Applied to ALL captures (errors AND messages) per spec.
+     * The RETURN VALUE is used (not the original).
+     */
+    beforeSend?: (event: ErrorEvent) => ErrorEvent | null;
+    /** Max breadcrumbs to retain. Default: 50. */
+    maxBreadcrumbs?: number;
+    /** Flush when this many events are buffered. Default: 25. */
+    batchSize?: number;
+    /** Max ms between automatic flushes. Default: 5000. */
+    flushIntervalMs?: number;
+    /** Max retry attempts on transient failures. Default: 3. */
+    maxRetries?: number;
+    /** OTel resource attributes merged into every outbound event. */
+    resourceAttributes?: Record<string, string>;
+    /**
+     * Opt-in local event artifact for agent debugging. Writes redacted NDJSON to
+     * `.squasher/events/YYYY-MM-DD.jsonl` by default.
+     */
+    localEventSink?: boolean | LocalEventSinkConfig;
+}
+export interface LocalEventSinkConfig {
+    enabled: boolean;
+    directory?: string;
+    redactKeys?: string[];
+    redactionText?: string;
+}
+export interface CaptureErrorOptions {
+    attributes?: ErrorEvent["attributes"];
+    level?: Level;
+    request?: RequestContext;
+}
+export type { AnalyticsContext, IngestResponse, JsonObject, JsonValue, Level, LlmContext, PageContext, RequestContext, SessionContext, StackFrame, TelemetryKind, TelemetryMeasurement, TelemetrySamplingConfig, ToolCallContext, TraceContext, UserContext, VisitorContext, };
+export type Breadcrumb = Omit<ApiBreadcrumb, "data"> & {
+    data?: JsonObject;
+};
+export type ErrorEvent = Omit<IngestEvent, "breadcrumbs" | "extra"> & {
+    breadcrumbs?: Breadcrumb[];
+    extra?: JsonObject;
+};
+export interface IngestBatchPayload {
+    events: ErrorEvent[];
+}

package/dist/_vendor/node-sdk/types.js

@@ -0,0 +1 @@
+export {};

package/dist/_vendor/sdk-runtime/batching/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Batching primitives used by Squasher SDKs.
+ *
+ * The 1 MB default keeps request bodies bounded while amortizing per-request
+ * overhead. Callers may choose a lower limit when their runtime requires one.
+ */
+/** Maximum serialized SDK batch body, in bytes. */
+export declare const MAX_BATCH_BODY_BYTES = 1000000;
+export interface BuildBatchesOptions<TItem> {
+    /**
+     * Static JSON immediately before the comma-separated serialized items.
+     * Keeping the envelope split lets the builder serialize each item once
+     * instead of repeatedly serializing a growing candidate array.
+     */
+    batchPrefix: string;
+    /** Static JSON immediately after the serialized items. */
+    batchSuffix: string;
+    /**
+     * Serialize a single item (no wrapper). Called when a batch of size 1 is
+     * flushed. Lets SDKs send `{...event}` instead of `{events: [{...}]}` for
+     * single-event flushes — half the bytes for the common case.
+     */
+    serializeSingle: (item: TItem) => string;
+    /** Override the default 1_000_000-byte ceiling (for tests). */
+    maxBatchBodyBytes?: number;
+}
+export interface BuiltBatch {
+    /** The exact request body (already serialized). */
+    body: string;
+    /** Number of items in this batch. */
+    itemCount: number;
+}
+/**
+ * Greedy batching: walk the items in order, adding each to the current batch
+ * unless doing so would exceed `MAX_BATCH_BODY_BYTES`. When it would, flush
+ * the current batch and start a new one with the offending item.
+ *
+ * An item that is itself larger than the limit becomes a single-item batch
+ * regardless — callers are expected to drop or split oversized items at a
+ * higher layer; this function does not silently drop data.
+ */
+export declare function buildBatches<TItem>(items: TItem[], options: BuildBatchesOptions<TItem>): BuiltBatch[];

package/dist/_vendor/sdk-runtime/batching/index.js

@@ -0,0 +1,48 @@
+/**
+ * Batching primitives used by Squasher SDKs.
+ *
+ * The 1 MB default keeps request bodies bounded while amortizing per-request
+ * overhead. Callers may choose a lower limit when their runtime requires one.
+ */
+/** Maximum serialized SDK batch body, in bytes. */
+export const MAX_BATCH_BODY_BYTES = 1_000_000;
+const BODY_ENCODER = new TextEncoder();
+/**
+ * Greedy batching: walk the items in order, adding each to the current batch
+ * unless doing so would exceed `MAX_BATCH_BODY_BYTES`. When it would, flush
+ * the current batch and start a new one with the offending item.
+ *
+ * An item that is itself larger than the limit becomes a single-item batch
+ * regardless — callers are expected to drop or split oversized items at a
+ * higher layer; this function does not silently drop data.
+ */
+export function buildBatches(items, options) {
+    const max = options.maxBatchBodyBytes ?? MAX_BATCH_BODY_BYTES;
+    const batches = [];
+    let current = [];
+    const envelopeBytes = BODY_ENCODER.encode(options.batchPrefix).length +
+        BODY_ENCODER.encode(options.batchSuffix).length;
+    let currentBodyBytes = envelopeBytes;
+    const flush = () => {
+        if (current.length === 0)
+            return;
+        const body = current.length === 1
+            ? current[0]
+            : `${options.batchPrefix}${current.join(",")}${options.batchSuffix}`;
+        batches.push({ body, itemCount: current.length });
+        current = [];
+        currentBodyBytes = envelopeBytes;
+    };
+    for (const item of items) {
+        const serialized = options.serializeSingle(item);
+        const serializedBytes = BODY_ENCODER.encode(serialized).length;
+        const separatorBytes = current.length === 0 ? 0 : 1;
+        if (current.length > 0 && currentBodyBytes + separatorBytes + serializedBytes > max) {
+            flush();
+        }
+        currentBodyBytes += (current.length === 0 ? 0 : 1) + serializedBytes;
+        current.push(serialized);
+    }
+    flush();
+    return batches;
+}

package/dist/_vendor/sdk-runtime/errors/headers.d.ts

@@ -0,0 +1,6 @@
+export type HeaderMap = Record<string, string>;
+export interface HeaderLike {
+    get(name: string): string | null;
+}
+export type HeaderSource = HeaderLike | HeaderMap;
+export declare function readHeader(headers: HeaderSource | undefined, name: string): string | undefined;

package/dist/_vendor/sdk-runtime/errors/headers.js

@@ -0,0 +1,44 @@
+export function readHeader(headers, name) {
+    if (!headers)
+        return undefined;
+    const get = readProperty(headers, "get");
+    if (isHeaderGetter(get)) {
+        try {
+            const value = get.call(headers, name);
+            return Object.prototype.toString.call(value) === "[object String]"
+                ? String(value)
+                : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const normalizedName = name.toLowerCase();
+    for (const [key, value] of Object.entries(Object(headers))) {
+        if (key.toLowerCase() === normalizedName &&
+            Object.prototype.toString.call(value) === "[object String]") {
+            return String(value);
+        }
+    }
+    return undefined;
+}
+function isHeaderGetter(value) {
+    return Object.prototype.toString.call(value) === "[object Function]";
+}
+function readProperty(owner, key) {
+    try {
+        const target = Object(owner);
+        let cursor = target;
+        while (cursor) {
+            const descriptor = Object.getOwnPropertyDescriptor(cursor, key);
+            if (descriptor) {
+                return "value" in descriptor ? descriptor.value : descriptor.get?.call(target);
+            }
+            cursor = Object.getPrototypeOf(cursor);
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}