@opendatalabs/personal-server-ts-core 1.34.1 → 1.35.0

package/dist/replication/envelope.d.ts

@@ -0,0 +1,481 @@
+import { z } from "zod";
+export declare const declarationBindingSchema: z.ZodObject<{
+    digest: z.ZodString;
+    version: z.ZodString;
+    stream: z.ZodString;
+    semantics: z.ZodEnum<{
+        append_only: "append_only";
+        mutable_state: "mutable_state";
+    }>;
+    primaryKey: z.ZodArray<z.ZodString>;
+    schemaDigest: z.ZodString;
+}, z.core.$strict>;
+export type DeclarationBinding = z.infer<typeof declarationBindingSchema>;
+/**
+ * What a binding contributes to record identity: stream, semantics and
+ * ordered primary key. Two bindings of one source with the same shape are
+ * versions of one stream (a declaration upgrade). Their operations merge by
+ * revision, and each one validates against its own schema.
+ */
+export declare function declarationShape(binding: DeclarationBinding): string;
+type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export declare const replicaOperationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"upsert">;
+    data: z.ZodCustom<Record<string, JsonValue>, Record<string, JsonValue>>;
+    blobs: z.ZodArray<z.ZodObject<{
+        blobId: z.ZodString;
+        sha256: z.ZodString;
+        mimeType: z.ZodString;
+        sizeBytes: z.ZodNumber;
+    }, z.core.$strict>>;
+    declaration: z.ZodObject<{
+        digest: z.ZodString;
+        version: z.ZodString;
+        stream: z.ZodString;
+        semantics: z.ZodEnum<{
+            append_only: "append_only";
+            mutable_state: "mutable_state";
+        }>;
+        primaryKey: z.ZodArray<z.ZodString>;
+        schemaDigest: z.ZodString;
+    }, z.core.$strict>;
+    recordKey: z.ZodString;
+    emittedAt: z.ZodString;
+    owner: z.ZodString;
+    sourceId: z.ZodString;
+    connectionId: z.ZodString;
+    methodId: z.ZodString;
+    generation: z.ZodNumber;
+    revision: z.ZodObject<{
+        counter: z.ZodNumber;
+        writerId: z.ZodString;
+        operationId: z.ZodString;
+        origin: z.ZodOptional<z.ZodObject<{
+            writerId: z.ZodString;
+            operationId: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"delete">;
+    deletedAt: z.ZodString;
+    declaration: z.ZodObject<{
+        digest: z.ZodString;
+        version: z.ZodString;
+        stream: z.ZodString;
+        semantics: z.ZodEnum<{
+            append_only: "append_only";
+            mutable_state: "mutable_state";
+        }>;
+        primaryKey: z.ZodArray<z.ZodString>;
+        schemaDigest: z.ZodString;
+    }, z.core.$strict>;
+    recordKey: z.ZodString;
+    emittedAt: z.ZodString;
+    owner: z.ZodString;
+    sourceId: z.ZodString;
+    connectionId: z.ZodString;
+    methodId: z.ZodString;
+    generation: z.ZodNumber;
+    revision: z.ZodObject<{
+        counter: z.ZodNumber;
+        writerId: z.ZodString;
+        operationId: z.ZodString;
+        origin: z.ZodOptional<z.ZodObject<{
+            writerId: z.ZodString;
+            operationId: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"connection-register">;
+    generation: z.ZodLiteral<1>;
+    owner: z.ZodString;
+    sourceId: z.ZodString;
+    connectionId: z.ZodString;
+    methodId: z.ZodString;
+    revision: z.ZodObject<{
+        counter: z.ZodNumber;
+        writerId: z.ZodString;
+        operationId: z.ZodString;
+        origin: z.ZodOptional<z.ZodObject<{
+            writerId: z.ZodString;
+            operationId: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"connection-reset">;
+    previousGeneration: z.ZodNumber;
+    owner: z.ZodString;
+    sourceId: z.ZodString;
+    connectionId: z.ZodString;
+    methodId: z.ZodString;
+    generation: z.ZodNumber;
+    revision: z.ZodObject<{
+        counter: z.ZodNumber;
+        writerId: z.ZodString;
+        operationId: z.ZodString;
+        origin: z.ZodOptional<z.ZodObject<{
+            writerId: z.ZodString;
+            operationId: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"connection-delete">;
+    owner: z.ZodString;
+    sourceId: z.ZodString;
+    connectionId: z.ZodString;
+    methodId: z.ZodString;
+    generation: z.ZodNumber;
+    revision: z.ZodObject<{
+        counter: z.ZodNumber;
+        writerId: z.ZodString;
+        operationId: z.ZodString;
+        origin: z.ZodOptional<z.ZodObject<{
+            writerId: z.ZodString;
+            operationId: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"blob-claim">;
+    blob: z.ZodObject<{
+        blobId: z.ZodString;
+        sha256: z.ZodString;
+        mimeType: z.ZodString;
+        sizeBytes: z.ZodNumber;
+    }, z.core.$strict>;
+    owner: z.ZodString;
+    sourceId: z.ZodString;
+    connectionId: z.ZodString;
+    methodId: z.ZodString;
+    generation: z.ZodNumber;
+    revision: z.ZodObject<{
+        counter: z.ZodNumber;
+        writerId: z.ZodString;
+        operationId: z.ZodString;
+        origin: z.ZodOptional<z.ZodObject<{
+            writerId: z.ZodString;
+            operationId: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"stream-invalidate">;
+    declaration: z.ZodObject<{
+        digest: z.ZodString;
+        version: z.ZodString;
+        stream: z.ZodString;
+        semantics: z.ZodEnum<{
+            append_only: "append_only";
+            mutable_state: "mutable_state";
+        }>;
+        primaryKey: z.ZodArray<z.ZodString>;
+        schemaDigest: z.ZodString;
+    }, z.core.$strict>;
+    owner: z.ZodString;
+    sourceId: z.ZodString;
+    connectionId: z.ZodString;
+    methodId: z.ZodString;
+    generation: z.ZodNumber;
+    revision: z.ZodObject<{
+        counter: z.ZodNumber;
+        writerId: z.ZodString;
+        operationId: z.ZodString;
+        origin: z.ZodOptional<z.ZodObject<{
+            writerId: z.ZodString;
+            operationId: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"stream-complete">;
+    declaration: z.ZodObject<{
+        digest: z.ZodString;
+        version: z.ZodString;
+        stream: z.ZodString;
+        semantics: z.ZodEnum<{
+            append_only: "append_only";
+            mutable_state: "mutable_state";
+        }>;
+        primaryKey: z.ZodArray<z.ZodString>;
+        schemaDigest: z.ZodString;
+    }, z.core.$strict>;
+    sourceCollectedAt: z.ZodString;
+    liveCount: z.ZodNumber;
+    snapshotSha256: z.ZodString;
+    proof: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"native">;
+        snapshotSha256: z.ZodString;
+        collectionTimeBasis: z.ZodLiteral<"host_run_finished">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"producer-asserted">;
+        snapshotSha256: z.ZodNull;
+        collectionTimeBasis: z.ZodNull;
+    }, z.core.$strict>], "kind">;
+    dependencies: z.ZodArray<z.ZodObject<{
+        writerId: z.ZodString;
+        operationId: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>>;
+    owner: z.ZodString;
+    sourceId: z.ZodString;
+    connectionId: z.ZodString;
+    methodId: z.ZodString;
+    generation: z.ZodNumber;
+    revision: z.ZodObject<{
+        counter: z.ZodNumber;
+        writerId: z.ZodString;
+        operationId: z.ZodString;
+        origin: z.ZodOptional<z.ZodObject<{
+            writerId: z.ZodString;
+            operationId: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "kind">;
+export type ReplicaOperation = z.infer<typeof replicaOperationSchema>;
+export type RecordOperation = Extract<ReplicaOperation, {
+    kind: "upsert" | "delete";
+}>;
+export declare const replicaEnvelopeSchema: z.ZodObject<{
+    format: z.ZodLiteral<"vana-pdpp-replica">;
+    version: z.ZodLiteral<1>;
+    owner: z.ZodString;
+    batchId: z.ZodString;
+    operations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"upsert">;
+        data: z.ZodCustom<Record<string, JsonValue>, Record<string, JsonValue>>;
+        blobs: z.ZodArray<z.ZodObject<{
+            blobId: z.ZodString;
+            sha256: z.ZodString;
+            mimeType: z.ZodString;
+            sizeBytes: z.ZodNumber;
+        }, z.core.$strict>>;
+        declaration: z.ZodObject<{
+            digest: z.ZodString;
+            version: z.ZodString;
+            stream: z.ZodString;
+            semantics: z.ZodEnum<{
+                append_only: "append_only";
+                mutable_state: "mutable_state";
+            }>;
+            primaryKey: z.ZodArray<z.ZodString>;
+            schemaDigest: z.ZodString;
+        }, z.core.$strict>;
+        recordKey: z.ZodString;
+        emittedAt: z.ZodString;
+        owner: z.ZodString;
+        sourceId: z.ZodString;
+        connectionId: z.ZodString;
+        methodId: z.ZodString;
+        generation: z.ZodNumber;
+        revision: z.ZodObject<{
+            counter: z.ZodNumber;
+            writerId: z.ZodString;
+            operationId: z.ZodString;
+            origin: z.ZodOptional<z.ZodObject<{
+                writerId: z.ZodString;
+                operationId: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"delete">;
+        deletedAt: z.ZodString;
+        declaration: z.ZodObject<{
+            digest: z.ZodString;
+            version: z.ZodString;
+            stream: z.ZodString;
+            semantics: z.ZodEnum<{
+                append_only: "append_only";
+                mutable_state: "mutable_state";
+            }>;
+            primaryKey: z.ZodArray<z.ZodString>;
+            schemaDigest: z.ZodString;
+        }, z.core.$strict>;
+        recordKey: z.ZodString;
+        emittedAt: z.ZodString;
+        owner: z.ZodString;
+        sourceId: z.ZodString;
+        connectionId: z.ZodString;
+        methodId: z.ZodString;
+        generation: z.ZodNumber;
+        revision: z.ZodObject<{
+            counter: z.ZodNumber;
+            writerId: z.ZodString;
+            operationId: z.ZodString;
+            origin: z.ZodOptional<z.ZodObject<{
+                writerId: z.ZodString;
+                operationId: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"connection-register">;
+        generation: z.ZodLiteral<1>;
+        owner: z.ZodString;
+        sourceId: z.ZodString;
+        connectionId: z.ZodString;
+        methodId: z.ZodString;
+        revision: z.ZodObject<{
+            counter: z.ZodNumber;
+            writerId: z.ZodString;
+            operationId: z.ZodString;
+            origin: z.ZodOptional<z.ZodObject<{
+                writerId: z.ZodString;
+                operationId: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"connection-reset">;
+        previousGeneration: z.ZodNumber;
+        owner: z.ZodString;
+        sourceId: z.ZodString;
+        connectionId: z.ZodString;
+        methodId: z.ZodString;
+        generation: z.ZodNumber;
+        revision: z.ZodObject<{
+            counter: z.ZodNumber;
+            writerId: z.ZodString;
+            operationId: z.ZodString;
+            origin: z.ZodOptional<z.ZodObject<{
+                writerId: z.ZodString;
+                operationId: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"connection-delete">;
+        owner: z.ZodString;
+        sourceId: z.ZodString;
+        connectionId: z.ZodString;
+        methodId: z.ZodString;
+        generation: z.ZodNumber;
+        revision: z.ZodObject<{
+            counter: z.ZodNumber;
+            writerId: z.ZodString;
+            operationId: z.ZodString;
+            origin: z.ZodOptional<z.ZodObject<{
+                writerId: z.ZodString;
+                operationId: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"blob-claim">;
+        blob: z.ZodObject<{
+            blobId: z.ZodString;
+            sha256: z.ZodString;
+            mimeType: z.ZodString;
+            sizeBytes: z.ZodNumber;
+        }, z.core.$strict>;
+        owner: z.ZodString;
+        sourceId: z.ZodString;
+        connectionId: z.ZodString;
+        methodId: z.ZodString;
+        generation: z.ZodNumber;
+        revision: z.ZodObject<{
+            counter: z.ZodNumber;
+            writerId: z.ZodString;
+            operationId: z.ZodString;
+            origin: z.ZodOptional<z.ZodObject<{
+                writerId: z.ZodString;
+                operationId: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"stream-invalidate">;
+        declaration: z.ZodObject<{
+            digest: z.ZodString;
+            version: z.ZodString;
+            stream: z.ZodString;
+            semantics: z.ZodEnum<{
+                append_only: "append_only";
+                mutable_state: "mutable_state";
+            }>;
+            primaryKey: z.ZodArray<z.ZodString>;
+            schemaDigest: z.ZodString;
+        }, z.core.$strict>;
+        owner: z.ZodString;
+        sourceId: z.ZodString;
+        connectionId: z.ZodString;
+        methodId: z.ZodString;
+        generation: z.ZodNumber;
+        revision: z.ZodObject<{
+            counter: z.ZodNumber;
+            writerId: z.ZodString;
+            operationId: z.ZodString;
+            origin: z.ZodOptional<z.ZodObject<{
+                writerId: z.ZodString;
+                operationId: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"stream-complete">;
+        declaration: z.ZodObject<{
+            digest: z.ZodString;
+            version: z.ZodString;
+            stream: z.ZodString;
+            semantics: z.ZodEnum<{
+                append_only: "append_only";
+                mutable_state: "mutable_state";
+            }>;
+            primaryKey: z.ZodArray<z.ZodString>;
+            schemaDigest: z.ZodString;
+        }, z.core.$strict>;
+        sourceCollectedAt: z.ZodString;
+        liveCount: z.ZodNumber;
+        snapshotSha256: z.ZodString;
+        proof: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"native">;
+            snapshotSha256: z.ZodString;
+            collectionTimeBasis: z.ZodLiteral<"host_run_finished">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"producer-asserted">;
+            snapshotSha256: z.ZodNull;
+            collectionTimeBasis: z.ZodNull;
+        }, z.core.$strict>], "kind">;
+        dependencies: z.ZodArray<z.ZodObject<{
+            writerId: z.ZodString;
+            operationId: z.ZodString;
+            digest: z.ZodString;
+        }, z.core.$strict>>;
+        owner: z.ZodString;
+        sourceId: z.ZodString;
+        connectionId: z.ZodString;
+        methodId: z.ZodString;
+        generation: z.ZodNumber;
+        revision: z.ZodObject<{
+            counter: z.ZodNumber;
+            writerId: z.ZodString;
+            operationId: z.ZodString;
+            origin: z.ZodOptional<z.ZodObject<{
+                writerId: z.ZodString;
+                operationId: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>;
+export type ReplicaEnvelope = z.infer<typeof replicaEnvelopeSchema>;
+/** Canonical JSON for the profile, preserving every own key at every depth. */
+export declare function canonicalJson(value: unknown): string;
+/** Canonical JSON serializer shared by wire encoding and replication digests. */
+export declare function exactJson(value: unknown): string;
+export interface EnvelopeExpectation {
+    /** Established by authenticated transport, never taken from the body itself. */
+    owner: string;
+    declarations: readonly {
+        sourceId: string;
+        binding: DeclarationBinding;
+    }[];
+}
+/** Binding checks are not signature verification; authenticate/decrypt before calling. */
+export declare function decodeReplicaEnvelope(encoded: string, expected: EnvelopeExpectation): ReplicaEnvelope;
+export declare function encodeReplicaEnvelope(envelope: ReplicaEnvelope, expected: EnvelopeExpectation): string;
+/**
+ * UTF-8 bytes per stored part of long replication text (a copy's envelope,
+ * a received fragment). A phone's SQL call carries or returns about 1 MiB
+ * at most (PS-Lite `LITE_REPLICA_SQL_BYTES`), and Node batches target
+ * 32 MiB in 4 MiB fragments, so such text is kept in rows of parts.
+ */
+export declare const REPLICA_TEXT_PART_BYTES: number;
+/**
+ * `text` in order, cut into parts of at most `maxBytes` UTF-8 bytes. A
+ * cut never falls inside a surrogate pair, so each part is valid text.
+ */
+export declare function replicaTextParts(text: string, maxBytes: number): string[];
+export {};
+//# sourceMappingURL=envelope.d.ts.map

package/dist/replication/envelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope.d.ts","sourceRoot":"","sources":["../../src/replication/envelope.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,wBAAwB;;;;;;;;;;kBAOnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,kBAAkB,GAAG,MAAM,CAEpE;AAoBD,KAAK,SAAS,GACZ,IAAI,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,EAAE,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAchF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAgDjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,eAAe,GAAG,OAAO,CACnC,gBAAgB,EAChB;IAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAA;CAAE,CAC9B,CAAC;AACF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAMhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAWpE,+EAA+E;AAC/E,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEpD;AAED,iFAAiF;AACjF,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAuBhD;AAED,MAAM,WAAW,mBAAmB;IAClC,gFAAgF;IAChF,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,SAAS;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,kBAAkB,CAAA;KAAE,EAAE,CAAC;CAC5E;AAED,0FAA0F;AAC1F,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,mBAAmB,GAC5B,eAAe,CAoBjB;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,eAAe,EACzB,QAAQ,EAAE,mBAAmB,GAC5B,MAAM,CAIR;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,QAAa,CAAC;AAElD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAkBzE"}

package/dist/replication/envelope.js

@@ -0,0 +1,192 @@
+import { z } from "zod";
+const token = z.string().min(1);
+const integer = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+const digest = z.string().regex(/^sha256:[a-f0-9]{64}$/);
+export const declarationBindingSchema = z.strictObject({
+    digest,
+    version: token,
+    stream: token,
+    semantics: z.enum(["mutable_state", "append_only"]),
+    primaryKey: z.array(token).min(1),
+    schemaDigest: digest,
+});
+/**
+ * What a binding contributes to record identity: stream, semantics and
+ * ordered primary key. Two bindings of one source with the same shape are
+ * versions of one stream (a declaration upgrade). Their operations merge by
+ * revision, and each one validates against its own schema.
+ */
+export function declarationShape(binding) {
+    return canonicalJson([binding.stream, binding.semantics, binding.primaryKey]);
+}
+const base = {
+    owner: token,
+    sourceId: token,
+    connectionId: token,
+    methodId: token,
+    generation: integer.min(1),
+    revision: z.strictObject({
+        counter: integer.min(1),
+        writerId: token,
+        operationId: token,
+        origin: z.strictObject({ writerId: token, operationId: token }).optional(),
+    }),
+};
+const record = {
+    ...base,
+    declaration: declarationBindingSchema,
+    recordKey: z.string(),
+    emittedAt: token,
+};
+const jsonRecordSchema = z.custom((value) => value !== null &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    isJsonValue(value));
+const blob = z.strictObject({
+    blobId: token,
+    sha256: digest,
+    mimeType: token,
+    sizeBytes: integer,
+});
+export const replicaOperationSchema = z.discriminatedUnion("kind", [
+    z.strictObject({
+        ...record,
+        kind: z.literal("upsert"),
+        data: jsonRecordSchema,
+        blobs: z.array(blob),
+    }),
+    z.strictObject({ ...record, kind: z.literal("delete"), deletedAt: token }),
+    z.strictObject({
+        ...base,
+        kind: z.literal("connection-register"),
+        generation: z.literal(1),
+    }),
+    z.strictObject({
+        ...base,
+        kind: z.literal("connection-reset"),
+        previousGeneration: integer.min(1),
+    }),
+    z.strictObject({ ...base, kind: z.literal("connection-delete") }),
+    z.strictObject({ ...base, kind: z.literal("blob-claim"), blob }),
+    z.strictObject({
+        ...base,
+        kind: z.literal("stream-invalidate"),
+        declaration: declarationBindingSchema,
+    }),
+    z.strictObject({
+        ...base,
+        kind: z.literal("stream-complete"),
+        declaration: declarationBindingSchema,
+        sourceCollectedAt: token,
+        liveCount: integer,
+        snapshotSha256: digest,
+        proof: z.discriminatedUnion("kind", [
+            z.strictObject({
+                kind: z.literal("native"),
+                snapshotSha256: digest,
+                collectionTimeBasis: z.literal("host_run_finished"),
+            }),
+            z.strictObject({
+                kind: z.literal("producer-asserted"),
+                snapshotSha256: z.null(),
+                collectionTimeBasis: z.null(),
+            }),
+        ]),
+        dependencies: z.array(z.strictObject({ writerId: token, operationId: token, digest })),
+    }),
+]);
+export const replicaEnvelopeSchema = z.strictObject({
+    format: z.literal("vana-pdpp-replica"),
+    version: z.literal(1),
+    owner: token,
+    batchId: token,
+    operations: z.array(replicaOperationSchema).min(1),
+});
+function isJsonValue(value) {
+    try {
+        exactJson(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Canonical JSON for the profile, preserving every own key at every depth. */
+export function canonicalJson(value) {
+    return exactJson(value);
+}
+/** Canonical JSON serializer shared by wire encoding and replication digests. */
+export function exactJson(value) {
+    if (Array.isArray(value)) {
+        // `map` skips holes, which would encode `new Array(1)` as `[]`.
+        for (let index = 0; index < value.length; index++)
+            if (!Object.hasOwn(value, index))
+                throw new TypeError(`not a JSON value: array hole at ${index}`);
+        return `[${value.map(exactJson).join(",")}]`;
+    }
+    if (value !== null && typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${exactJson(record[key])}`)
+            .join(",")}}`;
+    }
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean" ||
+        (typeof value === "number" && Number.isFinite(value)))
+        return JSON.stringify(value);
+    throw new TypeError(`not a JSON value: ${typeof value}`);
+}
+/** Binding checks are not signature verification; authenticate/decrypt before calling. */
+export function decodeReplicaEnvelope(encoded, expected) {
+    const envelope = replicaEnvelopeSchema.parse(JSON.parse(encoded));
+    if (envelope.owner !== expected.owner)
+        throw new Error("wrong owner");
+    for (const operation of envelope.operations) {
+        if (operation.owner !== expected.owner)
+            throw new Error("wrong operation owner");
+        if ("declaration" in operation &&
+            !expected.declarations.some((entry) => entry.sourceId === operation.sourceId &&
+                canonicalJson(entry.binding) === canonicalJson(operation.declaration))) {
+            throw new Error("declaration binding mismatch");
+        }
+    }
+    if (canonicalJson(envelope) !== encoded)
+        throw new Error("noncanonical replica envelope");
+    return envelope;
+}
+export function encodeReplicaEnvelope(envelope, expected) {
+    return canonicalJson(decodeReplicaEnvelope(canonicalJson(envelope), expected));
+}
+/**
+ * UTF-8 bytes per stored part of long replication text (a copy's envelope,
+ * a received fragment). A phone's SQL call carries or returns about 1 MiB
+ * at most (PS-Lite `LITE_REPLICA_SQL_BYTES`), and Node batches target
+ * 32 MiB in 4 MiB fragments, so such text is kept in rows of parts.
+ */
+export const REPLICA_TEXT_PART_BYTES = 512 * 1024;
+/**
+ * `text` in order, cut into parts of at most `maxBytes` UTF-8 bytes. A
+ * cut never falls inside a surrogate pair, so each part is valid text.
+ */
+export function replicaTextParts(text, maxBytes) {
+    const parts = [];
+    let start = 0;
+    let bytes = 0;
+    for (let index = 0; index < text.length;) {
+        const code = text.codePointAt(index);
+        const units = code > 0xffff ? 2 : 1;
+        const size = code < 0x80 ? 1 : code < 0x800 ? 2 : code > 0xffff ? 4 : 3;
+        if (bytes + size > maxBytes) {
+            parts.push(text.slice(start, index));
+            start = index;
+            bytes = 0;
+        }
+        bytes += size;
+        index += units;
+    }
+    parts.push(text.slice(start));
+    return parts;
+}
+//# sourceMappingURL=envelope.js.map

package/dist/replication/envelope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelope.js","sourceRoot":"","sources":["../../src/replication/envelope.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,KAAK,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAChC,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;AAC5E,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;AACzD,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,YAAY,CAAC;IACrD,MAAM;IACN,OAAO,EAAE,KAAK;IACd,MAAM,EAAE,KAAK;IACb,SAAS,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC;IACnD,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACjC,YAAY,EAAE,MAAM;CACrB,CAAC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,OAA2B;IAC1D,OAAO,aAAa,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;AAChF,CAAC;AACD,MAAM,IAAI,GAAG;IACX,KAAK,EAAE,KAAK;IACZ,QAAQ,EAAE,KAAK;IACf,YAAY,EAAE,KAAK;IACnB,QAAQ,EAAE,KAAK;IACf,UAAU,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;IAC1B,QAAQ,EAAE,CAAC,CAAC,YAAY,CAAC;QACvB,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;QACvB,QAAQ,EAAE,KAAK;QACf,WAAW,EAAE,KAAK;QAClB,MAAM,EAAE,CAAC,CAAC,YAAY,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC,QAAQ,EAAE;KAC3E,CAAC;CACH,CAAC;AACF,MAAM,MAAM,GAAG;IACb,GAAG,IAAI;IACP,WAAW,EAAE,wBAAwB;IACrC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;IACrB,SAAS,EAAE,KAAK;CACjB,CAAC;AAGF,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAC/B,CAAC,KAAK,EAAE,EAAE,CACR,KAAK,KAAK,IAAI;IACd,OAAO,KAAK,KAAK,QAAQ;IACzB,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;IACrB,WAAW,CAAC,KAAK,CAAC,CACrB,CAAC;AACF,MAAM,IAAI,GAAG,CAAC,CAAC,YAAY,CAAC;IAC1B,MAAM,EAAE,KAAK;IACb,MAAM,EAAE,MAAM;IACd,QAAQ,EAAE,KAAK;IACf,SAAS,EAAE,OAAO;CACnB,CAAC,CAAC;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,kBAAkB,CAAC,MAAM,EAAE;IACjE,CAAC,CAAC,YAAY,CAAC;QACb,GAAG,MAAM;QACT,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC;QACzB,IAAI,EAAE,gBAAgB;QACtB,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC;KACrB,CAAC;IACF,CAAC,CAAC,YAAY,CAAC,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;IAC1E,CAAC,CAAC,YAAY,CAAC;QACb,GAAG,IAAI;QACP,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,qBAAqB,CAAC;QACtC,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;KACzB,CAAC;IACF,CAAC,CAAC,YAAY,CAAC;QACb,GAAG,IAAI;QACP,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,kBAAkB,CAAC;QACnC,kBAAkB,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;KACnC,CAAC;IACF,CAAC,CAAC,YAAY,CAAC,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,mBAAmB,CAAC,EAAE,CAAC;IACjE,CAAC,CAAC,YAAY,CAAC,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC;IAChE,CAAC,CAAC,YAAY,CAAC;QACb,GAAG,IAAI;QACP,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,mBAAmB,CAAC;QACpC,WAAW,EAAE,wBAAwB;KACtC,CAAC;IACF,CAAC,CAAC,YAAY,CAAC;QACb,GAAG,IAAI;QACP,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC;QAClC,WAAW,EAAE,wBAAwB;QACrC,iBAAiB,EAAE,KAAK;QACxB,SAAS,EAAE,OAAO;QAClB,cAAc,EAAE,MAAM;QACtB,KAAK,EAAE,CAAC,CAAC,kBAAkB,CAAC,MAAM,EAAE;YAClC,CAAC,CAAC,YAAY,CAAC;gBACb,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC;gBACzB,cAAc,EAAE,MAAM;gBACtB,mBAAmB,EAAE,CAAC,CAAC,OAAO,CAAC,mBAAmB,CAAC;aACpD,CAAC;YACF,CAAC,CAAC,YAAY,CAAC;gBACb,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,mBAAmB,CAAC;gBACpC,cAAc,EAAE,CAAC,CAAC,IAAI,EAAE;gBACxB,mBAAmB,EAAE,CAAC,CAAC,IAAI,EAAE;aAC9B,CAAC;SACH,CAAC;QACF,YAAY,EAAE,CAAC,CAAC,KAAK,CACnB,CAAC,CAAC,YAAY,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAChE;KACF,CAAC;CACH,CAAC,CAAC;AAMH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,YAAY,CAAC;IAClD,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,mBAAmB,CAAC;IACtC,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;IACrB,KAAK,EAAE,KAAK;IACZ,OAAO,EAAE,KAAK;IACd,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,sBAAsB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;CACnD,CAAC,CAAC;AAGH,SAAS,WAAW,CAAC,KAAc;IACjC,IAAI,CAAC;QACH,SAAS,CAAC,KAAK,CAAC,CAAC;QACjB,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,+EAA+E;AAC/E,MAAM,UAAU,aAAa,CAAC,KAAc;IAC1C,OAAO,SAAS,CAAC,KAAK,CAAC,CAAC;AAC1B,CAAC;AAED,iFAAiF;AACjF,MAAM,UAAU,SAAS,CAAC,KAAc;IACtC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,gEAAgE;QAChE,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE;YAC/C,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC;gBAC9B,MAAM,IAAI,SAAS,CAAC,mCAAmC,KAAK,EAAE,CAAC,CAAC;QACpE,OAAO,IAAI,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;IAC/C,CAAC;IACD,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAChD,MAAM,MAAM,GAAG,KAAgC,CAAC;QAChD,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;aAC3B,IAAI,EAAE;aACN,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;aAChE,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;IAClB,CAAC;IACD,IACE,KAAK,KAAK,IAAI;QACd,OAAO,KAAK,KAAK,QAAQ;QACzB,OAAO,KAAK,KAAK,SAAS;QAC1B,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAErD,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAC/B,MAAM,IAAI,SAAS,CAAC,qBAAqB,OAAO,KAAK,EAAE,CAAC,CAAC;AAC3D,CAAC;AAQD,0FAA0F;AAC1F,MAAM,UAAU,qBAAqB,CACnC,OAAe,EACf,QAA6B;IAE7B,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;IAClE,IAAI,QAAQ,CAAC,KAAK,KAAK,QAAQ,CAAC,KAAK;QAAE,MAAM,IAAI,KAAK,CAAC,aAAa,CAAC,CAAC;IACtE,KAAK,MAAM,SAAS,IAAI,QAAQ,CAAC,UAAU,EAAE,CAAC;QAC5C,IAAI,SAAS,CAAC,KAAK,KAAK,QAAQ,CAAC,KAAK;YACpC,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;QAC3C,IACE,aAAa,IAAI,SAAS;YAC1B,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CACzB,CAAC,KAAK,EAAE,EAAE,CACR,KAAK,CAAC,QAAQ,KAAK,SAAS,CAAC,QAAQ;gBACrC,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,aAAa,CAAC,SAAS,CAAC,WAAW,CAAC,CACxE,EACD,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;IACD,IAAI,aAAa,CAAC,QAAQ,CAAC,KAAK,OAAO;QACrC,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;IACnD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,MAAM,UAAU,qBAAqB,CACnC,QAAyB,EACzB,QAA6B;IAE7B,OAAO,aAAa,CAClB,qBAAqB,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,CACzD,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,GAAG,GAAG,IAAI,CAAC;AAElD;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY,EAAE,QAAgB;IAC7D,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC;QACzC,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAE,CAAC;QACtC,MAAM,KAAK,GAAG,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACpC,MAAM,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACxE,IAAI,KAAK,GAAG,IAAI,GAAG,QAAQ,EAAE,CAAC;YAC5B,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;YACrC,KAAK,GAAG,KAAK,CAAC;YACd,KAAK,GAAG,CAAC,CAAC;QACZ,CAAC;QACD,KAAK,IAAI,IAAI,CAAC;QACd,KAAK,IAAI,KAAK,CAAC;IACjB,CAAC;IACD,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;IAC9B,OAAO,KAAK,CAAC;AACf,CAAC"}