@squasher-ai/nextjs 0.3.0 → 0.4.0

package/dist/_vendor/sdk-runtime/retry.js

@@ -0,0 +1,104 @@
+/**
+ * Retry primitives shared across Squasher SDKs.
+ *
+ * Server retry hints take precedence over exponential backoff with downward
+ * jitter. Aborts are never retried; network failures, timeouts, 408, 429, and
+ * 5xx responses are retryable by default.
+ */
+import { readHeader } from "./errors/headers.js";
+import { SquasherConnectionError, SquasherUserAbortError } from "./errors/index.js";
+// 408 = Request Timeout, 429 = Too Many Requests. 409 (Conflict) is
+// intentionally NOT included — for Squasher's ingest path, 409 means
+// "duplicate event detected by server dedup", and retrying creates extra
+// writes that re-trip the dedup. Servers that genuinely want a transient
+// 409 retried (e.g. optimistic-locking conflicts) can opt back in via
+// the `X-Should-Retry: true` response header.
+const RETRYABLE_STATUSES = new Set([408, 429]);
+/**
+ * Decide whether a response (or thrown error) should trigger a retry.
+ *
+ * Aborts always opt out — `AbortController.abort()` is user intent, not a
+ * transient failure. Connection errors always opt in. Status-code logic
+ * mirrors Stainless: 408/409/429 plus any 5xx, with `X-Should-Retry`
+ * override.
+ */
+export function shouldRetry(input) {
+    if (input.thrown instanceof SquasherUserAbortError)
+        return false;
+    if (input.thrown instanceof SquasherConnectionError)
+        return true;
+    if (input.thrown && input.status === undefined) {
+        // Unknown thrown value with no response — treat as transport failure.
+        return true;
+    }
+    const override = readHeader(input.headers, "x-should-retry");
+    if (override === "true")
+        return true;
+    if (override === "false")
+        return false;
+    if (input.status === undefined)
+        return false;
+    if (RETRYABLE_STATUSES.has(input.status))
+        return true;
+    if (input.status >= 500)
+        return true;
+    return false;
+}
+const DEFAULT_MAX_SLEEP_MS = 8_000;
+/**
+ * Compute the delay in milliseconds before the next attempt. Server-supplied
+ * hints win when present, otherwise falls back to exponential backoff with
+ * downward jitter.
+ *
+ * Returned value is always non-negative. Capped at `maxSleepMs` (default 8s)
+ * even when the server requests a longer retry — long sleeps almost always
+ * indicate the caller should reach for queueing instead of in-process retries.
+ */
+export function nextBackoffMs(opts) {
+    const max = opts.maxSleepMs ?? DEFAULT_MAX_SLEEP_MS;
+    const random = opts.random ?? Math.random;
+    const retryAfterMsHeader = readHeader(opts.headers, "retry-after-ms");
+    if (retryAfterMsHeader !== undefined) {
+        const ms = Number.parseFloat(retryAfterMsHeader);
+        if (Number.isFinite(ms) && ms >= 0)
+            return Math.min(ms, max);
+    }
+    const retryAfterHeader = readHeader(opts.headers, "retry-after");
+    if (retryAfterHeader !== undefined) {
+        const seconds = Number.parseFloat(retryAfterHeader);
+        if (Number.isFinite(seconds) && seconds >= 0) {
+            return Math.min(seconds * 1000, max);
+        }
+        // HTTP-date form (RFC 7231)
+        const dateMs = Date.parse(retryAfterHeader);
+        if (!Number.isNaN(dateMs)) {
+            const now = opts.now ? opts.now() : Date.now();
+            const delta = dateMs - now;
+            if (delta > 0)
+                return Math.min(delta, max);
+            return 0;
+        }
+    }
+    // Exponential backoff with downward jitter.
+    const baseSeconds = Math.min(0.5 * Math.pow(2, opts.attempt), max / 1000);
+    const jitter = 1 - random() * 0.25;
+    return Math.min(baseSeconds * 1000 * jitter, max);
+}
+/** Promise-friendly setTimeout. Resolves after `ms` milliseconds. */
+export function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new SquasherUserAbortError());
+            return;
+        }
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(new SquasherUserAbortError());
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}

package/dist/_vendor/sdk-runtime/runtime/actionable-error.d.ts

@@ -0,0 +1,37 @@
+import { SquasherError } from "../errors/index.js";
+export type ActionableErrorValue = boolean | null | number | string;
+export type ActionableErrorInternal = Record<string, ActionableErrorValue | ActionableErrorValue[]>;
+interface ActionableErrorJson extends ActionableErrorContext {
+    message: string;
+    name: string;
+}
+export interface ActionableErrorContext {
+    status?: number | string;
+    why?: string;
+    fix?: string;
+    link?: string;
+    internal?: ActionableErrorInternal;
+}
+export interface ActionableErrorOptions extends ActionableErrorContext {
+    cause?: Error;
+    name?: string;
+}
+export interface ActionableErrorTelemetry {
+    attributes: Record<string, number | string>;
+    extra: {
+        squasher_error: ActionableErrorContext;
+    };
+}
+export declare class ActionableError extends SquasherError {
+    readonly status: number | string | undefined;
+    readonly why: string | undefined;
+    readonly fix: string | undefined;
+    readonly link: string | undefined;
+    readonly internal: ActionableErrorInternal | undefined;
+    constructor(message: string, options?: ActionableErrorOptions);
+    toJSON(): ActionableErrorJson;
+}
+export declare function createActionableError(message: string, options?: ActionableErrorOptions): ActionableError;
+export declare function getActionableErrorContext(error: Error): ActionableErrorContext | undefined;
+export declare function getActionableErrorTelemetry(error: Error): ActionableErrorTelemetry | undefined;
+export {};

package/dist/_vendor/sdk-runtime/runtime/actionable-error.js

@@ -0,0 +1,123 @@
+import { SquasherError } from "../errors/index.js";
+export class ActionableError extends SquasherError {
+    status;
+    why;
+    fix;
+    link;
+    constructor(message, options = {}) {
+        super(message);
+        this.name = options.name ?? "ActionableError";
+        this.status = options.status;
+        this.why = options.why;
+        this.fix = options.fix;
+        this.link = options.link;
+        if (options.cause) {
+            Object.defineProperty(this, "cause", { value: options.cause });
+        }
+        Object.defineProperty(this, "internal", {
+            enumerable: false,
+            value: readInternal(options.internal),
+        });
+    }
+    toJSON() {
+        const result = { message: this.message, name: this.name };
+        if (this.status !== undefined)
+            result.status = this.status;
+        if (this.why)
+            result.why = this.why;
+        if (this.fix)
+            result.fix = this.fix;
+        if (this.link)
+            result.link = this.link;
+        return result;
+    }
+}
+export function createActionableError(message, options = {}) {
+    return new ActionableError(message, options);
+}
+export function getActionableErrorContext(error) {
+    const internal = readInternal(readProperty(error, "internal"));
+    const context = {
+        status: readStatus(readProperty(error, "status")),
+        why: readText(readProperty(error, "why")),
+        fix: readText(readProperty(error, "fix")),
+        link: readText(readProperty(error, "link")),
+        internal,
+    };
+    return context.status !== undefined || context.why || context.fix || context.link || internal
+        ? context
+        : undefined;
+}
+export function getActionableErrorTelemetry(error) {
+    const context = getActionableErrorContext(error);
+    if (!context)
+        return undefined;
+    const attributes = {};
+    if (context.status !== undefined)
+        attributes["error.status"] = context.status;
+    if (context.why)
+        attributes["error.why"] = context.why;
+    if (context.fix)
+        attributes["error.fix"] = context.fix;
+    if (context.link)
+        attributes["error.link"] = context.link;
+    return { attributes, extra: { squasher_error: context } };
+}
+function readProperty(error, name) {
+    try {
+        const owner = Object(error);
+        let cursor = owner;
+        while (cursor) {
+            const descriptor = Object.getOwnPropertyDescriptor(cursor, name);
+            if (descriptor) {
+                return "value" in descriptor ? descriptor.value : descriptor.get?.call(owner);
+            }
+            cursor = Object.getPrototypeOf(cursor);
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readText(value) {
+    if (Object.prototype.toString.call(value) !== "[object String]")
+        return undefined;
+    const text = String(value).trim();
+    return text.length > 0 ? text : undefined;
+}
+function readStatus(value) {
+    const tag = Object.prototype.toString.call(value);
+    if (tag === "[object Number]") {
+        const number = Number(value);
+        return Number.isFinite(number) ? number : undefined;
+    }
+    if (tag === "[object String]")
+        return readText(value);
+    return undefined;
+}
+function readInternal(value) {
+    if (Object.prototype.toString.call(value) !== "[object Object]")
+        return undefined;
+    const internal = {};
+    for (const [key, entry] of Object.entries(Object(value))) {
+        const parsed = readInternalValue(entry);
+        if (parsed !== undefined)
+            internal[key] = parsed;
+    }
+    return Object.keys(internal).length > 0 ? internal : undefined;
+}
+function readInternalValue(value) {
+    if (Array.isArray(value)) {
+        const values = value.filter(isActionableValue);
+        return values.length > 0 ? values : undefined;
+    }
+    return isActionableValue(value) ? value : undefined;
+}
+function isActionableValue(value) {
+    const tag = Object.prototype.toString.call(value);
+    return (value === null ||
+        tag === "[object Boolean]" ||
+        tag === "[object Number]" ||
+        tag === "[object String]");
+}

package/dist/_vendor/sdk-runtime/runtime/environment.d.ts

@@ -0,0 +1,18 @@
+export type RuntimePrimitive = boolean | null | number | string;
+export type RuntimeValue = RuntimePrimitive | RuntimeValue[] | RuntimeRecord | undefined;
+export interface RuntimeRecord {
+    [key: string]: RuntimeValue;
+}
+export interface RuntimeMethod<TResult> {
+    (): TResult;
+}
+export interface RuntimeEnvironment {
+    [name: string]: string | undefined;
+}
+export declare function readGlobalProperty(name: string): RuntimeValue;
+export declare function readRuntimeProperty<T>(value: T, name: string): RuntimeValue;
+export declare function readRuntimeString<T>(value: T): string | undefined;
+export declare function readRuntimeNumber<T>(value: T): number | undefined;
+export declare function readRuntimeMethod<TResult, T = RuntimeValue>(value: T, name: PropertyKey): RuntimeMethod<TResult> | undefined;
+export declare function readProcessEnvironment(): RuntimeEnvironment;
+export declare function readGlobalEnvironmentValue(name: string): string | undefined;

package/dist/_vendor/sdk-runtime/runtime/environment.js

@@ -0,0 +1,81 @@
+export function readGlobalProperty(name) {
+    try {
+        return readRuntimeProperty(globalThis, name);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readRuntimeProperty(value, name) {
+    try {
+        if (value === null || value === undefined)
+            return undefined;
+        const owner = Object(value);
+        let cursor = owner;
+        while (cursor) {
+            const descriptor = Object.getOwnPropertyDescriptor(cursor, name);
+            if (descriptor) {
+                if ("value" in descriptor)
+                    return descriptor.value;
+                return descriptor.get?.call(owner);
+            }
+            cursor = Object.getPrototypeOf(cursor);
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readRuntimeString(value) {
+    return Object.prototype.toString.call(value) === "[object String]" ? String(value) : undefined;
+}
+export function readRuntimeNumber(value) {
+    if (Object.prototype.toString.call(value) !== "[object Number]")
+        return undefined;
+    const number = Number(value);
+    return Number.isFinite(number) ? number : undefined;
+}
+export function readRuntimeMethod(value, name) {
+    try {
+        if (value === null || value === undefined)
+            return undefined;
+        const owner = Object(value);
+        let cursor = owner;
+        while (cursor) {
+            const descriptor = Object.getOwnPropertyDescriptor(cursor, name);
+            if (descriptor) {
+                const candidate = "value" in descriptor ? descriptor.value : descriptor.get?.call(owner);
+                return Object.prototype.toString.call(candidate) === "[object Function]"
+                    ? candidate
+                    : undefined;
+            }
+            cursor = Object.getPrototypeOf(cursor);
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readProcessEnvironment() {
+    const value = readRuntimeProperty(readGlobalProperty("process"), "env");
+    if (Object.prototype.toString.call(value) !== "[object Object]")
+        return {};
+    const environment = {};
+    for (const [name, entry] of Object.entries(Object(value))) {
+        environment[name] = readRuntimeString(entry);
+    }
+    return environment;
+}
+export function readGlobalEnvironmentValue(name) {
+    const value = readGlobalProperty(name);
+    const tag = Object.prototype.toString.call(value);
+    if (tag === "[object String]")
+        return String(value);
+    if (tag === "[object Boolean]")
+        return value ? "1" : "0";
+    if (tag === "[object Number]")
+        return String(value);
+    return undefined;
+}

package/dist/_vendor/sdk-runtime/runtime/public-sdk-runtime.d.ts

@@ -0,0 +1,12 @@
+export declare const DEFAULT_INGEST_ENDPOINT = "https://ingest.squasher.ai";
+export { buildBatches, type BuildBatchesOptions, type BuiltBatch, MAX_BATCH_BODY_BYTES, } from "../batching/index.js";
+export { ActionableError, type ActionableErrorContext, type ActionableErrorOptions, type ActionableErrorTelemetry, type ActionableErrorValue, createActionableError, getActionableErrorContext, getActionableErrorTelemetry, } from "./actionable-error.js";
+export { readGlobalEnvironmentValue, readGlobalProperty, readProcessEnvironment, readRuntimeMethod, readRuntimeNumber, readRuntimeProperty, readRuntimeString, type RuntimeEnvironment, type RuntimeMethod, type RuntimePrimitive, type RuntimeRecord, type RuntimeValue, } from "./environment.js";
+export { type DefaultHeadersOptions, getDefaultHeaders, getRequestHeaders, getUserAgent, type RequestHeaderOptions, } from "../headers.js";
+export { type BackoffOptions, type HeadersLike, nextBackoffMs, type RetryDecisionInput, shouldRetry, sleep, } from "../retry.js";
+export { createRedactor, type RedactableValue, type Redactor, type RedactorKeyMask, type RedactorOptions, type RedactorPathMask, type RedactorPathSegment, } from "./redaction.js";
+export { detectRelease, isValidRelease, parseRelease, type ParsedRelease } from "./release.js";
+export { type ResolvedTelemetrySampling, resolveTelemetrySampling, shouldSampleTelemetry, } from "../sampling/index.js";
+export declare function resolveEnvFlag(name: string): boolean;
+export declare function resolveDebugFlag(configDebug: boolean | undefined): boolean;
+export declare function readEnvValue(name: string): string | undefined;

package/dist/_vendor/sdk-runtime/runtime/public-sdk-runtime.js

@@ -0,0 +1,38 @@
+export const DEFAULT_INGEST_ENDPOINT = "https://ingest.squasher.ai";
+export { buildBatches, MAX_BATCH_BODY_BYTES, } from "../batching/index.js";
+export { ActionableError, createActionableError, getActionableErrorContext, getActionableErrorTelemetry, } from "./actionable-error.js";
+export { readGlobalEnvironmentValue, readGlobalProperty, readProcessEnvironment, readRuntimeMethod, readRuntimeNumber, readRuntimeProperty, readRuntimeString, } from "./environment.js";
+export { getDefaultHeaders, getRequestHeaders, getUserAgent, } from "../headers.js";
+export { nextBackoffMs, shouldRetry, sleep, } from "../retry.js";
+export { createRedactor, } from "./redaction.js";
+export { detectRelease, isValidRelease, parseRelease } from "./release.js";
+export { resolveTelemetrySampling, shouldSampleTelemetry, } from "../sampling/index.js";
+import { readGlobalEnvironmentValue, readProcessEnvironment } from "./environment.js";
+export function resolveEnvFlag(name) {
+    const envName = `SQUASHER_${name}`;
+    const raw = readEnvValue(envName);
+    if (raw === undefined || raw === null)
+        return false;
+    const normalized = String(raw).trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+export function resolveDebugFlag(configDebug) {
+    if (configDebug !== undefined)
+        return configDebug;
+    return resolveEnvFlag("DEBUG");
+}
+export function readEnvValue(name) {
+    try {
+        const value = readProcessEnvironment()[name];
+        if (value !== undefined && value !== null && value !== "")
+            return value;
+    }
+    catch { }
+    try {
+        const value = readGlobalEnvironmentValue(name);
+        if (value !== undefined && value !== "")
+            return value;
+    }
+    catch { }
+    return undefined;
+}

package/dist/_vendor/sdk-runtime/runtime/redaction.d.ts

@@ -0,0 +1,14 @@
+export type RedactableValue = boolean | null | number | string | RedactableValue[] | {
+    [key: string]: RedactableValue;
+};
+export type RedactorKeyMask = RegExp | string;
+export type RedactorPathSegment = number | string;
+export type RedactorPathMask = readonly RedactorPathSegment[] | string;
+export interface RedactorOptions {
+    mask?: string;
+    keyMasks?: readonly RedactorKeyMask[];
+    pathMasks?: readonly RedactorPathMask[];
+    patternMasks?: readonly RegExp[];
+}
+export type Redactor = (value: RedactableValue) => RedactableValue;
+export declare function createRedactor(options?: RedactorOptions): Redactor;

package/dist/_vendor/sdk-runtime/runtime/redaction.js

@@ -0,0 +1,120 @@
+const DEFAULT_MASK = "[REDACTED]";
+const EMAIL_PATTERN = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi;
+const BEARER_PATTERN = /\bBearer\s+[A-Za-z0-9._~+/=-]+\b/gi;
+const JWT_PATTERN = /\beyJ[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}\b/g;
+const API_KEY_PATTERN = /\b(?:sk|pk|sq|squasher)_(?:pk|sk|live|test|dev|prod)?_?[A-Za-z0-9_-]{16,}\b/g;
+const SENSITIVE_KEY_PARTS = [
+    "apikey",
+    "authorization",
+    "authtoken",
+    "bearertoken",
+    "clientsecret",
+    "cookie",
+    "idtoken",
+    "password",
+    "passwd",
+    "privatekey",
+    "refreshtoken",
+    "secret",
+    "sessiontoken",
+    "squasherkey",
+    "token",
+];
+export function createRedactor(options = {}) {
+    const config = {
+        mask: options.mask ?? DEFAULT_MASK,
+        keyMasks: options.keyMasks ?? [],
+        pathMasks: options.pathMasks ?? [],
+        patternMasks: options.patternMasks ?? [],
+    };
+    return (value) => redactValue(value, [], config);
+}
+function redactValue(value, path, config) {
+    if (Object.prototype.toString.call(value) === "[object String]") {
+        return redactString(String(value), config);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item, index) => redactValue(item, [...path, index], config));
+    }
+    if (!isRedactableRecord(value))
+        return value;
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+        const itemPath = [...path, key];
+        result[key] = shouldMaskField(key, itemPath, config)
+            ? config.mask
+            : redactValue(item, itemPath, config);
+    }
+    return result;
+}
+function isRedactableRecord(value) {
+    if (value === null)
+        return false;
+    try {
+        const prototype = Object.getPrototypeOf(Object(value));
+        return prototype === null || Object.getPrototypeOf(prototype) === null;
+    }
+    catch {
+        return false;
+    }
+}
+function redactString(value, config) {
+    let redacted = value
+        .replace(EMAIL_PATTERN, config.mask)
+        .replace(BEARER_PATTERN, `Bearer ${config.mask}`)
+        .replace(JWT_PATTERN, config.mask)
+        .replace(API_KEY_PATTERN, config.mask);
+    for (const pattern of config.patternMasks) {
+        redacted = redacted.replace(globalPattern(pattern), config.mask);
+    }
+    return redacted;
+}
+function shouldMaskField(key, path, config) {
+    if (isSensitiveKey(key))
+        return true;
+    if (config.keyMasks.some((mask) => matchesKeyMask(mask, key)))
+        return true;
+    return config.pathMasks.some((mask) => matchesPathMask(mask, path));
+}
+function isSensitiveKey(key) {
+    const normalized = normalizeSegment(key);
+    return SENSITIVE_KEY_PARTS.some((part) => normalized.includes(part));
+}
+function matchesKeyMask(mask, key) {
+    if (isRegularExpression(mask)) {
+        mask.lastIndex = 0;
+        return RegExp.prototype.test.call(mask, key);
+    }
+    return normalizeSegment(String(mask)) === normalizeSegment(key);
+}
+function matchesPathMask(mask, path) {
+    const maskPath = Array.isArray(mask) ? mask : splitPath(String(mask));
+    if (maskPath.length !== path.length)
+        return false;
+    for (let index = 0; index < maskPath.length; index += 1) {
+        const segment = maskPath[index];
+        if (segment === "*")
+            continue;
+        if (normalizePathSegment(segment) !== normalizePathSegment(path[index]))
+            return false;
+    }
+    return true;
+}
+function isRegularExpression(mask) {
+    return Object.prototype.toString.call(mask) === "[object RegExp]";
+}
+function splitPath(path) {
+    return path.split(".").filter((segment) => segment.length > 0);
+}
+function normalizePathSegment(segment) {
+    return Object.prototype.toString.call(segment) === "[object Number]"
+        ? String(segment)
+        : normalizeSegment(String(segment ?? ""));
+}
+function normalizeSegment(segment) {
+    return segment.replace(/[^A-Za-z0-9]/g, "").toLowerCase();
+}
+function globalPattern(pattern) {
+    const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
+    return new RegExp(pattern.source, flags);
+}

package/dist/_vendor/sdk-runtime/runtime/release.d.ts

@@ -0,0 +1,35 @@
+import { type RuntimeEnvironment } from "./environment.js";
+/**
+ * `canonical` is what every consumer should display / store: v-prefix
+ * stripped, `service@version+build` form rebuilt from the parsed components,
+ * so `v1.2.3` and `1.2.3` (or two inputs with different whitespace) compare
+ * equal by `canonical`.
+ */
+export interface ParsedRelease {
+    canonical: string;
+    service: string | null;
+    version: string;
+    build: string | null;
+    isSemver: boolean;
+}
+export type ReleaseInput = string | null | undefined;
+/**
+ * Parse + validate a release string. Returns `null` for empty input, junk
+ * sentinels, values over 200 chars, or strings with whitespace / control chars.
+ * Accepts: `1.2.3`, `v1.2.3`, `svc@1.2.3`, `svc@1.2.3+sha`, `1.2.3+sha`, and
+ * bare git shas (non-semver but valid).
+ */
+export declare function parseRelease(input: ReleaseInput): ParsedRelease | null;
+/**
+ * True when `parseRelease(input)` would accept the value. Pure boolean — use
+ * this at validation boundaries that don't need the parsed pieces (e.g. zod
+ * `.refine()`, ingest pre-filters).
+ */
+export declare function isValidRelease(input: ReleaseInput): input is string;
+/**
+ * Auto-detect a release from common CI/host env vars so customers on
+ * Vercel / Railway / Render / Fly / GitHub Actions get a useful release tag
+ * without configuring anything. Explicit `SQUASHER_RELEASE` always wins;
+ * values that fail `parseRelease` are skipped and detection continues.
+ */
+export declare function detectRelease(env?: Readonly<RuntimeEnvironment>): string | null;