ramosedb 0.0.1 → 0.4.0

package/dist/internal/replication/replica-gc.js

@@ -0,0 +1,91 @@
+import * as Data from "effect/Data";
+import { REPLICA_STORAGE_VERSION } from "./protocol.js";
+import { replicaPartitionDatabasePrefix } from "./replica-lifecycle.js";
+export const replicaSweepKey = (partition) => [`ramose-replica-sweep-v${REPLICA_STORAGE_VERSION}`, partition].join(":");
+export const replicaSweepPrefix = (partitionPrefix) => [`ramose-replica-sweep-v${REPLICA_STORAGE_VERSION}`, partitionPrefix].join(":");
+export class ReplicaReachability {
+    known = new Set();
+    frontier = [];
+    failed = false;
+    constructor(roots) {
+        for (const root of roots)
+            this.add(root);
+    }
+    add(hash) {
+        if (this.known.has(hash))
+            return;
+        this.known.add(hash);
+        this.frontier.push(hash);
+    }
+    next(limit) {
+        return this.frontier.splice(0, Math.max(0, limit));
+    }
+    expand(children) {
+        for (const child of children)
+            this.add(child);
+    }
+    fail() {
+        this.failed = true;
+    }
+    get pending() {
+        return this.frontier.length > 0;
+    }
+    get complete() {
+        return !this.failed && this.frontier.length === 0;
+    }
+    get reachable() {
+        return this.known;
+    }
+}
+export const unreachableNodeHashes = (stored, live) => {
+    const swept = [];
+    const seen = new Set();
+    for (const hash of stored) {
+        if (live.has(hash) || seen.has(hash))
+            continue;
+        seen.add(hash);
+        swept.push(hash);
+    }
+    return Object.freeze(swept);
+};
+export const supersededPartitions = (stored, referenced) => {
+    const confirmed = new Set();
+    for (const partition of referenced) {
+        const database = replicaPartitionDatabasePrefix(partition);
+        if (database !== undefined)
+            confirmed.add(database);
+    }
+    const superseded = new Set();
+    for (const partition of stored) {
+        if (referenced.has(partition))
+            continue;
+        const database = replicaPartitionDatabasePrefix(partition);
+        if (database !== undefined && confirmed.has(database))
+            superseded.add(partition);
+    }
+    return superseded;
+};
+export const stagingIsSweepable = (staging, committedRevision) => staging !== undefined && staging.baseRevision !== committedRevision;
+const QUOTA_CODES = new Set([
+    22,
+    1014,
+]);
+const QUOTA_NAMES = new Set([
+    "QuotaExceededError",
+    "NS_ERROR_DOM_QUOTA_REACHED",
+    "QUOTA_EXCEEDED_ERR",
+]);
+export const classifyReplicaStorageFailure = (error) => {
+    if (typeof error !== "object" || error === null)
+        return "unrelated";
+    const named = error;
+    if (typeof named.name === "string" && QUOTA_NAMES.has(named.name))
+        return "quota";
+    if (typeof named.code === "number" && QUOTA_CODES.has(named.code))
+        return "quota";
+    return "unrelated";
+};
+export const replicaQuotaRecovery = (attempt, failure) => failure !== "quota" ? "propagate" : attempt >= 2 ? "exhausted" : "reclaim";
+export class ReplicaQuotaExhaustedError extends Data.TaggedError("ReplicaQuotaExhaustedError") {
+}
+//# sourceMappingURL=replica-gc.js.map

package/dist/internal/replication/replica-gc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replica-gc.js","sourceRoot":"","sources":["../../../src/internal/replication/replica-gc.ts"],"names":[],"mappings":"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"}

package/dist/internal/replication/replica-integrity.d.ts

@@ -0,0 +1,107 @@
+import * as Result from "effect/Result";
+import type { ReadCompatibilityHash } from "../authorization/identities.ts";
+import { type Datom, type IndexId } from "../core/datom.ts";
+import type { Roots } from "../core/db.ts";
+import { type NodeRef, type TreeNode } from "../core/tree.ts";
+import { REPLICA_STORAGE_VERSION, type LogicalDatom, type ReplicationIdentity } from "./protocol.ts";
+import { type ReplicaAttributeSpec } from "./replica-schema.ts";
+export type ReplicaManifest = {
+    readonly partition: string;
+    readonly storageVersion: typeof REPLICA_STORAGE_VERSION;
+    readonly identity: ReplicationIdentity;
+    readonly readCompatibilityHash: ReadCompatibilityHash;
+    readonly revision: string;
+    readonly ordinal: number;
+    readonly datoms: readonly LogicalDatom[];
+    readonly attributes: readonly ReplicaAttributeSpec[];
+    readonly entityIds: readonly (readonly [string, number])[];
+    readonly entityHandles: readonly (readonly [string, string])[];
+    readonly attributeIds: readonly (readonly [string, number])[];
+    readonly roots: Roots;
+    readonly nextLocalId: number;
+    readonly installId?: string | undefined;
+};
+export type ReplicaCorruptionReason = "manifest-undecodable" | "manifest-invariant" | "node-missing" | "node-hash" | "node-undecodable" | "node-kind" | "node-invariant";
+export type ReplicaIncompatibilityReason = "read-compatibility" | "schema-metadata";
+export type ReplicaUnusableReason = ReplicaCorruptionReason | ReplicaIncompatibilityReason;
+export type ReplicaRecoveryAction = "replacement-required" | "update-required";
+export declare const replicaRecoveryAction: (reason: ReplicaUnusableReason) => ReplicaRecoveryAction;
+export type ReplicaIntegrityFailure = {
+    readonly reason: ReplicaCorruptionReason;
+    readonly detail: string;
+    readonly index?: IndexId;
+    readonly hash?: string;
+};
+declare const ReplicaCorruptError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ReplicaCorruptError";
+} & Readonly<A>;
+export declare class ReplicaCorruptError extends ReplicaCorruptError_base<{
+    readonly partition: string;
+    readonly reason: ReplicaUnusableReason;
+    readonly detail: string;
+}> {
+}
+declare const ReplicaSupersededError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ReplicaSupersededError";
+} & Readonly<A>;
+export declare class ReplicaSupersededError extends ReplicaSupersededError_base<{
+    readonly partition: string;
+    readonly revision: string;
+    readonly ordinal: number;
+}> {
+}
+export type ReplicaRestoreOutcome<A> = {
+    readonly _tag: "restored";
+    readonly replica: A;
+} | {
+    readonly _tag: "absent";
+} | {
+    readonly _tag: "contended";
+    readonly partition: string;
+    readonly attempts: number;
+} | {
+    readonly _tag: "replacement-required";
+    readonly partition: string;
+    readonly reason: ReplicaUnusableReason;
+    readonly detail: string;
+} | {
+    readonly _tag: "update-required";
+    readonly partition: string;
+    readonly reason: ReplicaUnusableReason;
+    readonly detail: string;
+};
+export declare const replicaRestored: <A>(replica: A) => ReplicaRestoreOutcome<A>;
+export declare const replicaAbsent: <A>() => ReplicaRestoreOutcome<A>;
+export declare const replicaContended: <A>(partition: string, attempts: number) => ReplicaRestoreOutcome<A>;
+export declare const replicaUnusable: <A>(partition: string, reason: ReplicaUnusableReason, detail: string) => ReplicaRestoreOutcome<A>;
+export declare const restoredReplica: <A>(outcome: ReplicaRestoreOutcome<A>) => A | undefined;
+export declare const replicaRefused: <A>(outcome: ReplicaRestoreOutcome<A>) => outcome is Extract<ReplicaRestoreOutcome<A>, {
+    readonly _tag: "replacement-required" | "update-required";
+}>;
+export declare const validateReplicaNodeRef: (ref: unknown, where: string, index?: IndexId) => ReplicaIntegrityFailure | undefined;
+export declare const validateReplicaRoots: (roots: unknown) => ReplicaIntegrityFailure | undefined;
+export declare const replicaManifestIdentity: (record: unknown) => ReplicationIdentity | undefined;
+export declare const replicaManifestFingerprint: (record: unknown) => string;
+export type ReplicaManifestExpectation = {
+    readonly partition: string;
+    readonly readCompatibilityHash: ReadCompatibilityHash;
+};
+export declare const validateReplicaManifest: (record: unknown, expected: ReplicaManifestExpectation) => Result.Result<ReplicaManifest, ReplicaIntegrityFailure>;
+export type ReplicaIndexDigest = {
+    datoms: number;
+    sum: number;
+    xor: number;
+    basis: number;
+};
+export declare const emptyReplicaIndexDigest: () => ReplicaIndexDigest;
+export declare const digestReplicaDatoms: (digest: ReplicaIndexDigest, datoms: readonly Datom[]) => void;
+export declare const sameReplicaIndexContents: (left: ReplicaIndexDigest, right: ReplicaIndexDigest) => boolean;
+export type ReplicaIndexDigests = Record<IndexId, ReplicaIndexDigest>;
+export declare const expectedReplicaContents: (manifest: ReplicaManifest) => Result.Result<ReplicaIndexDigests, ReplicaIntegrityFailure>;
+export declare const validateReplicaContents: (roots: Roots, walked: ReplicaIndexDigests, expected: ReplicaIndexDigests) => ReplicaIntegrityFailure | undefined;
+export declare const validateReplicaNode: (index: IndexId, ref: NodeRef, decoded: {
+    readonly index: IndexId;
+    readonly node: TreeNode;
+}, expectedKey?: Datom) => ReplicaIntegrityFailure | undefined;
+export {};
+//# sourceMappingURL=replica-integrity.d.ts.map

package/dist/internal/replication/replica-integrity.d.ts.map

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

package/dist/internal/replication/replica-integrity.js

@@ -0,0 +1,418 @@
+import * as Data from "effect/Data";
+import * as Result from "effect/Result";
+import { ENTITY_ID_PATTERN } from "../../db/refs.js";
+import { COMPARATORS, IndexName } from "../core/datom.js";
+import { FIRST_USER_EID, Schema } from "../core/schema.js";
+import { NodeKind } from "../core/tree.js";
+import { isReplicationOrdinal, REPLICA_STORAGE_VERSION, } from "./protocol.js";
+import { replicaBootstrapDatoms, replicaFactDatom, replicaSchema, } from "./replica-schema.js";
+export const replicaRecoveryAction = (reason) => reason === "read-compatibility" || reason === "schema-metadata"
+    ? "update-required"
+    : "replacement-required";
+const failure = (reason, detail, located) => Object.freeze({
+    reason,
+    detail,
+    ...(located?.index === undefined ? {} : { index: located.index }),
+    ...(located?.hash === undefined ? {} : { hash: located.hash }),
+});
+export class ReplicaCorruptError extends Data.TaggedError("ReplicaCorruptError") {
+}
+export class ReplicaSupersededError extends Data.TaggedError("ReplicaSupersededError") {
+}
+export const replicaRestored = (replica) => Object.freeze({ _tag: "restored", replica });
+export const replicaAbsent = () => Object.freeze({ _tag: "absent" });
+export const replicaContended = (partition, attempts) => Object.freeze({ _tag: "contended", partition, attempts });
+export const replicaUnusable = (partition, reason, detail) => Object.freeze({
+    _tag: replicaRecoveryAction(reason),
+    partition,
+    reason,
+    detail,
+});
+export const restoredReplica = (outcome) => outcome._tag === "restored" ? outcome.replica : undefined;
+export const replicaRefused = (outcome) => outcome._tag === "replacement-required" || outcome._tag === "update-required";
+const HEX_64 = /^[0-9a-f]{64}$/;
+const isCount = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+export const validateReplicaNodeRef = (ref, where, index) => {
+    if (!isRecord(ref))
+        return failure("manifest-undecodable", `${where} is not a node reference`, { index });
+    if (typeof ref.hash !== "string" || !HEX_64.test(ref.hash)) {
+        return failure("manifest-undecodable", `${where} has no content address`, { index });
+    }
+    if (ref.kind !== NodeKind.Leaf && ref.kind !== NodeKind.Dir) {
+        return failure("node-kind", `${where} declares an unknown node kind`, {
+            index,
+            hash: ref.hash,
+        });
+    }
+    if (!isCount(ref.count)) {
+        return failure("node-invariant", `${where} has no subtree count`, {
+            index,
+            hash: ref.hash,
+        });
+    }
+    return undefined;
+};
+export const validateReplicaRoots = (roots) => {
+    if (!isRecord(roots))
+        return failure("manifest-undecodable", "manifest has no roots");
+    if (!isCount(roots.t))
+        return failure("manifest-undecodable", "roots carry no basis");
+    for (const [name, index] of [["eavt", 0], ["aevt", 1], ["avet", 2], ["vaet", 3]]) {
+        const invalid = validateReplicaNodeRef(roots[name], `root ${name}`, index);
+        if (invalid !== undefined)
+            return invalid;
+    }
+    const counts = roots;
+    if (counts.eavt.count !== counts.aevt.count) {
+        return failure("manifest-invariant", "eavt and aevt index different datom counts");
+    }
+    for (const name of ["avet", "vaet"]) {
+        if (counts[name].count > counts.eavt.count) {
+            return failure("manifest-invariant", `${name} indexes more datoms than eavt`);
+        }
+    }
+    return undefined;
+};
+const isReplicationIdentityShape = (value) => isRecord(value) && value.version === 1 &&
+    ["server", "principal", "database", "catalog", "readView", "readCompatibilityHash",
+        "authenticator"].every((field) => typeof value[field] === "string");
+export const replicaManifestIdentity = (record) => isRecord(record) && isReplicationIdentityShape(record.identity)
+    ? record.identity
+    : undefined;
+export const replicaManifestFingerprint = (record) => {
+    const manifest = isRecord(record) ? record : {};
+    const roots = isRecord(manifest.roots) ? manifest.roots : {};
+    const size = (value) => Array.isArray(value) ? value.length : -1;
+    return JSON.stringify([
+        typeof manifest.revision === "string" ? manifest.revision : null,
+        ...["eavt", "aevt", "avet", "vaet"].map((name) => {
+            const ref = roots[name];
+            return isRecord(ref) && typeof ref.hash === "string" ? ref.hash : null;
+        }),
+        typeof manifest.installId === "string" ? manifest.installId : null,
+        typeof roots.t === "number" ? roots.t : null,
+        typeof manifest.nextLocalId === "number" ? manifest.nextLocalId : null,
+        size(manifest.datoms),
+        size(manifest.attributes),
+        size(manifest.entityIds),
+        size(manifest.attributeIds),
+    ]);
+};
+const isLogicalValue = (value) => {
+    if (!isRecord(value))
+        return false;
+    switch (value.type) {
+        case "long":
+        case "instant":
+            return typeof value.value === "number" && Number.isSafeInteger(value.value);
+        case "double":
+            return (typeof value.value === "number" && Number.isFinite(value.value)) ||
+                value.value === "positive-infinity" || value.value === "negative-infinity";
+        case "boolean":
+            return typeof value.value === "boolean";
+        case "string":
+        case "ref":
+        case "uuid":
+            return typeof value.value === "string";
+        case "bytes":
+            return typeof value.value === "string" && isCanonicalBase64(value.value);
+        default:
+            return false;
+    }
+};
+const isCanonicalBase64 = (value) => {
+    try {
+        return btoa(atob(value)) === value;
+    }
+    catch {
+        return false;
+    }
+};
+const localIds = (entries, what) => {
+    if (!Array.isArray(entries)) {
+        return Result.fail(failure("manifest-undecodable", `manifest has no ${what} map`));
+    }
+    const map = new Map();
+    const used = new Set();
+    for (const entry of entries) {
+        if (!Array.isArray(entry) || entry.length !== 2) {
+            return Result.fail(failure("manifest-undecodable", `malformed ${what} entry`));
+        }
+        const [name, id] = entry;
+        if (typeof name !== "string" || !isCount(id)) {
+            return Result.fail(failure("manifest-undecodable", `malformed ${what} entry`));
+        }
+        if (id < FIRST_USER_EID) {
+            return Result.fail(failure("manifest-invariant", `${what} ${name} is a reserved local id`));
+        }
+        if (map.has(name)) {
+            return Result.fail(failure("manifest-invariant", `duplicate ${what} ${name}`));
+        }
+        if (used.has(id)) {
+            return Result.fail(failure("manifest-invariant", `${what} ${name} reuses a local id`));
+        }
+        map.set(name, id);
+        used.add(id);
+    }
+    return Result.succeed(map);
+};
+const sealedHandles = (entries) => {
+    if (!Array.isArray(entries)) {
+        return Result.fail(failure("manifest-undecodable", "manifest has no entity handle map"));
+    }
+    const map = new Map();
+    const used = new Set();
+    for (const entry of entries) {
+        if (!Array.isArray(entry) || entry.length !== 2) {
+            return Result.fail(failure("manifest-undecodable", "malformed entity handle entry"));
+        }
+        const [identity, handle] = entry;
+        if (typeof identity !== "string" || typeof handle !== "string") {
+            return Result.fail(failure("manifest-undecodable", "malformed entity handle entry"));
+        }
+        if (!ENTITY_ID_PATTERN.test(handle)) {
+            return Result.fail(failure("manifest-undecodable", `entity handle for ${identity} is not a sealed handle`));
+        }
+        if (map.has(identity)) {
+            return Result.fail(failure("manifest-invariant", `duplicate entity handle ${identity}`));
+        }
+        if (used.has(handle)) {
+            return Result.fail(failure("manifest-invariant", `entity handle ${identity} reuses another entity's handle`));
+        }
+        map.set(identity, handle);
+        used.add(handle);
+    }
+    return Result.succeed(map);
+};
+export const validateReplicaManifest = (record, expected) => Result.gen(function* () {
+    if (!isRecord(record)) {
+        return yield* Result.fail(failure("manifest-undecodable", "manifest is not a record"));
+    }
+    if (record.storageVersion !== REPLICA_STORAGE_VERSION) {
+        return yield* Result.fail(failure("manifest-invariant", "manifest is not this storage version"));
+    }
+    if (record.partition !== expected.partition) {
+        return yield* Result.fail(failure("manifest-invariant", "manifest is stored under another partition"));
+    }
+    const identity = record.identity;
+    if (!isReplicationIdentityShape(identity) || typeof record.revision !== "string") {
+        return yield* Result.fail(failure("manifest-undecodable", "manifest has no complete identity or revision"));
+    }
+    if (!isReplicationOrdinal(record.ordinal)) {
+        return yield* Result.fail(failure("manifest-undecodable", "manifest has no visible-change ordinal"));
+    }
+    if (record.readCompatibilityHash !== identity.readCompatibilityHash ||
+        record.readCompatibilityHash !== expected.readCompatibilityHash) {
+        return yield* Result.fail(failure("manifest-invariant", "manifest does not confirm this read compatibility"));
+    }
+    if (!Array.isArray(record.datoms) || !Array.isArray(record.attributes)) {
+        return yield* Result.fail(failure("manifest-undecodable", "manifest has no datoms or attributes"));
+    }
+    const rootsInvalid = validateReplicaRoots(record.roots);
+    if (rootsInvalid !== undefined)
+        return yield* Result.fail(rootsInvalid);
+    if (!isCount(record.nextLocalId) || record.nextLocalId < FIRST_USER_EID) {
+        return yield* Result.fail(failure("manifest-invariant", "manifest has no local id allocator"));
+    }
+    const entities = yield* localIds(record.entityIds, "entity id");
+    const handles = yield* sealedHandles(record.entityHandles);
+    const attributeIds = yield* localIds(record.attributeIds, "attribute id");
+    const allocated = new Set();
+    for (const [what, ids] of [["entity", entities], ["attribute", attributeIds]]) {
+        for (const [name, id] of ids) {
+            if (id >= record.nextLocalId) {
+                return yield* Result.fail(failure("manifest-invariant", `${what} ${name} was never allocated`));
+            }
+            if (allocated.has(id)) {
+                return yield* Result.fail(failure("manifest-invariant", `${what} ${name} reuses a local id`));
+            }
+            allocated.add(id);
+        }
+    }
+    const bootstrap = Schema.bootstrap();
+    for (const spec of record.attributes) {
+        if (!isRecord(spec) || typeof spec.ident !== "string" ||
+            typeof spec.valueType !== "number" ||
+            (spec.cardinality !== "one" && spec.cardinality !== "many") ||
+            typeof spec.index !== "boolean" || typeof spec.isComponent !== "boolean" ||
+            typeof spec.optional !== "boolean" ||
+            (spec.unique !== undefined && spec.unique !== "identity" && spec.unique !== "value")) {
+            return yield* Result.fail(failure("manifest-undecodable", "malformed replica attribute"));
+        }
+        if (bootstrap.attr(spec.ident) === undefined && !attributeIds.has(spec.ident)) {
+            return yield* Result.fail(failure("manifest-invariant", `attribute ${spec.ident} has no local id`));
+        }
+    }
+    for (const datom of record.datoms) {
+        if (!isRecord(datom) || typeof datom.entity !== "string" ||
+            typeof datom.field !== "string" || datom.op !== "add" ||
+            !isLogicalValue(datom.value)) {
+            return yield* Result.fail(failure("manifest-undecodable", "malformed logical datom"));
+        }
+        if (!entities.has(datom.entity)) {
+            return yield* Result.fail(failure("manifest-invariant", `fact entity ${datom.entity} has no local id`));
+        }
+        if (!handles.has(datom.entity)) {
+            return yield* Result.fail(failure("manifest-invariant", `fact entity ${datom.entity} has no sealed handle`));
+        }
+        if (bootstrap.attr(datom.field) === undefined && !attributeIds.has(datom.field)) {
+            return yield* Result.fail(failure("manifest-invariant", `fact field ${datom.field} has no local id`));
+        }
+        if (datom.value.type === "ref") {
+            const target = datom.value.value;
+            if (!entities.has(target)) {
+                return yield* Result.fail(failure("manifest-invariant", "logical reference has no local entity"));
+            }
+            if (!handles.has(target)) {
+                return yield* Result.fail(failure("manifest-invariant", "logical reference has no sealed handle"));
+            }
+        }
+    }
+    return record;
+});
+export const emptyReplicaIndexDigest = () => ({ datoms: 0, sum: 0, xor: 0, basis: 0 });
+const FNV_PRIME = 0x01000193;
+const FNV_OFFSET = 0x811c9dc5;
+const mix = (hash, word) => Math.imul(hash ^ (word >>> 0), FNV_PRIME) >>> 0;
+const scratch = new DataView(new ArrayBuffer(8));
+const mixNumber = (hash, value) => {
+    scratch.setFloat64(0, value);
+    return mix(mix(hash, scratch.getUint32(0)), scratch.getUint32(4));
+};
+const mixString = (hash, value) => {
+    let mixed = mix(hash, value.length);
+    for (let i = 0; i < value.length; i++)
+        mixed = mix(mixed, value.charCodeAt(i));
+    return mixed;
+};
+const datomHash = (datom) => {
+    let hash = mix(mix(mix(mix(FNV_OFFSET, datom.e), datom.a), datom.t), datom.vt);
+    hash = mix(hash, datom.op ? 1 : 0);
+    const value = datom.v;
+    if (typeof value === "number")
+        return mixNumber(hash, value);
+    if (typeof value === "string")
+        return mixString(hash, value);
+    if (typeof value === "boolean")
+        return mix(hash, value ? 1 : 0);
+    let mixed = mix(hash, value.length);
+    for (let i = 0; i < value.length; i++)
+        mixed = mix(mixed, value[i]);
+    return mixed;
+};
+export const digestReplicaDatoms = (digest, datoms) => {
+    for (const datom of datoms) {
+        const hash = datomHash(datom);
+        digest.datoms++;
+        digest.sum = (digest.sum + hash) >>> 0;
+        digest.xor = (digest.xor ^ hash) >>> 0;
+        if (datom.t > digest.basis)
+            digest.basis = datom.t;
+    }
+};
+export const sameReplicaIndexContents = (left, right) => left.datoms === right.datoms && left.sum === right.sum && left.xor === right.xor &&
+    left.basis === right.basis;
+const emptyDigests = () => ({
+    0: emptyReplicaIndexDigest(),
+    1: emptyReplicaIndexDigest(),
+    2: emptyReplicaIndexDigest(),
+    3: emptyReplicaIndexDigest(),
+});
+export const expectedReplicaContents = (manifest) => {
+    const entities = new Map(manifest.entityIds);
+    const built = replicaSchema(manifest.attributes, new Map(manifest.attributeIds));
+    if (built === undefined) {
+        return Result.fail(failure("manifest-invariant", "a stored attribute has no local id"));
+    }
+    const digests = emptyDigests();
+    const fold = (datom) => {
+        digestReplicaDatoms(digests[0], [datom]);
+        digestReplicaDatoms(digests[1], [datom]);
+        if (built.schema.isAvet(datom.a))
+            digestReplicaDatoms(digests[2], [datom]);
+        if (built.schema.isVaet(datom.a))
+            digestReplicaDatoms(digests[3], [datom]);
+    };
+    try {
+        for (const datom of replicaBootstrapDatoms())
+            fold(datom);
+        for (const datom of built.datoms)
+            fold(datom);
+        for (const logical of manifest.datoms) {
+            const fact = replicaFactDatom(logical, built.schema, entities);
+            if (typeof fact === "string") {
+                return Result.fail(failure("manifest-invariant", `stored fact on ${logical.field} cannot be materialized`));
+            }
+            fold(fact);
+        }
+    }
+    catch {
+        return Result.fail(failure("manifest-undecodable", "a stored fact cannot be materialized"));
+    }
+    return Result.succeed(digests);
+};
+export const validateReplicaContents = (roots, walked, expected) => {
+    for (const index of [0, 1, 2, 3]) {
+        if (!sameReplicaIndexContents(walked[index], expected[index])) {
+            return failure("manifest-invariant", `${IndexName[index]} does not hold the datoms this manifest describes`, { index });
+        }
+    }
+    if (roots.t !== expected[0].basis) {
+        return failure("manifest-invariant", "the manifest basis is not the indexed basis");
+    }
+    return undefined;
+};
+const nodeCount = (node) => {
+    if (node.kind === NodeKind.Leaf)
+        return node.datoms.length;
+    let total = 0;
+    for (const ref of node.refs)
+        total += ref.count;
+    return total;
+};
+export const validateReplicaNode = (index, ref, decoded, expectedKey) => {
+    const located = { index, hash: ref.hash };
+    if (decoded.index !== index) {
+        return failure("node-kind", `node belongs to index ${decoded.index}, not ${IndexName[index]}`, located);
+    }
+    const node = decoded.node;
+    if (node.kind !== ref.kind)
+        return failure("node-kind", "node kind is not the referenced kind", located);
+    if (nodeCount(node) !== ref.count) {
+        return failure("node-invariant", "node does not hold the referenced datom count", located);
+    }
+    const comparator = COMPARATORS[index];
+    const smallest = node.kind === NodeKind.Leaf ? node.datoms[0] : node.keys[0];
+    if (expectedKey !== undefined) {
+        if (smallest === undefined) {
+            return failure("node-invariant", "a linked subtree holds no datoms", located);
+        }
+        if (comparator(expectedKey, smallest) !== 0) {
+            return failure("node-invariant", "directory separator is not the first datom of its subtree", located);
+        }
+    }
+    if (node.kind === NodeKind.Leaf) {
+        for (let i = 1; i < node.datoms.length; i++) {
+            if (comparator(node.datoms[i - 1], node.datoms[i]) >= 0) {
+                return failure("node-invariant", "leaf datoms are not in index order", located);
+            }
+        }
+        return undefined;
+    }
+    if (node.refs.length !== node.keys.length) {
+        return failure("node-invariant", "directory keys and children disagree", located);
+    }
+    if (node.refs.length === 0)
+        return failure("node-invariant", "directory has no children", located);
+    for (let i = 0; i < node.refs.length; i++) {
+        const invalid = validateReplicaNodeRef(node.refs[i], `child ${i}`, index);
+        if (invalid !== undefined)
+            return invalid;
+        if (i > 0 && comparator(node.keys[i - 1], node.keys[i]) >= 0) {
+            return failure("node-invariant", "directory keys are not in index order", located);
+        }
+    }
+    return undefined;
+};
+//# sourceMappingURL=replica-integrity.js.map