@opendatalabs/personal-server-ts-lite 1.34.2 → 1.35.0

package/dist/canonical-store.d.ts

@@ -0,0 +1,395 @@
+import { type ReplicaOperation } from "@opendatalabs/personal-server-ts-core/replication/envelope";
+import { type MergeContext } from "@opendatalabs/personal-server-ts-core/replication/merge-plan";
+import { type PdppRecordRow } from "@opendatalabs/personal-server-ts-core/storage/pdpp-records/portable";
+import { type CompletionOperation } from "@opendatalabs/personal-server-ts-core/replication/completion";
+import { type ReplicaReader, type ReplicaVisibilityPolicy } from "@opendatalabs/personal-server-ts-core/replication/visibility-policy";
+import { type LiteCanonicalPersistence, type LiteBlobDescriptor, type LiteStagingId } from "./canonical-persistence.js";
+/**
+ * A refusal that the batch's content or the store's immutable state decides:
+ * the same input fails the same way on every retry. A replica import that
+ * throws it stops retrying (`ReplicaCopyRefused` on the engine host).
+ */
+export declare class LiteCanonicalRefusal extends Error {
+    readonly reason: "batch_too_large" | "operation_too_large" | "wrong_owner" | "connection_binding_mismatch" | "partition_too_large" | "commit_id_reused" | "blob_metadata_conflict";
+    readonly code = "lite_canonical_refused";
+    constructor(reason: "batch_too_large" | "operation_too_large" | "wrong_owner" | "connection_binding_mismatch" | "partition_too_large" | "commit_id_reused" | "blob_metadata_conflict", message: string);
+}
+export type LiteOperationDraft = ReplicaOperation extends infer T ? T extends ReplicaOperation ? Omit<T, "revision"> : never : never;
+interface Connection {
+    sourceId: string;
+    methodId: string;
+}
+export interface LiteCommitReceipt {
+    sequence: number;
+    operationCount: number;
+}
+export interface LiteReplicaReadOptions {
+    reader?: ReplicaReader;
+}
+export type LiteVisibleRecord = PdppRecordRow;
+/** One local commit, in sequence order. It points at the retained operation. */
+interface LogEntry {
+    batchId: string;
+    operationKey: string;
+    sequence: number;
+    /** The record row's version after this operation (record operations only). */
+    rowVersion?: number;
+}
+/** The fingerprint `stagePending` and `pendingBatch` report for an envelope. */
+export declare const litePendingFingerprint: (envelope: unknown) => string;
+export declare function createLiteCanonicalStore(deps: {
+    persistence: LiteCanonicalPersistence;
+    context: () => MergeContext;
+    authenticateReplica: (credential: unknown) => string | undefined;
+    enabled?: boolean;
+    visibilityPolicy?: ReplicaVisibilityPolicy;
+    newId?: () => string;
+    /** Called after each local batch commits, so replication steps soon. */
+    localCommitted?: () => void;
+}): {
+    /** Host hook: caller authenticates/decrypts transport and verifies its hash before staging. */
+    stagePending(input: {
+        id: string;
+        envelope: unknown;
+        credential: unknown;
+        blobs?: {
+            stagingId: LiteStagingId;
+            descriptor: LiteBlobDescriptor;
+        }[];
+    }): Promise<{
+        fingerprint: string;
+        state: "confirmed" | "quarantined";
+    } | {
+        fingerprint: string;
+        state: "pending";
+    }>;
+    /** Trusted finality hook; fingerprint must come from independently verified finalized evidence. */
+    promotePending(input: {
+        id: string;
+        credential: unknown;
+        fingerprint: string;
+    }): Promise<LiteCommitReceipt>;
+    quarantinePending(input: {
+        id: string;
+        credential: unknown;
+        reason: string;
+    }): Promise<void>;
+    /** Trusted host provisioning only; never called by replica or collector input. */
+    provisionConnection(id: string, connection: Connection): Promise<void>;
+    /**
+     * Replication's writer identity (host contract §3.2): local operations
+     * from now on name `writerId`. The first time a writer binds, every
+     * unpublished local operation is dropped from the outbox and the current
+     * canonical state is re-exported under it (`reexport`), so a phone with
+     * local writes before its first enable, or after a writer rotation,
+     * still converges. Binding the writer already exported is a no-op.
+     */
+    rebaseline(writerId: string): Promise<{
+        reissued: number;
+        skipped: number;
+    } | undefined>;
+    /** A staged pending batch's state and fingerprint, if any. */
+    pendingBatch(id: string): Promise<{
+        state: "pending" | "confirmed" | "quarantined";
+        fingerprint: string;
+    } | undefined>;
+    commitLocal: (id: string, operations: LiteOperationDraft[], blobs?: {
+        stagingId: LiteStagingId;
+        descriptor: LiteBlobDescriptor;
+    }[]) => Promise<LiteCommitReceipt>;
+    import: (input: {
+        id: string;
+        envelope: unknown;
+        credential: unknown;
+        blobs?: {
+            stagingId: LiteStagingId;
+            descriptor: LiteBlobDescriptor;
+        }[];
+    }) => Promise<LiteCommitReceipt>;
+    /** True when reconcile withdraws this connection from every reader. */
+    isConnectionQuarantined(connectionId: string): Promise<boolean>;
+    /**
+     * Trusted host hook for a terminal batch (contract v3.1 A, H): record
+     * the absorbing connection-quarantine fact and withdraw the connection
+     * from every reader in the same transaction. The view revisions advance,
+     * so open page cursors expire. Rows stay retained; nothing is deleted.
+     */
+    quarantineConnection(input: {
+        credential: unknown;
+        connectionId: string;
+        reason: string;
+    }): Promise<void>;
+    /** Invoke after trusted declaration/validator changes. Continue until after is absent. */
+    retry(input: {
+        credential: unknown;
+        after?: string;
+    }): Promise<{
+        after: string | undefined;
+    }>;
+    readRecord(connection: string, stream: string, key: string, options?: LiteReplicaReadOptions): Promise<PdppRecordRow | undefined>;
+    /**
+     * The certified completions of a connection's canonical streams, by
+     * stream. A completion describes canonical rows as stored, so a reader
+     * that sees the pending preview gets none, as on Node.
+     */
+    readStreamCompletions(connection: string, options?: LiteReplicaReadOptions): Promise<CompletionOperation[]>;
+    /** Host-only current-row page. Includes tombstones; not a public query cursor. */
+    readConnectionPage(connection: string, after?: string, options?: LiteReplicaReadOptions): Promise<{
+        rows: PdppRecordRow[];
+        after: string | undefined;
+    }>;
+    /**
+     * Internal bounded page of every local commit after a sequence, including
+     * acknowledged ones. Never a public PDPP cursor or grant-relative read.
+     */
+    readLogPage(afterSequence?: number): Promise<{
+        entries: (LogEntry & {
+            operation: ReplicaOperation;
+        })[];
+        nextAfterSequence: number;
+        hasMore: boolean;
+    }>;
+    /** Local commits after `afterSequence` that are not yet acknowledged. */
+    readOutboxPage(afterSequence?: number): Promise<{
+        entries: {
+            sequence: number;
+            batchId: string;
+            operation: {
+                kind: "upsert";
+                data: Record<string, string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
+                    [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
+                } | null)[] | {
+                    [key: string]: string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null;
+                } | null)[] | {
+                    [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+                } | null)[] | {
+                    [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+                } | null)[] | {
+                    [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+                } | null)[] | {
+                    [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+                } | null)[] | {
+                    [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+                } | null)[] | {
+                    [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+                } | null)[] | {
+                    [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+                } | null)[] | {
+                    [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+                } | null)[] | {
+                    [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+                } | null)[] | {
+                    [key: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null)[] | /*elided*/ any | null;
+                } | null>;
+                blobs: {
+                    blobId: string;
+                    sha256: string;
+                    mimeType: string;
+                    sizeBytes: number;
+                }[];
+                declaration: {
+                    digest: string;
+                    version: string;
+                    stream: string;
+                    semantics: "append_only" | "mutable_state";
+                    primaryKey: string[];
+                    schemaDigest: string;
+                };
+                recordKey: string;
+                emittedAt: string;
+                owner: string;
+                sourceId: string;
+                connectionId: string;
+                methodId: string;
+                generation: number;
+                revision: {
+                    counter: number;
+                    writerId: string;
+                    operationId: string;
+                    origin?: {
+                        writerId: string;
+                        operationId: string;
+                    } | undefined;
+                };
+            } | {
+                kind: "delete";
+                deletedAt: string;
+                declaration: {
+                    digest: string;
+                    version: string;
+                    stream: string;
+                    semantics: "append_only" | "mutable_state";
+                    primaryKey: string[];
+                    schemaDigest: string;
+                };
+                recordKey: string;
+                emittedAt: string;
+                owner: string;
+                sourceId: string;
+                connectionId: string;
+                methodId: string;
+                generation: number;
+                revision: {
+                    counter: number;
+                    writerId: string;
+                    operationId: string;
+                    origin?: {
+                        writerId: string;
+                        operationId: string;
+                    } | undefined;
+                };
+            } | {
+                kind: "connection-register";
+                generation: 1;
+                owner: string;
+                sourceId: string;
+                connectionId: string;
+                methodId: string;
+                revision: {
+                    counter: number;
+                    writerId: string;
+                    operationId: string;
+                    origin?: {
+                        writerId: string;
+                        operationId: string;
+                    } | undefined;
+                };
+            } | {
+                kind: "connection-reset";
+                previousGeneration: number;
+                owner: string;
+                sourceId: string;
+                connectionId: string;
+                methodId: string;
+                generation: number;
+                revision: {
+                    counter: number;
+                    writerId: string;
+                    operationId: string;
+                    origin?: {
+                        writerId: string;
+                        operationId: string;
+                    } | undefined;
+                };
+            } | {
+                kind: "connection-delete";
+                owner: string;
+                sourceId: string;
+                connectionId: string;
+                methodId: string;
+                generation: number;
+                revision: {
+                    counter: number;
+                    writerId: string;
+                    operationId: string;
+                    origin?: {
+                        writerId: string;
+                        operationId: string;
+                    } | undefined;
+                };
+            } | {
+                kind: "blob-claim";
+                blob: {
+                    blobId: string;
+                    sha256: string;
+                    mimeType: string;
+                    sizeBytes: number;
+                };
+                owner: string;
+                sourceId: string;
+                connectionId: string;
+                methodId: string;
+                generation: number;
+                revision: {
+                    counter: number;
+                    writerId: string;
+                    operationId: string;
+                    origin?: {
+                        writerId: string;
+                        operationId: string;
+                    } | undefined;
+                };
+            } | {
+                kind: "stream-invalidate";
+                declaration: {
+                    digest: string;
+                    version: string;
+                    stream: string;
+                    semantics: "append_only" | "mutable_state";
+                    primaryKey: string[];
+                    schemaDigest: string;
+                };
+                owner: string;
+                sourceId: string;
+                connectionId: string;
+                methodId: string;
+                generation: number;
+                revision: {
+                    counter: number;
+                    writerId: string;
+                    operationId: string;
+                    origin?: {
+                        writerId: string;
+                        operationId: string;
+                    } | undefined;
+                };
+            } | {
+                kind: "stream-complete";
+                declaration: {
+                    digest: string;
+                    version: string;
+                    stream: string;
+                    semantics: "append_only" | "mutable_state";
+                    primaryKey: string[];
+                    schemaDigest: string;
+                };
+                sourceCollectedAt: string;
+                liveCount: number;
+                snapshotSha256: string;
+                proof: {
+                    kind: "native";
+                    snapshotSha256: string;
+                    collectionTimeBasis: "host_run_finished";
+                } | {
+                    kind: "producer-asserted";
+                    snapshotSha256: null;
+                    collectionTimeBasis: null;
+                };
+                dependencies: {
+                    writerId: string;
+                    operationId: string;
+                    digest: string;
+                }[];
+                owner: string;
+                sourceId: string;
+                connectionId: string;
+                methodId: string;
+                generation: number;
+                revision: {
+                    counter: number;
+                    writerId: string;
+                    operationId: string;
+                    origin?: {
+                        writerId: string;
+                        operationId: string;
+                    } | undefined;
+                };
+            };
+        }[];
+        nextAfterSequence: number;
+        hasMore: boolean;
+    }>;
+    /** Moves the outbox past `next`. The log keeps every entry. */
+    acknowledgeOutbox(expected: number, next: number): Promise<void>;
+    /**
+     * The engine published every outbox operation up to `next` and the
+     * gateway confirmed its registration: move the outbox past them. The log
+     * keeps every entry. Monotonic; a lower or repeated acknowledgment is a
+     * no-op.
+     */
+    acknowledgePublished(next: number): Promise<void>;
+    stageBlob(descriptor: LiteBlobDescriptor, chunks: AsyncIterable<Uint8Array>, signal?: AbortSignal): Promise<LiteStagingId>;
+    readBlob(blobId: string, options?: LiteReplicaReadOptions): AsyncGenerator<Uint8Array<ArrayBufferLike>, void, unknown>;
+};
+export {};
+//# sourceMappingURL=canonical-store.d.ts.map

package/dist/canonical-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical-store.d.ts","sourceRoot":"","sources":["../src/canonical-store.ts"],"names":[],"mappings":"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"}