@genn-inc/cluebase-frontend-sdk 0.0.6 → 0.0.9

package/dist/exporter/browser-outbox-records.d.ts

@@ -4,27 +4,11 @@ import { type BrowserSourceEvent } from "./source-event.js";
 export type StorageLike = Pick<Storage, "getItem" | "setItem" | "removeItem" | "key"> & {
     readonly length: number;
 };
-export type CollectionPermit = {
-    readonly generation: string;
-    readonly permittedAtStart: boolean;
-    readonly captureOrdinal: number;
-};
 export type OwnedBrowserEvent = {
     readonly byteLength: number;
-    readonly permit: CollectionPermit;
     readonly diagnosticCanonicalBytes: string;
     value(): BrowserSourceEvent;
 };
-export type PendingBrowserBatch = {
-    readonly events: readonly OwnedBrowserEvent[];
-    readonly metadata: BatchEnvelopeMetadata;
-    readonly generation: string;
-    readonly ordinal: number;
-    readonly diagnosticCanonicalBytes: string;
-    readonly recordKey: string;
-    readonly ownerBatchId: string;
-    readonly planOrdinal: number | null;
-};
 type RecordBase = {
     readonly storageVersion: 2;
     readonly projectHash: string;
@@ -98,9 +82,13 @@ export type PendingRecordLike = PendingRecord | SplitPlanRecord;
 type StoredWithoutChecksum = Omit<OutboxRecord, "checksumSha256">;
 export declare const UNANCHORED_COLLECTION_GENERATION = "__cluebase_unanchored_generation__";
 export declare const LEGACY_TOMBSTONE_LIMIT = 10000;
+export type DraftPermit = {
+    readonly generation: string;
+    readonly permittedAtStart: boolean;
+};
 export declare const createDraft: (input: {
     readonly event: BrowserSourceEvent;
-    readonly permit: CollectionPermit;
+    readonly permit: DraftPermit;
     readonly projectHash: string;
     readonly createdAt: string;
     readonly origin?: "v2" | "legacy_v1";
@@ -122,13 +110,8 @@ export declare const createPending: (input: {
     readonly drafts: readonly DraftRecord[];
     readonly ordinal: number;
 }) => PendingRecord;
-export declare const toPendingBatch: (record: PendingRecordLike, recordKey: string, events: readonly OwnedStoredEvent[], metadata: BatchEnvelopeMetadata, planOrdinal: number | null) => PendingBrowserBatch;
-export declare const toHeadBatch: (record: PendingRecordLike, recordKey: string) => PendingBrowserBatch | null;
-export declare const splitPendingRecord: (record: PendingRecordLike, createMetadata: () => BatchEnvelopeMetadata) => SplitPlanRecord | null;
-export declare const largestFittingPrefix: (drafts: readonly DraftRecord[], maxBytes: number, metadata: BatchEnvelopeMetadata, measure: (events: readonly BrowserSourceEvent[], metadata: BatchEnvelopeMetadata) => number) => number;
-export declare const ownEvent: (event: BrowserSourceEvent, permit: CollectionPermit) => OwnedBrowserEvent | null;
-export declare const isOwnedEvent: (value: OwnedBrowserEvent | null) => value is OwnedBrowserEvent;
-export declare const recordBatchId: (batch: PendingBrowserBatch) => string;
+export declare const sentByteLength: (event: BrowserSourceEvent) => number;
+export declare const ownEvent: (event: BrowserSourceEvent) => OwnedBrowserEvent | null;
 export declare const withChecksum: <T extends StoredWithoutChecksum>(record: T) => T & {
     readonly checksumSha256: string;
 };

package/dist/exporter/browser-outbox-records.js

@@ -1,11 +1,11 @@
 import { sha256 } from "@noble/hashes/sha256";
 import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils";
 import { canonicalize as canonicalJsonStringify } from "json-canonicalize";
-import { isBrowserSourceSignalEvent, } from "./source-event.js";
+import { isBrowserSourceSignalEvent, withSourceEvidence, } from "./source-event.js";
 export const UNANCHORED_COLLECTION_GENERATION = "__cluebase_unanchored_generation__";
 export const LEGACY_TOMBSTONE_LIMIT = 10000;
 export const createDraft = (input) => {
-    const owned = ownEvent(input.event, input.permit);
+    const owned = ownEvent(input.event);
     if (!owned)
         return null;
     const event = owned.value();
@@ -71,102 +71,16 @@ export const createPending = (input) => {
         ordinal: input.ordinal,
     });
 };
-export const toPendingBatch = (record, recordKey, events, metadata, planOrdinal) => {
-    const owned = events
-        .map((event) => ownEvent(event.event, {
-        generation: record.collectionGeneration,
-        permittedAtStart: event.permittedAtStart,
-        captureOrdinal: 0,
-    }))
-        .filter(isOwnedEvent);
-    return Object.freeze({
-        events: Object.freeze(owned),
-        metadata: Object.freeze({ ...metadata }),
-        generation: record.collectionGeneration,
-        ordinal: record.ordinal,
-        diagnosticCanonicalBytes: canonicalJsonStringify({
-            sourceType: "frontend_sdk",
-            sourceSchemaVersion: "1",
-            batchId: metadata.batch_id,
-            idempotencyKey: metadata.idempotency_key,
-            sentAt: metadata.sent_at,
-            events: owned.map((event) => event.value()),
-        }),
-        recordKey,
-        ownerBatchId: record.batchId,
-        planOrdinal,
-    });
-};
-export const toHeadBatch = (record, recordKey) => {
-    if (record.kind === "pending") {
-        return toPendingBatch(record, recordKey, record.events, {
-            batch_id: record.batchId,
-            idempotency_key: record.idempotencyKey,
-            sent_at: record.sentAt,
-        }, null);
-    }
-    const child = record.children[record.nextOrdinal];
-    if (!child)
-        return null;
-    return toPendingBatch(record, recordKey, record.events.slice(child.start, child.end), child.metadata, record.nextOrdinal);
-};
-export const splitPendingRecord = (record, createMetadata) => {
-    const child = record.kind === "pending"
-        ? {
-            start: 0,
-            end: record.events.length,
-            metadata: {
-                batch_id: record.batchId,
-                idempotency_key: record.idempotencyKey,
-                sent_at: record.sentAt,
-            },
-        }
-        : record.children[record.nextOrdinal];
-    if (!child || child.end - child.start < 2)
-        return null;
-    const boundary = child.start + Math.ceil((child.end - child.start) / 2);
-    const replacements = [
-        { start: child.start, end: boundary, metadata: createMetadata() },
-        { start: boundary, end: child.end, metadata: createMetadata() },
-    ];
-    return withChecksum({
-        ...withoutChecksum(record),
-        kind: "split_plan",
-        children: record.kind === "pending"
-            ? replacements
-            : [
-                ...record.children.slice(0, record.nextOrdinal),
-                ...replacements,
-                ...record.children.slice(record.nextOrdinal + 1),
-            ],
-        nextOrdinal: record.kind === "pending" ? 0 : record.nextOrdinal,
-    });
-};
-export const largestFittingPrefix = (drafts, maxBytes, metadata, measure) => {
-    let low = 1;
-    let high = drafts.length;
-    let largest = 0;
-    while (low <= high) {
-        const count = Math.floor((low + high) / 2);
-        if (measure(drafts.slice(0, count).map((draft) => draft.event), metadata) <= maxBytes) {
-            largest = count;
-            low = count + 1;
-        }
-        else {
-            high = count - 1;
-        }
-    }
-    return largest;
-};
-export const ownEvent = (event, permit) => {
+export const sentByteLength = (event) => new TextEncoder().encode(JSON.stringify(withSourceEvidence(event)))
+    .byteLength;
+export const ownEvent = (event) => {
     try {
         const json = JSON.stringify(event);
         const parsed = JSON.parse(json);
         if (!isBrowserSourceSignalEvent(parsed))
             return null;
         return Object.freeze({
-            byteLength: new TextEncoder().encode(json).byteLength,
-            permit: Object.freeze({ ...permit }),
+            byteLength: sentByteLength(parsed),
             diagnosticCanonicalBytes: canonicalJsonStringify(parsed),
             value: () => JSON.parse(json),
         });
@@ -175,8 +89,6 @@ export const ownEvent = (event, permit) => {
         return null;
     }
 };
-export const isOwnedEvent = (value) => value !== null;
-export const recordBatchId = (batch) => batch.ownerBatchId;
 export const withChecksum = (record) => ({
     ...record,
     checksumSha256: sha256Hex(canonicalJsonStringify(record)),

package/dist/exporter/browser-outbox.d.ts

@@ -1,10 +1,11 @@
 import type { InternalMetricsStore } from "../internal/metrics.js";
 import type { CluebaseConsentState } from "../provider/types.js";
-import { type CollectionPermit, type PendingBrowserBatch, type StorageLike } from "./browser-outbox-records.js";
+import { type DraftRecord, type PendingRecordLike, type StorageLike } from "./browser-outbox-records.js";
 import type { BatchEnvelopeMetadata } from "./client.js";
 import { DiagnosticStore } from "./diagnostics.js";
+import type { RestoredEvent } from "./sdk-core-delivery.js";
 import type { BrowserSourceEvent } from "./source-event.js";
-export type { CollectionPermit, OwnedBrowserEvent, PendingBrowserBatch, } from "./browser-outbox-records.js";
+export type { OwnedBrowserEvent } from "./browser-outbox-records.js";
 export type ConsentTransition = {
     readonly state: CluebaseConsentState;
     readonly generation: string;
@@ -21,17 +22,15 @@ export declare class BrowserOutbox {
     private readonly lockName;
     private readonly storage;
     private readonly durableOutboxSupported;
-    private readonly maxBytes;
-    private readonly maxEvents;
     private readonly metrics;
     private readonly diagnostics;
     private drafts;
     private pending;
+    private readonly pendingByBatchId;
     private tombstones;
     private nextOrdinal;
     private consent;
     private generation;
-    private nextPermitOrdinal;
     private legacyImportBlocked;
     private consentAnchorEstablished;
     private initialDenialPending;
@@ -47,47 +46,44 @@ export declare class BrowserOutbox {
     constructor(options: {
         readonly projectKey: string;
         readonly initialConsent: CluebaseConsentState;
-        readonly maxBytes: number;
-        readonly maxEvents: number;
         readonly metrics?: InternalMetricsStore;
         readonly diagnostics?: DiagnosticStore;
         readonly storage?: StorageLike | null;
         readonly onConsentRevoked?: () => void;
     });
     currentConsent(): CluebaseConsentState;
-    capturePermit(): CollectionPermit;
-    permits(permit: CollectionPermit): boolean;
+    collectionGeneration(): string;
     setConsent(next: CluebaseConsentState): ConsentTransition;
     commitConsentTransition(transition: ConsentTransition): void;
     private persistCommittedConsent;
-    addDraft(event: BrowserSourceEvent, permit?: CollectionPermit): boolean;
-    estimatedDraftBytes(measure: (events: readonly BrowserSourceEvent[], metadata: BatchEnvelopeMetadata) => number, metadata: BatchEnvelopeMetadata): number;
-    draftCount(): number;
-    prepareFence(input: {
-        readonly maxPayloadBytes: number;
+    holdDraft(event: BrowserSourceEvent): DraftRecord | null;
+    claimBatch(input: {
+        readonly batchId: number;
+        readonly eventKeys: readonly string[];
         readonly createMetadata: () => BatchEnvelopeMetadata;
-        readonly measure: (events: readonly BrowserSourceEvent[], metadata: BatchEnvelopeMetadata) => number;
     }): {
-        readonly targetOrdinal: number;
-        readonly oversized: number;
+        readonly record: PendingRecordLike;
+        readonly minted: boolean;
+    } | null;
+    releaseBatch(batchId: number): void;
+    reopenBatch(batchId: number): void;
+    releaseEvents(eventKeys: readonly string[]): void;
+    restorable(): {
+        readonly batches: readonly {
+            readonly ordinal: number;
+            readonly storedBatchId: string;
+            readonly events: readonly RestoredEvent[];
+        }[];
+        readonly drafts: readonly DraftRecord[];
     };
-    headThrough(targetOrdinal: number): PendingBrowserBatch | null;
-    removeHead(expected: PendingBrowserBatch): boolean;
-    retainHead(expected: PendingBrowserBatch): boolean;
-    splitHead(expected: PendingBrowserBatch, createMetadata: () => BatchEnvelopeMetadata): boolean;
+    bindRestoredBatch(storedBatchId: string, batchId: number): void;
     clear(): boolean;
     close(): void;
     pendingEventCount(): number;
-    pendingBytes(): number;
     withDeliveryLock<T>(operation: () => Promise<T>, options?: {
         readonly restore?: boolean;
     }): Promise<T>;
-    private permitsBatch;
-    private resolvePermit;
     private initializeConsentForDelivery;
-    private enforceCapacity;
-    private dropOldestPendingForCapacity;
-    private forciblyRemovePendingRecord;
     private purgeAll;
     clearMemory(): void;
     private restore;
@@ -104,7 +100,6 @@ export declare class BrowserOutbox {
     private persistConsent;
     private writeRecord;
     private removeRecord;
-    private removeDraft;
     private removeClaimedDraftRecords;
     private readRecord;
     private failClosedConsentState;