@debugbundle/sdk-react-native 3.0.1 → 3.1.0

package/dist/client.js

@@ -1,9 +1,16 @@
+import { utf8Bytes as utf8ByteLength } from "./owned-json.js";
+import { normalizeNativeState, stringValue, asRecord, objectWrap, parseRequestUrl, sanitizeScreenName, generateId, canonicalDevice, toLegacyNativeEvent, correlationFromContext, sameMobileDevice } from "./client-values.js";
+import { MobileEvidenceController, fitMobileEvent } from "./evidence-controller.js";
+import { normalizeCapabilities } from "./evidence-capabilities.js";
+import { canonicalEvent } from "./evidence-wire.js";
+import { ownJSON } from "./owned-json.js";
+import { snapshotError, snapshotExceptionEvidence } from "./exception-evidence.js";
 import { getNativeModule, degradedNativeState, safeNativeCall } from "./native.js";
 import { applyBeforeSend } from "./before-send.js";
 import { defaultRedactFields, DEFAULT_HEADER_ALLOWLIST, sanitizeHeaders, sanitizeValue } from "./redaction.js";
 import { sanitizeTelemetry } from "./privacy-telemetry.js";
 const SDK_NAME = "@debugbundle/sdk-react-native";
-const DEFAULT_SDK_VERSION = "3.0.1";
+const DEFAULT_SDK_VERSION = "3.1.0";
 const MAX_PENDING_NATIVE_CALLS = 256;
 const MAX_PENDING_LOW_PRIORITY_CALLS = 224;
 const MAX_PENDING_NATIVE_BYTES = 4 * 1024 * 1024;
@@ -59,8 +66,10 @@ export class DebugBundleReactNativeClient {
     jsProbeActivationExpiresAt = 0;
     pendingNativeCalls = 0;
     pendingNativeBytes = 0;
+    evidence;
     constructor(config = {}) {
         this.config = resolveConfig(config);
+        this.evidence = new MobileEvidenceController(this.config);
         if (Object.keys(config).length > 0) {
             this.init(config);
         }
@@ -71,8 +80,34 @@ export class DebugBundleReactNativeClient {
     get lastEventAt() {
         return this.nativeState.lastEventAt ?? null;
     }
+    get evidenceCapabilities() {
+        return this.evidence.capabilities(this.nativeState, this.hasCanonicalBridge());
+    }
+    hasCanonicalBridge() {
+        return this.nativeModule?.enqueueCanonicalEventJson !== undefined || this.nativeModule?.enqueueCanonicalEvent !== undefined;
+    }
+    beginOperation() { return this.evidence.begin(); }
+    withOperationContext(operation) {
+        const scope = this.beginOperation();
+        try {
+            return operation(scope);
+        }
+        finally {
+            scope.close();
+        }
+    }
+    captureRecovery(observation) {
+        if (!this.canCapture("diagnostic_context", true) || !this.hasNativeCapacity(false) ||
+            !this.evidenceCapabilities.features.includes("recovery_v1"))
+            return;
+        const prepared = this.evidence.recovery(observation);
+        if (prepared)
+            this.enqueue("diagnostic_context", prepared.payload, null, true, undefined, true, true, prepared.correlation);
+    }
     init(config) {
+        this.evidence.close();
         this.config = resolveConfig(config);
+        this.evidence = new MobileEvidenceController(this.config);
         this.nativeModule = getNativeModule();
         if (!this.config.enabled) {
             this.nativeState = { status: "disconnected", lastEventAt: null, nativeModuleAvailable: Boolean(this.nativeModule) };
@@ -87,11 +122,14 @@ export class DebugBundleReactNativeClient {
             return;
         }
         try {
+            const initializedConfig = this.config;
             const initialization = this.nativeModule.initialize(nativeConfig(this.config));
             if (isPromiseLike(initialization)) {
                 this.nativeState = { status: "healthy", lastEventAt: null, nativeModuleAvailable: true };
                 void safeNativeCall(async () => {
-                    this.nativeState = normalizeNativeState(await initialization);
+                    const state = await initialization;
+                    if (this.config === initializedConfig)
+                        this.nativeState = normalizeNativeState(state);
                 }, undefined);
             }
             else {
@@ -106,17 +144,21 @@ export class DebugBundleReactNativeClient {
         if (!this.config.captureErrors || !this.canCapture("frontend_exception", false) ||
             !this.hasNativeCapacity(true))
             return;
-        const mergedContext = this.mergeContext(context);
-        const sanitizedError = asRecord(sanitizeValue(error, { redactFields: this.config.redactFields }));
+        const mergedContext = this.evidence.context(this.mergeContext(context), this.nativeState, this.hasCanonicalBridge());
+        const sanitizedError = snapshotError(error, this.config.redactFields);
+        const fatal = mergedContext.source === "react-native-global-error" && mergedContext.fatal === true;
+        const graph = this.evidenceCapabilities.features.includes("exception_evidence_v1")
+            ? snapshotExceptionEvidence(error, sanitizedError, this.config.redactFields, fatal) : undefined;
         this.enqueue("frontend_exception", {
             name: stringValue(sanitizedError.name) ?? "Error",
             message: stringValue(sanitizedError.message) ?? "Unknown error",
             stack: stringValue(sanitizedError.stack) ?? `${stringValue(sanitizedError.name) ?? "Error"}: ${stringValue(sanitizedError.message) ?? "Unknown error"}`,
             breadcrumbs: this.breadcrumbs.slice(),
-            probe_data: this.snapshotProbeData()
+            probe_data: this.snapshotProbeData(),
+            ...(graph ? { exception_evidence: graph } : {})
         }, stringValue(mergedContext.trace_id), false, asRecord(sanitizeValue(mergedContext, {
             redactFields: this.config.redactFields
-        })), this.config.captureErrors);
+        })), this.config.captureErrors, !fatal, correlationFromContext(mergedContext));
     }
     captureError(error, context = {}) {
         this.captureException(error, context);
@@ -236,7 +278,7 @@ export class DebugBundleReactNativeClient {
         await safeNativeCall(async () => {
             await this.nativeModule.flush();
             const state = await this.nativeModule.getStatus();
-            this.nativeState = state;
+            this.nativeState = normalizeNativeState(state);
         }, undefined);
     }
     async activateProbeTriggerToken(token) {
@@ -258,7 +300,8 @@ export class DebugBundleReactNativeClient {
         this.breadcrumbs.push(breadcrumb);
         this.breadcrumbs = this.breadcrumbs.slice(-this.config.maxBreadcrumbs);
         this.enqueue("frontend_breadcrumb", {
-            breadcrumb_type: type,
+            breadcrumb_type: ["route_change", "click", "form_submit", "console_log", "network_request"].includes(type) ? type
+                : type === "screen" ? "route_change" : type === "action" ? "click" : "console_log",
             data: breadcrumb.data
         }, null, true);
     }
@@ -272,7 +315,7 @@ export class DebugBundleReactNativeClient {
             source
         });
     }
-    enqueue(eventType, payload, traceId, countTowardSession, context, localPolicyAllows = true) {
+    enqueue(eventType, payload, traceId, countTowardSession, context, localPolicyAllows = true, runBeforeSend = true, correlation) {
         if (!localPolicyAllows)
             return;
         if (!this.canCapture(eventType, countTowardSession)) {
@@ -285,6 +328,7 @@ export class DebugBundleReactNativeClient {
         this.pendingNativeCalls += 1;
         let handedOff = false;
         let reservedBytes = 0;
+        let owner = null;
         try {
             const authoredEvent = {
                 schema_version: "2026-03-01",
@@ -299,15 +343,16 @@ export class DebugBundleReactNativeClient {
                     framework: "react-native"
                 },
                 occurred_at: new Date().toISOString(),
-                ...(traceId ? { correlation: { trace_id: traceId } } : {}),
+                ...(correlation ? { correlation } : traceId ? { correlation: { trace_id: traceId } } : {}),
                 ...(context && Object.keys(context).length > 0 ? { context } : {}),
-                payload: this.nativeState.device
-                    ? { ...payload, device: canonicalDevice(this.nativeState.device, this.config) }
-                    : payload
+                payload: eventType === "diagnostic_context" ? payload : { ...payload, device: canonicalDevice(this.nativeState.device, this.config) }
             };
             const initial = protectEventFields(authoredEvent, this.config.redactFields);
             if (!initial)
                 return;
+            owner = initial.event_id;
+            if (initial.event_type === "diagnostic_context" && (!canonicalEvent(ownJSON(initial)) || !this.evidence.budget.reserve(initial, owner)))
+                return;
             const config = this.config;
             const nativeModule = this.nativeModule;
             const initialBytes = utf8ByteLength(JSON.stringify(initial));
@@ -321,26 +366,30 @@ export class DebugBundleReactNativeClient {
                 return;
             }
             handedOff = true;
-            this.sendAdmittedEvent(initial, config, nativeModule, reservedBytes);
+            this.sendAdmittedEvent(initial, config, nativeModule, reservedBytes, runBeforeSend, !this.nativeState.device);
         }
         catch {
             this.nativeState = degradedNativeState("event_preparation_failed");
         }
         finally {
-            if (!handedOff)
+            if (!handedOff) {
                 this.releaseNativeCapacity(reservedBytes);
+                if (owner)
+                    this.evidence.budget.release(owner);
+            }
         }
     }
-    sendAdmittedEvent(initial, config, nativeModule, reservedBytes) {
+    sendAdmittedEvent(initial, config, nativeModule, reservedBytes, runBeforeSend, hydrateNativeDevice) {
         // This activation receives only a protected snapshot: deferred closures must
         // not retain the raw capture payload/context through their lexical scope.
+        const evidence = this.evidence;
         const prepareAndSend = async () => {
             if (this.config !== config)
                 return;
-            const safeEvent = this.prepareAdmittedEvent(initial, config, nativeModule.enqueueCanonicalEvent !== undefined);
+            const safeEvent = this.prepareAdmittedEvent(initial, config, nativeModule.enqueueCanonicalEventJson !== undefined || nativeModule.enqueueCanonicalEvent !== undefined, runBeforeSend, hydrateNativeDevice);
             if (safeEvent === null)
                 return;
-            const finalPriority = safeEvent.event_type === "frontend_exception" ||
+            const finalPriority = ["frontend_exception", "backend_exception"].includes(safeEvent.event_type) ||
                 safeEvent.event_type === "log_event" && ["error", "critical"].includes(String(safeEvent.payload.level));
             const eventBytes = utf8ByteLength(JSON.stringify(safeEvent));
             const finalLimit = finalPriority ? MAX_PENDING_NATIVE_BYTES : MAX_PENDING_LOW_PRIORITY_BYTES;
@@ -350,20 +399,33 @@ export class DebugBundleReactNativeClient {
                 return;
             this.pendingNativeBytes += eventBytes;
             reservedBytes += eventBytes;
-            if (nativeModule.enqueueCanonicalEvent)
+            if (safeEvent.event_type === "diagnostic_context") {
+                if (!evidence.budget.replace(initial.event_id, safeEvent))
+                    return;
+            }
+            else {
+                evidence.budget.release(initial.event_id);
+                if (["frontend_exception", "backend_exception"].includes(safeEvent.event_type))
+                    evidence.budget.register(safeEvent);
+            }
+            // iOS TurboModule object conversion removes nested nulls. A string carrier
+            // preserves the validated JSON shape; older binaries keep their existing API.
+            if (nativeModule.enqueueCanonicalEventJson)
+                await nativeModule.enqueueCanonicalEventJson(JSON.stringify(safeEvent));
+            else if (nativeModule.enqueueCanonicalEvent)
                 await nativeModule.enqueueCanonicalEvent(safeEvent);
             else
                 await nativeModule.enqueueEvent(safeEvent);
         };
-        const operation = config.beforeSend === null
+        const operation = config.beforeSend === null || !runBeforeSend
             ? safeNativeCall(prepareAndSend, undefined)
             : Promise.resolve().then(() => safeNativeCall(prepareAndSend, undefined));
-        void operation.finally(() => { this.releaseNativeCapacity(reservedBytes); });
+        void operation.finally(() => { this.releaseNativeCapacity(reservedBytes); evidence.budget.release(initial.event_id); });
     }
-    prepareAdmittedEvent(initial, config, canonical) {
+    prepareAdmittedEvent(initial, config, canonical, runBeforeSend, hydrateNativeDevice) {
         // Exit this synchronous activation before awaiting the bridge. An application
         // replacement may be huge before projection and must not survive suspension.
-        const event = applyBeforeSend(initial, config.beforeSend);
+        const event = applyBeforeSend(initial, runBeforeSend ? config.beforeSend : null);
         if (!event || this.config !== config)
             return null;
         const safeEvent = protectEventFields(event, config.redactFields);
@@ -372,9 +434,21 @@ export class DebugBundleReactNativeClient {
         if (safeEvent.event_type === "log_event" &&
             (!config.captureLogs || !(LOG_LEVELS[safeEvent.payload.level] >= LOG_LEVELS[config.logLevel])))
             return null;
-        if (safeEvent.event_type === "frontend_exception" && !config.captureErrors)
+        if (["frontend_exception", "backend_exception"].includes(safeEvent.event_type) && !config.captureErrors)
             return null;
-        return canonical ? safeEvent : toLegacyNativeEvent(safeEvent);
+        if (!canonicalEvent(ownJSON(safeEvent)))
+            return null;
+        const filtered = this.evidence.filter(safeEvent, this.nativeState, canonical);
+        if (!filtered)
+            return null;
+        const fitted = fitMobileEvent(filtered);
+        if (fitted && hydrateNativeDevice && fitted.sdk_name === SDK_NAME && fitted.event_type === "frontend_exception" &&
+            sameMobileDevice(initial.payload.device, fitted.payload.device)) {
+            // This is the private native carrier, whose existing worker supplies device
+            // metadata before wire delivery. Preserve an explicitly changed hook device.
+            delete fitted.payload.device;
+        }
+        return fitted ? canonical ? fitted : toLegacyNativeEvent(fitted) : null;
     }
     hasNativeCapacity(highPriority) {
         return this.pendingNativeCalls < (highPriority ? MAX_PENDING_NATIVE_CALLS : MAX_PENDING_LOW_PRIORITY_CALLS) &&
@@ -414,24 +488,6 @@ export class DebugBundleReactNativeClient {
         return this.jsProbeActivationExpiresAt > Date.now();
     }
 }
-function utf8ByteLength(value) {
-    let bytes = 0;
-    for (let index = 0; index < value.length; index += 1) {
-        const code = value.charCodeAt(index);
-        if (code < 0x80)
-            bytes += 1;
-        else if (code < 0x800)
-            bytes += 2;
-        else if (code >= 0xd800 && code <= 0xdbff && index + 1 < value.length &&
-            value.charCodeAt(index + 1) >= 0xdc00 && value.charCodeAt(index + 1) <= 0xdfff) {
-            bytes += 4;
-            index += 1;
-        }
-        else
-            bytes += 3;
-    }
-    return bytes;
-}
 export function createDebugBundleClient(config = {}) {
     return new DebugBundleReactNativeClient(config);
 }
@@ -452,6 +508,9 @@ export function resolveConfig(config) {
         maxEventsPerSession: clampInteger(config.maxEventsPerSession, 100, 1, 10000),
         maxBreadcrumbs: clampInteger(config.maxBreadcrumbs, 20, 1, 200),
         captureErrors: config.captureErrors ?? true,
+        captureExceptionEvidence: config.captureExceptionEvidence ?? true,
+        captureRecoveryObservations: config.captureRecoveryObservations ?? false,
+        evidenceCapabilities: config.evidenceCapabilities ? normalizeCapabilities(config.evidenceCapabilities) : null,
         captureUnhandledRejections: config.captureUnhandledRejections ?? true,
         captureScreens: config.captureScreens ?? true,
         captureActions: config.captureActions ?? false,
@@ -501,165 +560,3 @@ function safeInvoke(producer) {
 function isPromiseLike(value) {
     return Boolean(value && typeof value.then === "function");
 }
-function normalizeNativeState(state) {
-    return {
-        ...state,
-        status: state.status || "healthy",
-        nativeModuleAvailable: state.nativeModuleAvailable ?? true
-    };
-}
-function stringValue(value) {
-    return typeof value === "string" && value.length > 0 ? value : null;
-}
-function asRecord(value) {
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-        return value;
-    }
-    return {};
-}
-function objectWrap(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : { value };
-}
-function parseRequestUrl(url) {
-    try {
-        const parsed = new URL(url);
-        const query = {};
-        for (const [key, value] of parsed.searchParams) {
-            const existing = query[key];
-            if (existing === undefined) {
-                query[key] = value;
-            }
-            else if (Array.isArray(existing)) {
-                existing.push(value);
-            }
-            else {
-                query[key] = [existing, value];
-            }
-        }
-        return { path: parsed.pathname || "/", query };
-    }
-    catch {
-        const [path = "/", rawQuery = ""] = url.split("?", 2);
-        const query = {};
-        for (const segment of rawQuery.split("&")) {
-            if (!segment) {
-                continue;
-            }
-            const [rawKey = "", rawValue = ""] = segment.split("=", 2);
-            const key = decodeQuerySegment(rawKey);
-            const value = decodeQuerySegment(rawValue);
-            const existing = query[key];
-            if (existing === undefined) {
-                query[key] = value;
-            }
-            else if (Array.isArray(existing)) {
-                existing.push(value);
-            }
-            else {
-                query[key] = [existing, value];
-            }
-        }
-        return { path: path || "/", query };
-    }
-}
-function decodeQuerySegment(value) {
-    try {
-        return decodeURIComponent(value.replace(/\+/g, " "));
-    }
-    catch {
-        return value;
-    }
-}
-function sanitizeScreenName(screenName) {
-    return screenName.replace(/[^a-zA-Z0-9_.:/-]/g, "_").slice(0, 120);
-}
-function generateId() {
-    const cryptoLike = globalThis.crypto;
-    if (cryptoLike?.randomUUID) {
-        return cryptoLike.randomUUID();
-    }
-    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (marker) => {
-        const random = Math.trunc(Math.random() * 16);
-        const value = marker === "x" ? random : (random & 0x3) | 0x8;
-        return value.toString(16);
-    });
-}
-function canonicalDevice(nativeDevice, config) {
-    const source = nativeDevice ?? {};
-    const sourceOs = asRecord(source.os);
-    const sourceScreen = asRecord(source.screen);
-    const sourceViewport = asRecord(source.viewport);
-    const width = nonNegativeInteger(sourceScreen.width ?? source.screen_width);
-    const height = nonNegativeInteger(sourceScreen.height ?? source.screen_height);
-    return {
-        user_agent: stringValue(source.user_agent),
-        os: {
-            name: stringValue(sourceOs.name ?? source.os_name),
-            version: stringValue(sourceOs.version ?? source.os_version)
-        },
-        device_type: canonicalDeviceType(source.device_type),
-        screen: { width, height },
-        viewport: {
-            width: nonNegativeInteger(sourceViewport.width ?? width),
-            height: nonNegativeInteger(sourceViewport.height ?? height)
-        },
-        device_pixel_ratio: positiveNumber(source.device_pixel_ratio),
-        touch_capable: typeof source.touch_capable === "boolean" ? source.touch_capable : null,
-        language: stringValue(source.language ?? source.locale),
-        connection_type: stringValue(source.connection_type),
-        color_scheme_preference: canonicalColorScheme(source.color_scheme_preference),
-        app_version: stringValue(source.app_version) ?? config.appVersion,
-        build_number: stringValue(source.build_number) ?? config.buildNumber,
-        release_channel: stringValue(source.release_channel) ?? config.releaseChannel,
-        api_level: nullableNonNegativeInteger(source.api_level),
-        manufacturer: stringValue(source.manufacturer),
-        model: stringValue(source.model),
-        timezone: stringValue(source.timezone),
-        battery_level: nonNegativeNumber(source.battery_level),
-        battery_charging: typeof source.battery_charging === "boolean"
-            ? source.battery_charging
-            : typeof source.charging === "boolean" ? source.charging : null,
-        free_disk_bytes: nullableNonNegativeInteger(source.free_disk_bytes),
-        free_memory_bytes: nullableNonNegativeInteger(source.free_memory_bytes),
-        jailbroken: typeof source.jailbroken === "boolean"
-            ? source.jailbroken
-            : typeof source.rooted === "boolean" ? source.rooted : null
-    };
-}
-function toLegacyNativeEvent(event) {
-    const context = event.context ?? {};
-    const payload = { ...event.payload, context };
-    if (event.event_type === "frontend_exception") {
-        payload.error = {
-            name: event.payload.name,
-            message: event.payload.message,
-            stack: event.payload.stack
-        };
-    }
-    else if (event.event_type === "request_event") {
-        payload.url = event.payload.path;
-    }
-    return { ...event, payload };
-}
-function canonicalDeviceType(value) {
-    return value === "desktop" || value === "mobile" || value === "tablet" ? value : "unknown";
-}
-function canonicalColorScheme(value) {
-    return value === "light" || value === "dark" || value === "no-preference" ? value : null;
-}
-function nonNegativeInteger(value) {
-    return nullableNonNegativeInteger(value) ?? 0;
-}
-function nullableNonNegativeInteger(value) {
-    return typeof value === "number" && Number.isFinite(value) && value >= 0
-        ? Math.trunc(value)
-        : null;
-}
-function positiveNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : null;
-}
-function nonNegativeNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
-}

package/dist/diagnostic-budget.d.ts

@@ -0,0 +1,16 @@
+import type { DebugBundleEventEnvelope } from "./types.js";
+/** Bridge ownership lasts until its promise settles; native offline ownership then
+ * remains with the native SDK. Observation/attempt allowances are never refunded. */
+export declare class MobileDiagnosticBudget {
+    private windows;
+    private pending;
+    get accountedBytes(): number;
+    private prune;
+    register(event: DebugBundleEventEnvelope): void;
+    reserve(event: DebugBundleEventEnvelope, owner?: string): boolean;
+    replace(owner: string, event: DebugBundleEventEnvelope): boolean;
+    release(id: string): void;
+    clear(): void;
+    private fresh;
+}
+//# sourceMappingURL=diagnostic-budget.d.ts.map

package/dist/diagnostic-budget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostic-budget.d.ts","sourceRoot":"","sources":["../src/diagnostic-budget.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAa3D;qFACqF;AACrF,qBAAa,sBAAsB;IACjC,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,OAAO,CAA8B;IAC7C,IAAI,cAAc,IAAI,MAAM,CAK3B;IACD,OAAO,CAAC,KAAK;IAGb,QAAQ,CAAC,KAAK,EAAE,wBAAwB,GAAG,IAAI;IAY/C,OAAO,CAAC,KAAK,EAAE,wBAAwB,EAAE,KAAK,SAAiB,GAAG,OAAO;IAwBzE,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,wBAAwB,GAAG,OAAO;IAmBhE,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAKzB,KAAK,IAAI,IAAI;IACb,OAAO,CAAC,KAAK;CACd"}

package/dist/diagnostic-budget.js

@@ -0,0 +1,120 @@
+import { evidenceReference } from "./evidence-wire.js";
+import { utf8Bytes } from "./owned-json.js";
+const cost = (value) => utf8Bytes(JSON.stringify(value));
+function scopeKey(event, reference) {
+    const scope = reference.scope;
+    return JSON.stringify([event.service.name, event.service.environment, event.correlation?.trace_id ?? null,
+        event.correlation?.session_id ?? null, reference.failure_ref, [scope.kind, scope.operation_id ?? scope.page_id]]);
+}
+/** Bridge ownership lasts until its promise settles; native offline ownership then
+ * remains with the native SDK. Observation/attempt allowances are never refunded. */
+export class MobileDiagnosticBudget {
+    windows = new Map();
+    pending = new Map();
+    get accountedBytes() {
+        let bytes = 0;
+        for (const [key, window] of this.windows)
+            bytes += cost([key, { ...window, attempts: [...window.attempts] }]);
+        for (const [id, pending] of this.pending)
+            bytes += pending.bytes + cost([id, pending.key, pending.attempt, pending.kind]);
+        return bytes;
+    }
+    prune(now) {
+        for (const [key, window] of this.windows)
+            if (!window.pending && now >= window.startsAt + 300_000)
+                this.windows.delete(key);
+    }
+    register(event) {
+        const reference = event.context?.evidence_reference;
+        if (!evidenceReference(reference))
+            return;
+        const now = Date.parse(event.occurred_at);
+        if (!Number.isFinite(now))
+            return;
+        this.prune(now);
+        const key = scopeKey(event, reference), previous = this.windows.get(key);
+        if (!previous && this.windows.size >= 50)
+            return;
+        const next = { ...(previous ?? this.fresh(now)), failureAt: previous?.failureAt ?? now, failureId: event.event_id };
+        if (previous?.failureId && previous.failureId !== event.event_id)
+            next.ambiguous = true;
+        this.windows.set(key, next);
+        if (this.accountedBytes > 65_536) {
+            if (previous)
+                this.windows.set(key, previous);
+            else
+                this.windows.delete(key);
+        }
+    }
+    reserve(event, owner = event.event_id) {
+        const now = Date.parse(event.occurred_at);
+        if (!Number.isFinite(now) || this.pending.has(owner))
+            return false;
+        this.prune(now);
+        const payload = event.payload, key = scopeKey(event, payload), previous = this.windows.get(key);
+        if (!previous && this.windows.size >= 50 || previous?.ambiguous)
+            return false;
+        const next = { ...(previous ?? this.fresh(now)), attempts: new Set(previous?.attempts), pending: (previous?.pending ?? 0) + 1 };
+        if (now < (next.failureAt ?? next.startsAt) || now > (next.failureAt ?? next.startsAt) + 300_000 || next.observations >= 20)
+            return false;
+        const attempt = payload.kind === "recovery" ? String(payload.attempt_id) : null;
+        if (attempt !== null) {
+            if (!next.attempts.has(attempt) && next.attempts.size >= 5)
+                return false;
+            next.attempts.add(attempt);
+        }
+        else {
+            if (next.resource || next.failureId !== payload.source_event_id || next.failureAt === null || now > next.failureAt + 30_000)
+                return false;
+            next.resource = true;
+        }
+        next.observations++;
+        this.windows.set(key, next);
+        this.pending.set(owner, { key, attempt, kind: String(payload.kind), bytes: cost(event) });
+        if (this.accountedBytes > 65_536) {
+            this.pending.delete(owner);
+            if (previous)
+                this.windows.set(key, previous);
+            else
+                this.windows.delete(key);
+            return false;
+        }
+        return true;
+    }
+    replace(owner, event) {
+        const current = this.pending.get(owner), payload = event.payload, key = scopeKey(event, payload);
+        const attempt = payload.kind === "recovery" ? String(payload.attempt_id) : null;
+        if (!current || current.key !== key || current.attempt !== attempt || current.kind !== payload.kind) {
+            this.release(owner);
+            return this.reserve(event, owner);
+        }
+        // Hook identity may stay stable while occurrence time or resource identity
+        // changes. Revalidate association without spending another observation.
+        const window = this.windows.get(key), now = Date.parse(event.occurred_at);
+        if (!window || window.ambiguous || !Number.isFinite(now) ||
+            now < (window.failureAt ?? window.startsAt) || now > (window.failureAt ?? window.startsAt) + 300_000 ||
+            attempt === null && (window.failureAt === null || payload.source_event_id !== window.failureId || now > window.failureAt + 30_000)) {
+            this.release(owner);
+            return false;
+        }
+        const previous = current.bytes;
+        current.bytes = cost(event);
+        if (this.accountedBytes > 65_536) {
+            current.bytes = previous;
+            this.release(owner);
+            return false;
+        }
+        return true;
+    }
+    release(id) {
+        const pending = this.pending.get(id);
+        if (!pending)
+            return;
+        this.pending.delete(id);
+        const window = this.windows.get(pending.key);
+        if (window)
+            window.pending = Math.max(0, window.pending - 1);
+    }
+    clear() { this.windows.clear(); this.pending.clear(); }
+    fresh(now) { return { startsAt: now, failureAt: null, failureId: null, attempts: new Set(), observations: 0, resource: false, ambiguous: false, pending: 0 }; }
+}

package/dist/event-schema-data.d.ts

@@ -0,0 +1,2 @@
+export declare const eventSchemaData: unknown;
+//# sourceMappingURL=event-schema-data.d.ts.map

package/dist/event-schema-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-schema-data.d.ts","sourceRoot":"","sources":["../src/event-schema-data.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe,EAAE,OA8CnB,CAAC"}