@bota.dev/web-app-sdk 2.0.0-beta.0

package/dist/encryptedUploadV2Host.d.ts

@@ -0,0 +1,239 @@
+import type { CoreBridge, CoreEffectEnvelope, CoreEncryptedUploadV2Checkpoint, CoreEncryptedUploadV2Evidence, CoreEncryptedUploadV2OutboundTransferFrame, CoreEncryptedUploadV2TransferFrame, CoreHostEvent } from './core.ts';
+import type { EncryptedUploadV2Material, EncryptedUploadV2Recording } from './providers.ts';
+import { type BrowserBlobHandle, type BrowserSdkStorage } from './storage.ts';
+import { type BrowserBluetoothTransport, type BrowserDeviceHandle } from './transport.ts';
+import type { WorkflowEffectContext, WorkflowEffectHost } from './workflowRuntime.ts';
+type SignedBlobKind = 'authorization' | 'receipt';
+export interface EncryptedUploadV2ListResult {
+    entries: Array<Extract<CoreEncryptedUploadV2TransferFrame, {
+        kind: 'recording_entry';
+    }>>;
+    listRevision: number;
+}
+export interface EncryptedUploadV2TransferRequest {
+    transportSessionId: bigint;
+    uploadSessionUuid: string;
+    recordingUuid: string;
+    recordingGeneration: number;
+    authorizationSha256: Uint8Array;
+    expectedCiphertextLength: bigint;
+    expectedCiphertextSha256: Uint8Array;
+    expectedCheckpointIntervalBlocks: number;
+    windowPackets: number;
+    dataPayloadBytes: number;
+}
+export type EncryptedUploadV2TransferContinuation = {
+    kind: 'window';
+} | {
+    kind: 'manifest';
+} | {
+    kind: 'repair';
+    missingSequences: number[];
+};
+export type EncryptedUploadV2OpenResult = {
+    kind: 'opened';
+    notifications: AsyncIterable<CoreEncryptedUploadV2TransferFrame>;
+} | {
+    kind: 'resume_rejected';
+};
+export interface EncryptedUploadV2NativeCheckpoint {
+    revision: number;
+    nextCiphertextOffset: bigint;
+    prefixSha256: Uint8Array;
+    highestContiguousSequence: number | null;
+}
+export type EncryptedUploadV2ReceiverEvent = {
+    kind: 'window_staged';
+    checkpoint: EncryptedUploadV2NativeCheckpoint;
+    missingSequences: number[];
+} | {
+    kind: 'completed';
+    manifest: Uint8Array;
+    evidence: CoreEncryptedUploadV2Evidence;
+};
+interface TransferReceiverOptions {
+    transportSessionId: bigint;
+    expectedCiphertextLength: bigint;
+    expectedCiphertextSha256: Uint8Array;
+    maximumDataPayloadBytes: number;
+    maximumWindowPackets: number;
+    maximumMissingSequences: number;
+    checkpoint: EncryptedUploadV2NativeCheckpoint;
+}
+interface BleOwnerTimingOptions {
+    resultTimeoutMs?: number;
+    cleanupTimeoutMs?: number;
+}
+export declare class EncryptedUploadV2SignedBlobWriter {
+    private readonly core;
+    private readonly transport;
+    private readonly device;
+    private readonly onOwnershipUncertain;
+    private readonly resultTimeoutMs;
+    private readonly cleanupTimeoutMs;
+    private readonly writes;
+    private active;
+    private operation;
+    private cancelled;
+    constructor(core: CoreBridge, transport: BrowserBluetoothTransport, device: BrowserDeviceHandle, onOwnershipUncertain?: () => void, timing?: BleOwnerTimingOptions);
+    send(blobKind: SignedBlobKind, writeId: number, value: Uint8Array, maximumBlobBytes: number, signal?: AbortSignal, terminalCallback?: () => void): Promise<void>;
+    private runSend;
+    cancel(): Promise<void>;
+    private finishOperation;
+    private poison;
+    private largestChunk;
+    private write;
+}
+export declare class EncryptedUploadV2TransferControl {
+    private readonly core;
+    private readonly transport;
+    private readonly device;
+    private readonly onOwnershipUncertain;
+    private readonly cleanupTimeoutMs;
+    private readonly writes;
+    private active;
+    private session;
+    constructor(core: CoreBridge, transport: BrowserBluetoothTransport, device: BrowserDeviceHandle, onOwnershipUncertain?: () => void, timing?: BleOwnerTimingOptions);
+    open(request: EncryptedUploadV2TransferRequest, checkpoint: EncryptedUploadV2NativeCheckpoint | null, signal?: AbortSignal): Promise<EncryptedUploadV2OpenResult>;
+    sendActiveFrame(frame: Extract<CoreEncryptedUploadV2OutboundTransferFrame, {
+        kind: 'window_ack';
+    }>, continuation: EncryptedUploadV2TransferContinuation): Promise<void>;
+    confirm(frame: Extract<CoreEncryptedUploadV2OutboundTransferFrame, {
+        kind: 'confirm';
+    }>, writeSucceeded: () => Promise<void>): Promise<void>;
+    confirmationAttemptedOrClaimCancellation(): Promise<boolean>;
+    abort(reason?: number): Promise<void>;
+    cancel(): Promise<void>;
+    private acceptTransferFrame;
+    private requireSession;
+    private releaseSession;
+    private poison;
+    list(transportSessionId: bigint, signal?: AbortSignal): Promise<EncryptedUploadV2ListResult>;
+    private writeControl;
+}
+export interface PersistedEncryptedUploadV2State {
+    schemaVersion: 1;
+    operationId: string;
+    serialNumber: string;
+    recording: EncryptedUploadV2Recording;
+    materialId: string;
+    recordingId: string;
+    uploadSessionId: string;
+    ownerRevision: number;
+    policy: 'legacy_allowed' | 'v2_preferred' | 'v2_required';
+    transportSessionId: bigint;
+    sinkId: string;
+    windowPackets: number;
+    dataPayloadBytes: number;
+    maximumSignedBlobBytes: number;
+    maximumMissingSequences: number;
+    checkpointIntervalBlocks: number;
+    capabilitySha256Hex: string;
+    coreCheckpoint: CoreEncryptedUploadV2Checkpoint | null;
+    highestContiguousSequence: number | null;
+    evidence: CoreEncryptedUploadV2Evidence | null;
+}
+export interface EncryptedUploadV2HostCallbacks {
+    transferCompleted(evidence: CoreEncryptedUploadV2Evidence): Promise<void>;
+    uploading(): Promise<void>;
+    cloudCompleted(receiptSha256: Uint8Array): Promise<void>;
+    confirmed(): Promise<void>;
+}
+export interface EncryptedUploadV2HostOptions {
+    core: CoreBridge;
+    transport: BrowserBluetoothTransport;
+    device: BrowserDeviceHandle;
+    storage: BrowserSdkStorage;
+    blob: BrowserBlobHandle;
+    material: EncryptedUploadV2Material;
+    state: PersistedEncryptedUploadV2State;
+    fetcher: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+    callbacks: EncryptedUploadV2HostCallbacks;
+    recoveryPhase: 'prepared' | 'transferring' | 'staged' | 'uploading' | 'cloud_completed';
+    expectedReceiptSha256Hex: string | null;
+    onOwnershipUncertain(): void;
+}
+export declare class EncryptedUploadV2Host implements WorkflowEffectHost {
+    private readonly core;
+    private readonly storage;
+    private readonly blob;
+    private readonly material;
+    private readonly state;
+    private readonly fetcher;
+    private readonly callbacks;
+    private readonly recoveryPhase;
+    private readonly expectedReceiptSha256Hex;
+    private readonly signedWriter;
+    private readonly transferControl;
+    private readonly uploadAbort;
+    private receiver;
+    private pendingNativeCheckpoint;
+    private persistedCoreCheckpoint;
+    private completedManifest;
+    private completedEvidence;
+    private acceptedReceipt;
+    private acceptedReceiptSha256;
+    private boundaryTarget;
+    private boundaryGate;
+    private startBoundaryTarget;
+    private pumpPromise;
+    private preparedAuthorizationSha256;
+    private cancelledValue;
+    private abortPromise;
+    constructor(options: EncryptedUploadV2HostOptions);
+    execute(envelope: CoreEffectEnvelope, context: WorkflowEffectContext): Promise<CoreHostEvent | readonly CoreHostEvent[] | null>;
+    confirmationAttemptedOrClaimCancellation(): Promise<boolean>;
+    cancel(): Promise<void>;
+    private startTransfer;
+    private repairWindow;
+    private saveCheckpoint;
+    private acknowledgeWindow;
+    private stageArtifacts;
+    private awaitReceipt;
+    private confirm;
+    private pump;
+    private dispatchTarget;
+    private validateCheckpointOwner;
+    private validateStartEffect;
+    private validateCompletion;
+    private requireReceiver;
+    private requireCompletedManifest;
+    private uploadCiphertext;
+    private abortState;
+}
+export declare class EncryptedUploadV2TransferReceiver {
+    private readonly core;
+    private readonly blob;
+    private readonly options;
+    private checkpoint;
+    private readonly packets;
+    private pendingWindow;
+    private readonly manifest;
+    private readonly manifestPresent;
+    private manifestSha256;
+    private prepared;
+    private terminal;
+    private completed;
+    private bufferedBytes;
+    constructor(core: CoreBridge, blob: BrowserBlobHandle, options: TransferReceiverOptions);
+    prepare(): Promise<void>;
+    receive(frame: CoreEncryptedUploadV2TransferFrame): Promise<EncryptedUploadV2ReceiverEvent | null>;
+    repairAcknowledgement(missingSequences: number[]): Extract<CoreEncryptedUploadV2OutboundTransferFrame, {
+        kind: 'window_ack';
+    }>;
+    checkpointDidPersist(checkpoint: EncryptedUploadV2NativeCheckpoint): void;
+    windowAcknowledgement(checkpoint: EncryptedUploadV2NativeCheckpoint): Extract<CoreEncryptedUploadV2OutboundTransferFrame, {
+        kind: 'window_ack';
+    }>;
+    private receiveData;
+    private receiveWindowEnd;
+    private receiveManifest;
+    private receiveEof;
+    private flushWindow;
+    private hashProspectivePrefix;
+    private acknowledgement;
+}
+export declare function initialEncryptedUploadV2Checkpoint(): EncryptedUploadV2NativeCheckpoint;
+export declare function coreCheckpoint(serialNumber: string, recordingUuid: Uint8Array, recordingGeneration: number, uploadSessionId: Uint8Array, ownerRevision: number, transportSessionId: bigint, checkpoint: EncryptedUploadV2NativeCheckpoint, windowPackets: number, dataPayloadBytes: number): CoreEncryptedUploadV2Checkpoint;
+export declare function parsePersistedEncryptedUploadV2State(value: unknown): PersistedEncryptedUploadV2State;
+export {};