@opengeni/sdk 0.48.0 → 0.57.0

package/dist/editable-artifacts/types.d.ts

@@ -0,0 +1,416 @@
+/** Opaque artifact identity. Workspace authority is carried by the ticket. */
+export type EditableArtifactId = string;
+export type EditableArtifactModality = "document" | "spreadsheet" | "presentation";
+export type EditableArtifactSerializedModality = Exclude<EditableArtifactModality, "spreadsheet">;
+export type EditableArtifactCausalEntry = Readonly<{
+    replicaId: string;
+    counter: number;
+}>;
+/** Sorted by replicaId, duplicate-free. */
+export type EditableArtifactCausalFrontier = readonly EditableArtifactCausalEntry[];
+/**
+ * Short-lived, artifact-scoped credential minted over authenticated HTTP.
+ * Implementations must never put a durable bearer token in a socket URL.
+ */
+export type EditableArtifactSyncTicket = {
+    artifactId: EditableArtifactId;
+    modality: EditableArtifactModality;
+    replicaId: string;
+    token: string;
+    expiresAt: string;
+    protocolVersion: number;
+};
+/** Immutable, server-verified canonical state. */
+type EditableArtifactSnapshotCommon = {
+    artifactId: EditableArtifactId;
+    sequence: number;
+    stateHash: string;
+    digest: string;
+    kernelVersion: string;
+    modelSchemaVersion: number;
+    bytes: Uint8Array;
+};
+export type EditableArtifactSpreadsheetSnapshot = EditableArtifactSnapshotCommon & {
+    modality: "spreadsheet";
+    causalFrontier: EditableArtifactCausalFrontier;
+    protocolVersion: number;
+};
+export type EditableArtifactSerializedSnapshot = EditableArtifactSnapshotCommon & {
+    modality: EditableArtifactSerializedModality;
+    nativeRevision: number;
+};
+export type EditableArtifactSnapshot = EditableArtifactSpreadsheetSnapshot | EditableArtifactSerializedSnapshot;
+/** One authoritative, atomically committed artifact transaction. */
+type EditableArtifactCommittedTransactionCommon = {
+    artifactId: EditableArtifactId;
+    transactionId: string;
+    requestHash: string;
+    startSequence: number;
+    endSequence: number;
+    priorStateHash: string;
+    stateHash: string;
+    committedTransactionBytes: Uint8Array;
+};
+export type EditableArtifactSpreadsheetCommittedTransaction = EditableArtifactCommittedTransactionCommon & {
+    modality: "spreadsheet";
+    causalFrontier: EditableArtifactCausalFrontier;
+    protocolVersion: number;
+    /** Exact whole canonical OGACO committed-transaction envelope. */
+    committedTransactionBytes: Uint8Array;
+};
+export type EditableArtifactSerializedCommittedTransaction = EditableArtifactCommittedTransactionCommon & {
+    modality: EditableArtifactSerializedModality;
+    priorNativeRevision: number;
+    nativeRevision: number;
+    commitProtocolVersion: number;
+    /** Exact whole canonical OGAST committed-transaction envelope. */
+    committedTransactionBytes: Uint8Array;
+};
+export type EditableArtifactCommittedTransaction = EditableArtifactSpreadsheetCommittedTransaction | EditableArtifactSerializedCommittedTransaction;
+/** A locally durable command batch. Retried with exactly the same identity. */
+type EditableArtifactPendingTransactionCommon = {
+    artifactId: EditableArtifactId;
+    /** Caller-authored portable OGATX client transaction identity. */
+    clientTransactionId: string;
+    requestHash: string;
+    protocolVersion: number;
+    modelSchemaVersion: number;
+    commandVersion: number;
+    replicaId: string;
+    /** Monotonic within one persisted replica epoch; never changed on retry. */
+    replicaCounter: number;
+    /** Symbolic predecessor resolved by the server to that transaction's causal stamp. */
+    previousLocalTransactionId: string | null;
+    observedHeadSequence: number;
+    commandBytes: Uint8Array;
+    /** Exact OGATX001 bytes persisted and retried byte-identically. */
+    intentBytes: Uint8Array;
+    createdAt: number;
+};
+export type EditableArtifactSpreadsheetPendingTransaction = EditableArtifactPendingTransactionCommon & {
+    modality: "spreadsheet";
+    causalBase: EditableArtifactCausalFrontier;
+    selectiveUndoTargets: readonly string[];
+};
+export type EditableArtifactSerializedPendingTransaction = EditableArtifactPendingTransactionCommon & {
+    modality: EditableArtifactSerializedModality;
+    /** Local proof that the strictly serialized command was authored over this native revision. */
+    observedNativeRevision: number;
+};
+export type EditableArtifactPendingTransaction = EditableArtifactSpreadsheetPendingTransaction | EditableArtifactSerializedPendingTransaction;
+export type EditableArtifactBlockedPending = Readonly<{
+    clientTransactionId: string;
+    code: string;
+}>;
+/** A bounded, sparse spreadsheet viewport requested from the Worker-owned kernel. */
+export type EditableSpreadsheetViewportQuery = Readonly<{
+    sheetId: string;
+    startRow: number;
+    startColumn: number;
+    rowCount: number;
+    columnCount: number;
+    /** Hard-clamped by the Worker/kernel; never permits a partial response. */
+    maxCells?: number;
+    /** Hard-clamped by the Worker/kernel; never permits a partial response. */
+    maxBytes?: number;
+}>;
+export type EditableSpreadsheetFormulaError = "null" | "divide_by_zero" | "value" | "reference" | "name" | "number" | "not_available" | "spill" | "calculation" | Readonly<{
+    custom: string;
+}>;
+export type EditableSpreadsheetCellValue = Readonly<{
+    kind: "empty";
+}> | Readonly<{
+    kind: "boolean";
+    value: boolean;
+}> | Readonly<{
+    kind: "number";
+    value: number;
+}>
+/** Canonical `Date.prototype.toISOString()` output; never a numeric serial. */
+ | Readonly<{
+    kind: "date";
+    value: string;
+}> | Readonly<{
+    kind: "text";
+    value: string;
+}> | Readonly<{
+    kind: "error";
+    value: EditableSpreadsheetFormulaError;
+}>;
+export type EditableSpreadsheetProjectedCell = Readonly<{
+    row: number;
+    column: number;
+    formula: string | null;
+    value: EditableSpreadsheetCellValue;
+}>;
+/**
+ * Immutable projection of one exact speculative kernel revision. Cells are
+ * sparse, strictly row-major, unique, and all inside the requested rectangle.
+ */
+export type EditableSpreadsheetViewportProjection = Readonly<{
+    revision: bigint;
+    sheetId: string;
+    /** Creation operation that pins the live CRDT generation, if collaborative. */
+    generationId: string | null;
+    startRow: number;
+    startColumn: number;
+    rowCount: number;
+    columnCount: number;
+    cells: readonly EditableSpreadsheetProjectedCell[];
+}>;
+export type EditableSpreadsheetUsedBounds = Readonly<{
+    startRow: number;
+    startColumn: number;
+    /** Inclusive maximum occupied row. */
+    endRow: number;
+    /** Inclusive maximum occupied column. */
+    endColumn: number;
+}>;
+export type EditableSpreadsheetSheetMetadata = Readonly<{
+    sheetId: string;
+    generationId: string | null;
+    name: string;
+    usedBounds: EditableSpreadsheetUsedBounds | null;
+}>;
+/**
+ * Bounded workbook catalog from the Worker-owned kernel. False feature flags
+ * mean the kernel does not model that feature; the SDK never invents authority.
+ */
+export type EditableSpreadsheetMetadataProjection = Readonly<{
+    revision: bigint;
+    modeledFeatures: Readonly<{
+        dimensions: boolean;
+        hidden: boolean;
+        merges: boolean;
+    }>;
+    sheets: readonly EditableSpreadsheetSheetMetadata[];
+}>;
+export type EditableSpreadsheetMetadataQuery = Readonly<{
+    maxSheets?: number;
+    maxBytes?: number;
+}>;
+export type EditableArtifactStoredReplica = {
+    artifactId: EditableArtifactId;
+    modality: EditableArtifactModality;
+    /** Last immutable server snapshot loaded and verified by the kernel. */
+    snapshot: EditableArtifactSnapshot;
+    /** Contiguous committed tail needed to reconstruct `cursor` after reload. */
+    tail: EditableArtifactCommittedTransaction[];
+    cursor: number;
+    stateHash: string;
+    updatedAt: number;
+};
+type EditableArtifactBootstrapCommon = {
+    artifactId: EditableArtifactId;
+    protocolVersion: number;
+    headSequence: number;
+    headStateHash: string;
+    kernelVersion: string;
+    modelSchemaVersion: number;
+    writable: boolean;
+    /** Earliest sequence still available through replay, inclusive. */
+    minimumReplaySequence: number;
+    /** Supplied for first load, requested resync, or a newer compact snapshot. */
+    snapshot: EditableArtifactSnapshot | null;
+    /** Server has expired this replica's history and requires a fresh snapshot. */
+    resyncRequired: boolean;
+};
+export type EditableArtifactBootstrap = EditableArtifactBootstrapCommon & ({
+    modality: "spreadsheet";
+    headCausalFrontier: EditableArtifactCausalFrontier;
+} | {
+    modality: EditableArtifactSerializedModality;
+    headNativeRevision: number;
+});
+export type EditableArtifactReplayPage = {
+    artifactId: EditableArtifactId;
+    transactions: EditableArtifactCommittedTransaction[];
+    headSequence: number;
+};
+export type EditableArtifactSubmitReceipt = {
+    artifactId: EditableArtifactId;
+    /** Exact OGATX client identity acknowledged by the authority. */
+    clientTransactionId: string;
+    /** Authoritative OGACO (spreadsheet) or OGAST (document/presentation) transaction identity. */
+    transactionId: string;
+    requestHash: string;
+    committed: EditableArtifactCommittedTransaction;
+};
+export type EditableArtifactLiveMessage = {
+    type: "transaction.committed";
+    transaction: EditableArtifactCommittedTransaction;
+} | {
+    type: "head";
+    artifactId: EditableArtifactId;
+    headSequence: number;
+} | {
+    type: "authorization";
+    artifactId: EditableArtifactId;
+    writable: boolean;
+} | {
+    type: "resync_required";
+    artifactId: EditableArtifactId;
+    reason: string;
+};
+export type EditableArtifactLiveClose = {
+    reason: "closed" | "ticket_expired" | "transport_error" | "permission_changed";
+    error?: unknown;
+};
+/** Exact limits advertised by the authenticated OGALV stream epoch. */
+export type EditableArtifactLiveLimits = Readonly<{
+    maxClientFrameBytes: number;
+    maxCommandBytes: number;
+    maxIntentBytes: number;
+    maxCommittedTransactionBytes: number;
+    maxSnapshotBytes: number;
+    maxInFlightTransactions: number;
+    maxInFlightBytes: number;
+}>;
+export type EditableArtifactLiveConnection = {
+    /** Opaque server session binding subscription, retention lease, and bootstrap. */
+    streamEpoch: string;
+    limits: EditableArtifactLiveLimits;
+    readBootstrap: (input: {
+        localCursor: number | null;
+        localStateHash: string | null;
+        resume: {
+            modality: "spreadsheet";
+            localCausalFrontier: EditableArtifactCausalFrontier;
+        } | {
+            modality: EditableArtifactSerializedModality;
+            localNativeRevision: number | null;
+        };
+        requireSnapshot: boolean;
+        signal: AbortSignal;
+    }) => Promise<EditableArtifactBootstrap>;
+    replay: (input: {
+        after: number;
+        through: number;
+        limit: number;
+        signal: AbortSignal;
+    }) => Promise<EditableArtifactReplayPage>;
+    submit: (input: {
+        transaction: EditableArtifactPendingTransaction;
+        signal: AbortSignal;
+    }) => Promise<EditableArtifactSubmitReceipt>;
+    acknowledge: (input: {
+        sequence: number;
+        stateHash: string;
+        signal: AbortSignal;
+    }) => Promise<void>;
+    /** Resolves once for every local or remote close. */
+    closed: Promise<EditableArtifactLiveClose>;
+    close: (reason?: string) => void;
+};
+/** HTTP/WebSocket details live behind this boundary. */
+export type EditableArtifactSyncTransport = {
+    mintTicket: (input: {
+        artifactId: EditableArtifactId;
+        replicaId: string;
+        signal: AbortSignal;
+    }) => Promise<EditableArtifactSyncTicket>;
+    /** Must subscribe before returning; bootstrap is read only after this call. */
+    openLive: (input: {
+        ticket: EditableArtifactSyncTicket;
+        after: number;
+        stateHash: string | null;
+        resume: {
+            modality: "spreadsheet";
+            causalFrontier: EditableArtifactCausalFrontier;
+        } | {
+            modality: EditableArtifactSerializedModality;
+            nativeRevision: number | null;
+        };
+        requireSnapshot: boolean;
+        signal: AbortSignal;
+        onMessage: (message: EditableArtifactLiveMessage) => void;
+    }) => Promise<EditableArtifactLiveConnection>;
+};
+/**
+ * Implemented by a dedicated browser Worker around the WASM kernel. The
+ * controller never mutates artifact state on the UI thread.
+ */
+export type EditableArtifactWorkerKernel = {
+    reset: () => Promise<void>;
+    /** Computes the digest over owned bytes inside the Worker. */
+    loadSnapshot: (snapshot: EditableArtifactSnapshot) => Promise<{
+        stateHash: string;
+        digest: string;
+    }>;
+    /** Rebuild-only path used before bootstrap exposes a visible revision. */
+    applyRecovered: (transaction: EditableArtifactCommittedTransaction) => Promise<{
+        stateHash: string;
+    }>;
+    /** Atomically commits confirmed state and publishes the rebased speculative layer. */
+    reconcileCommitted: (transaction: EditableArtifactCommittedTransaction, remainingPending: readonly EditableArtifactPendingTransaction[]) => Promise<{
+        stateHash: string;
+        blockedPending: readonly EditableArtifactBlockedPending[];
+    }>;
+    /** Rebuilds the speculative layer without changing confirmed authority. */
+    replacePending: (transactions: readonly EditableArtifactPendingTransaction[]) => Promise<{
+        blockedPending: readonly EditableArtifactBlockedPending[];
+    }>;
+    /** Canonical encoding + request hashing occurs off the UI thread. */
+    authorPending: (input: {
+        modality: EditableArtifactModality;
+        protocolVersion: number;
+        kernelVersion: string;
+        modelSchemaVersion: number;
+        commandVersion: number;
+        artifactId: EditableArtifactId;
+        clientTransactionId: string;
+        replicaId: string;
+        replicaCounter: number;
+        previousLocalTransactionId: string | null;
+        observedHeadSequence: number;
+        causalBase?: EditableArtifactCausalFrontier;
+        selectiveUndoTargets?: readonly string[];
+        commandBytes: Uint8Array;
+        createdAt: number;
+    }) => Promise<EditableArtifactPendingTransaction>;
+    /** Runs against the speculative fork; canonical state remains Worker-only. */
+    querySpreadsheetViewport: (query: EditableSpreadsheetViewportQuery) => Promise<EditableSpreadsheetViewportProjection>;
+    querySpreadsheetMetadata: (query?: EditableSpreadsheetMetadataQuery) => Promise<EditableSpreadsheetMetadataProjection>;
+    /** Canonical, bounded document projection produced by the real Worker WASM session. */
+    queryDocument: (query: DocumentArtifactQuery) => Promise<DocumentArtifactProjection>;
+    /** Canonical, bounded presentation projection produced by the real Worker WASM session. */
+    queryPresentation: (query: PresentationArtifactQuery) => Promise<PresentationArtifactQueryResponse>;
+};
+export type EditableDocumentQuery = DocumentArtifactQuery;
+export type EditableDocumentProjection = DocumentArtifactProjection;
+export type EditablePresentationQuery = PresentationArtifactQuery;
+export type EditablePresentationProjection = PresentationArtifactQueryResponse;
+export type EditablePresentationSlideCatalogQuery = Extract<PresentationArtifactQuery, {
+    kind: "slide-catalog";
+}>;
+export type EditablePresentationEditorSlideQuery = Extract<PresentationArtifactQuery, {
+    kind: "editor-slide";
+}>;
+export type EditablePresentationSlideCatalogProjection = Extract<PresentationArtifactQueryResponse, {
+    kind: "slide-catalog";
+}>;
+export type EditablePresentationEditorSlideProjection = Extract<PresentationArtifactQueryResponse, {
+    kind: "editor-slide";
+}>;
+export type EditableArtifactSyncState = "idle" | "connecting" | "syncing" | "live" | "reconnecting" | "resyncing" | "unsupported" | "failed" | "closed";
+export type EditableArtifactSyncView = {
+    artifactId: EditableArtifactId;
+    modality: EditableArtifactModality;
+    state: EditableArtifactSyncState;
+    cursor: number;
+    headSequence: number;
+    writable: boolean;
+    pendingTransactions: number;
+    blockedPending: readonly EditableArtifactBlockedPending[];
+    queuedMessages: number;
+    reconnectAttempt: number;
+    lastError: Error | null;
+};
+export type EditableArtifactSyncListener = (view: EditableArtifactSyncView) => void;
+export type EditableArtifactSyncScheduler = {
+    now: () => number;
+    sleep: (delayMs: number, signal: AbortSignal) => Promise<void>;
+};
+import type { DocumentArtifactProjection, DocumentArtifactQuery } from "@opengeni/contracts/document-artifact-query";
+import type { PresentationArtifactQuery, PresentationArtifactQueryResponse } from "@opengeni/contracts/presentation-artifact-query";
+export {};

package/dist/editable-artifacts/worker/browser-client.d.ts

@@ -0,0 +1,80 @@
+import type { EditableArtifactModality, EditableArtifactWorkerKernel, EditablePresentationEditorSlideProjection, EditablePresentationEditorSlideQuery, EditablePresentationSlideCatalogProjection, EditablePresentationSlideCatalogQuery } from "../types.js";
+import { type ArtifactWorkerRpcLimits, type ArtifactWorkerRpcMessage } from "./rpc-protocol.js";
+export type ArtifactWorkerClientMessageEvent = {
+    data: unknown;
+};
+export type ArtifactWorkerClientErrorEvent = {
+    error?: unknown;
+    message?: string;
+};
+export type ArtifactWorkerClientEndpoint = {
+    postMessage: (message: ArtifactWorkerRpcMessage, transfer: Transferable[]) => void;
+    addEventListener: {
+        (type: "message", listener: (event: ArtifactWorkerClientMessageEvent) => void): void;
+        (type: "error" | "messageerror", listener: (event: ArtifactWorkerClientErrorEvent) => void): void;
+    };
+    removeEventListener: {
+        (type: "message", listener: (event: ArtifactWorkerClientMessageEvent) => void): void;
+        (type: "error" | "messageerror", listener: (event: ArtifactWorkerClientErrorEvent) => void): void;
+    };
+    terminate: () => void;
+};
+export type CreateBrowserEditableArtifactWorkerKernelOptions = {
+    modality: EditableArtifactModality;
+    /** Exact package/runtime identity; checked before the Worker accepts state. */
+    kernelVersion: string;
+    protocolVersion: number;
+    modelSchemaVersion: number;
+    commandVersion: number;
+    /**
+     * Prebuilt module-Worker entry. No blob/eval worker is ever synthesized.
+     * Bundler example: import `workerUrl` from
+     * `@opengeni/sdk/editable-artifacts/worker?worker&url`, then pass it here.
+     */
+    workerUrl: string | URL;
+    /** wasm-bindgen ESM glue built from the pinned artifact kernel. */
+    wasmGlueUrl: string | URL;
+    /** Exact `.wasm` asset paired with the glue. */
+    wasmBinaryUrl: string | URL;
+    /**
+     * Origin hosting the embedding application. Browser runtimes default to
+     * `location.origin`; non-browser/custom Worker hosts must supply it.
+     */
+    applicationOrigin?: string | URL;
+    /** Additional explicitly trusted asset origins; same-origin is the default. */
+    allowedAssetOrigins?: readonly string[];
+    /** Only for local development. Production assets must use HTTPS. */
+    allowInsecureDevelopmentAssets?: boolean;
+    requestTimeoutMs?: number;
+    initializationTimeoutMs?: number;
+    maximumSnapshotBytes?: number;
+    maximumCommandBytes?: number;
+    maximumIntentBytes?: number;
+    maximumCommittedTransactionBytes?: number;
+    maximumQueryBytes?: number;
+    maximumQueryResponseBytes?: number;
+    maximumPendingTransactions?: number;
+    maximumPendingAggregateBytes?: number;
+    rpcLimits?: Readonly<ArtifactWorkerRpcLimits>;
+    workerFactory?: (url: URL, options: {
+        type: "module";
+        name: string;
+    }) => ArtifactWorkerClientEndpoint;
+};
+export type BrowserEditableArtifactWorkerKernel = EditableArtifactWorkerKernel & {
+    queryPresentationSlideCatalog: (query: EditablePresentationSlideCatalogQuery) => Promise<EditablePresentationSlideCatalogProjection>;
+    queryPresentationEditorSlide: (query: EditablePresentationEditorSlideQuery) => Promise<EditablePresentationEditorSlideProjection>;
+    /** Requests bounded graceful cleanup, then terminates the Worker. Idempotent. */
+    dispose: () => Promise<void>;
+    /** Retires a failed generation; the next method call lazily starts a fresh Worker. */
+    restart: () => void;
+};
+export declare class ArtifactWorkerClientError extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    constructor(code: string, message: string, options?: {
+        retryable?: boolean;
+        cause?: unknown;
+    });
+}
+export declare function createBrowserEditableArtifactWorkerKernel(options: CreateBrowserEditableArtifactWorkerKernelOptions): BrowserEditableArtifactWorkerKernel;

package/dist/editable-artifacts/worker/browser-entry.d.ts

@@ -0,0 +1,6 @@
+import { ArtifactWorkerRuntime, type ArtifactWorkerRuntimeEndpoint } from "./runtime.js";
+/**
+ * Dedicated module-Worker entry. Hosts bundle and self-host this file under
+ * their CSP, then pass its URL to `createBrowserEditableArtifactWorkerKernel`.
+ */
+export declare function installBrowserArtifactWorkerEntry(scope: ArtifactWorkerRuntimeEndpoint): ArtifactWorkerRuntime;

package/dist/editable-artifacts/worker/kernel-adapter.d.ts

@@ -0,0 +1,45 @@
+import type { ArtifactWorkerInitializeInput } from "./wire-codec.js";
+import type { EditableArtifactModality } from "../types.js";
+export type ArtifactWorkerKernelSession = {
+    readonly modality: EditableArtifactModality;
+    /** Replays one exact whole canonical OGACO001 transaction. */
+    applyCommitted: (committedTransactionBytes: Uint8Array) => void;
+    /** Authors and applies one exact OGATX001 intent over the current frontier. */
+    applyPending: (intentBytes: Uint8Array) => void;
+    /** Applies one exact document/presentation command and returns its native receipt. */
+    applyCommands: (commandBytes: Uint8Array) => Uint8Array;
+    /** Native serialized-model revision; unavailable for spreadsheets. */
+    nativeRevision: () => number;
+    /** Stages an atomic candidate without serializing/reopening the model. */
+    fork: () => ArtifactWorkerKernelSession;
+    /** Kernel-defined canonical hash; never synthesized from transport bytes. */
+    stateHash: () => Promise<string>;
+    snapshot: () => Uint8Array;
+    /** Canonical bounded OGAKQ request to canonical OGAKV projection. */
+    query: (queryBytes: Uint8Array) => Uint8Array;
+    dispose: () => void;
+};
+/** A valid local intent whose structural preconditions no longer project. */
+export declare class ArtifactWorkerPendingProjectionError extends Error {
+    readonly code: string;
+    constructor(code: string, message?: string);
+}
+/** Entirely Worker-owned adapter over one compatible collaboration WASM build. */
+export type ArtifactWorkerKernelAdapter = {
+    readonly modality: EditableArtifactModality;
+    readonly protocolVersion: number;
+    readonly kernelVersion: string;
+    readonly modelSchemaVersion: number;
+    readonly commandVersion: number;
+    readonly maximumSnapshotBytes: number;
+    readonly maximumCommandBytes: number;
+    readonly maximumIntentBytes: number;
+    readonly maximumCommittedTransactionBytes: number;
+    readonly maximumQueryBytes: number;
+    readonly maximumQueryResponseBytes: number;
+    canonicalizeSnapshot: (snapshotBytes: Uint8Array) => Uint8Array;
+    open: (snapshotBytes: Uint8Array) => ArtifactWorkerKernelSession;
+    dispose?: () => void;
+};
+export type ArtifactWorkerKernelAdapterFactory = (input: ArtifactWorkerInitializeInput) => Promise<ArtifactWorkerKernelAdapter>;
+export declare const loadBrowserWasmKernelAdapter: ArtifactWorkerKernelAdapterFactory;

package/dist/editable-artifacts/worker/rpc-protocol.d.ts

@@ -0,0 +1,92 @@
+export declare const enum ArtifactWorkerRpcKind {
+    Initialize = 1,
+    Reset = 2,
+    LoadSnapshot = 3,
+    ApplyRecovered = 4,
+    ReconcileCommitted = 5,
+    ReplacePending = 6,
+    AuthorPending = 7,
+    Cancel = 8,
+    Dispose = 9,
+    QuerySpreadsheet = 10,
+    Response = 128,
+    Error = 129
+}
+export type ArtifactWorkerRpcMessage = {
+    frame: ArrayBuffer;
+    segments: ArrayBuffer[];
+};
+export type ArtifactWorkerRpcLimits = {
+    maxMetadataBytes: number;
+    maxSegmentBytes: number;
+    maxTotalSegmentBytes: number;
+    maxSegments: number;
+};
+export type DecodedArtifactWorkerRpcFrame = {
+    kind: ArtifactWorkerRpcKind;
+    generation: number;
+    requestId: number;
+    flags: number;
+    metadata: Uint8Array;
+    segments: Uint8Array[];
+};
+export declare const DEFAULT_ARTIFACT_WORKER_RPC_LIMITS: Readonly<ArtifactWorkerRpcLimits>;
+export declare class ArtifactWorkerProtocolError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare function encodeArtifactWorkerRpcMessage(input: {
+    kind: ArtifactWorkerRpcKind;
+    generation: number;
+    requestId: number;
+    flags?: number;
+    metadata?: Uint8Array;
+    /** Every buffer must already be exclusively owned by this message. */
+    segments?: ArrayBuffer[];
+    limits?: Readonly<ArtifactWorkerRpcLimits>;
+}): ArtifactWorkerRpcMessage;
+export declare function decodeArtifactWorkerRpcMessage(input: unknown, limitsInput?: Readonly<ArtifactWorkerRpcLimits>): DecodedArtifactWorkerRpcFrame;
+export declare function transferListForArtifactWorkerRpcMessage(message: ArtifactWorkerRpcMessage): Transferable[];
+/** Creates a private transferable copy; transferring never detaches caller-owned bytes. */
+export declare function ownedTransferBuffer(bytes: Uint8Array): ArrayBuffer;
+export declare class ArtifactWorkerBinaryWriter {
+    private readonly maximumBytes;
+    private readonly chunks;
+    private size;
+    constructor(maximumBytes?: number);
+    u8(value: number): this;
+    u16(value: number): this;
+    u32(value: number): this;
+    safeUint(value: number): this;
+    f64(value: number): this;
+    string(value: string, maximumBytes?: number): this;
+    optionalString(value: string | null, maximumBytes?: number): this;
+    frontier(value: readonly Readonly<{
+        replicaId: string;
+        counter: number;
+    }>[], maximumActors?: number): this;
+    finish(): Uint8Array;
+    private append;
+}
+export declare class ArtifactWorkerBinaryReader {
+    private readonly bytes;
+    private readonly view;
+    private offset;
+    constructor(bytes: Uint8Array);
+    u8(): number;
+    u16(): number;
+    u32(): number;
+    safeUint(): number;
+    f64(): number;
+    string(maximumBytes?: number): string;
+    optionalString(maximumBytes?: number): string | null;
+    frontier(maximumActors?: number): readonly Readonly<{
+        replicaId: string;
+        counter: number;
+    }>[];
+    done(): void;
+    remaining(): number;
+    private require;
+}