@minnowdb/core 0.0.1 → 0.1.0

package/dist/storage/types.js

@@ -0,0 +1,1549 @@
+export const storeNames = [
+    "catalog",
+    "manifests",
+    "segments",
+    "blocks",
+    "transactions",
+    "leases",
+    "statistics",
+    "temp",
+    "gc",
+];
+/** Every this-many commits the store writes a full checkpoint instead of a delta. */
+export const MANIFEST_CHECKPOINT_INTERVAL = 32;
+/** Applies one stored record to a running block set (checkpoint replaces, delta mutates). */
+export function applyManifestRecord(blockIds, record) {
+    if (record.blockIds !== undefined) {
+        blockIds.clear();
+        for (const id of record.blockIds)
+            blockIds.add(id);
+        return;
+    }
+    for (const id of record.removedBlockIds ?? [])
+        blockIds.delete(id);
+    for (const id of record.addedBlockIds ?? [])
+        blockIds.add(id);
+}
+export const simpleDataTypes = ["boolean", "number", "string", "datetime"];
+/**
+ * The single authority on which enum declarations are legal, shared by the schema DSL's
+ * `column.enum()` and the engine's `createTable`: at least one value, every value a non-empty
+ * string, no duplicates. Returns a defensive copy.
+ */
+export function validateEnumValues(values, context) {
+    if (values.length === 0) {
+        throw new TypeError(`An enum needs at least one value: ${context}`);
+    }
+    const seen = new Set();
+    for (const value of values) {
+        if (typeof value !== "string" || value.length === 0) {
+            throw new TypeError(`Enum values must be non-empty strings: ${context}`);
+        }
+        if (seen.has(value)) {
+            throw new TypeError(`Duplicate enum value: ${context} has "${value}" twice`);
+        }
+        seen.add(value);
+    }
+    return [...values];
+}
+/**
+ * The single authority on which default declarations are legal, shared by the schema DSL's
+ * `table()` and the engine's `createTable` so the two entry points (and the wire path between
+ * them) can never drift: defaults require non-nullable columns, "now" is datetime-only,
+ * auto-increment is the number unique key, and the unique key never defaults to a constant.
+ */
+export function validateColumnDefault(column, defaultValue) {
+    if (column.nullable) {
+        throw new TypeError(`Defaults require a non-nullable column: ${column.name}`);
+    }
+    switch (defaultValue.kind) {
+        case "now":
+            if (column.type !== "datetime") {
+                throw new TypeError(`Default now requires a datetime column: ${column.name}`);
+            }
+            return;
+        case "autoincrement":
+            if (column.type !== "number") {
+                throw new TypeError(`Auto-increment requires a number column: ${column.name}`);
+            }
+            if (!column.isUniqueKey) {
+                throw new TypeError(`Auto-increment requires the unique key column: ${column.name}`);
+            }
+            return;
+        case "literal": {
+            const value = defaultValue.value;
+            if (column.type === "datetime") {
+                throw new TypeError(`Datetime columns default with now, not a literal: ${column.name}`);
+            }
+            if (typeof value !== column.type) {
+                throw new TypeError(`Default literal must be a ${column.type}: ${column.name}`);
+            }
+            if (typeof value === "number" && !Number.isFinite(value)) {
+                throw new TypeError(`Default literal must be finite: ${column.name}`);
+            }
+            if (column.enumValues !== undefined &&
+                typeof value === "string" &&
+                !column.enumValues.includes(value)) {
+                throw new TypeError(`Default must be one of the enum values: ${column.name}`);
+            }
+            if (column.isUniqueKey) {
+                throw new TypeError(`Unique key cannot default to a constant: ${column.name}`);
+            }
+            return;
+        }
+        // The wire path can hand this untyped data (including specs from removed generator kinds).
+        default:
+            throw new TypeError(`Unknown default kind: ${String(defaultValue.kind)}`);
+    }
+}
+export class TableRecordConflictError extends Error {
+    tableId;
+    expectedRevision;
+    actualRevision;
+    name = "TableRecordConflictError";
+    constructor(tableId, expectedRevision, actualRevision) {
+        super(`Table ${tableId} changed: expected revision ${String(expectedRevision)}, found ${String(actualRevision)}`);
+        this.tableId = tableId;
+        this.expectedRevision = expectedRevision;
+        this.actualRevision = actualRevision;
+    }
+}
+export const compactionJobStates = [
+    "planned",
+    "running",
+    "ready",
+    "published",
+    "cancelled",
+    "aborted",
+];
+export const compactionRewritePlanKinds = ["copy-v1", "rechunk-v1", "merge-v1"];
+export const compactionOutputCompressions = ["raw", "gzip"];
+export class CompactionJobConflictError extends Error {
+    jobId;
+    expectedRevision;
+    actualRevision;
+    name = "CompactionJobConflictError";
+    constructor(jobId, expectedRevision, actualRevision) {
+        super(`Compaction job ${jobId} changed: expected revision ${String(expectedRevision)}, found ${String(actualRevision)}`);
+        this.jobId = jobId;
+        this.expectedRevision = expectedRevision;
+        this.actualRevision = actualRevision;
+    }
+}
+export const garbageCollectionJobStates = ["planned", "running", "completed"];
+export class GarbageCollectionJobConflictError extends Error {
+    jobId;
+    expectedRevision;
+    actualRevision;
+    name = "GarbageCollectionJobConflictError";
+    constructor(jobId, expectedRevision, actualRevision) {
+        super(`Garbage collection job ${jobId} changed: expected revision ${String(expectedRevision)}, found ${String(actualRevision)}`);
+        this.jobId = jobId;
+        this.expectedRevision = expectedRevision;
+        this.actualRevision = actualRevision;
+    }
+}
+export class SnapshotManifestMissingError extends Error {
+    version;
+    name = "SnapshotManifestMissingError";
+    constructor(version) {
+        super(`Snapshot manifest is unavailable: ${String(version)}`);
+        this.version = version;
+    }
+}
+export class LeaseConflictError extends Error {
+    leaseId;
+    expectedRevision;
+    actualRevision;
+    name = "LeaseConflictError";
+    constructor(leaseId, expectedRevision, actualRevision) {
+        super(`Lease ${leaseId} changed: expected revision ${String(expectedRevision)}, found ${String(actualRevision)}`);
+        this.leaseId = leaseId;
+        this.expectedRevision = expectedRevision;
+        this.actualRevision = actualRevision;
+    }
+}
+/**
+ * Shared candidate-merge core for both stores: fetching chunks is store-specific, but the
+ * term-match rule (exact, or prefix as a term range) and the sorted-unique row-id shape must
+ * never drift between backends — pruning would silently differ per store.
+ */
+export function collectFtsCandidates(chunkLists, terms) {
+    const sets = terms.map(() => new Set());
+    for (const postings of chunkLists) {
+        for (const posting of postings) {
+            for (let index = 0; index < terms.length; index += 1) {
+                const term = terms[index];
+                if (term === undefined)
+                    continue;
+                const matches = term.prefix
+                    ? posting.term.startsWith(term.term)
+                    : posting.term === term.term;
+                if (!matches)
+                    continue;
+                const set = sets[index];
+                if (set !== undefined)
+                    for (const rowId of posting.rowIds)
+                        set.add(rowId);
+            }
+        }
+    }
+    return {
+        rowIdsByTerm: sets.map((set) => [...set].sort((left, right) => (left < right ? -1 : left > right ? 1 : 0))),
+    };
+}
+/**
+ * Shared stale-writer policy for both stores' commit steps: a commit that adds segments to a
+ * table with active full-text columns but no covering delta flips the uncovered columns to
+ * "invalid" (the index self-heals through a rebuild; the data commit itself always proceeds).
+ * Returns the updated record, or undefined when nothing changes.
+ */
+export function invalidateUncoveredFtsColumns(record, coveredColumnIds) {
+    const ftsColumns = record.ftsColumns;
+    if (ftsColumns === undefined)
+        return undefined;
+    let invalidated = false;
+    const next = {};
+    for (const [columnId, state] of Object.entries(ftsColumns)) {
+        if (state.state !== "invalid" && !coveredColumnIds.has(columnId)) {
+            next[columnId] = { ...state, state: "invalid" };
+            invalidated = true;
+        }
+        else {
+            next[columnId] = { ...state };
+        }
+    }
+    if (!invalidated)
+        return undefined;
+    return { ...record, ftsColumns: next, revision: (record.revision ?? 0) + 1 };
+}
+export class UniqueKeyConflictError extends Error {
+    tableId;
+    keyToken;
+    name = "UniqueKeyConflictError";
+    constructor(tableId, keyToken) {
+        super(`Unique key already exists in table ${tableId}`);
+        this.tableId = tableId;
+        this.keyToken = keyToken;
+    }
+}
+export class WriteConflictError extends Error {
+    expectedVersion;
+    actualVersion;
+    name = "WriteConflictError";
+    constructor(expectedVersion, actualVersion) {
+        super(`Manifest changed: expected ${String(expectedVersion)}, found ${String(actualVersion)}`);
+        this.expectedVersion = expectedVersion;
+        this.actualVersion = actualVersion;
+    }
+}
+export class TransactionRecordConflictError extends Error {
+    transactionId;
+    expectedRevision;
+    actualRevision;
+    name = "TransactionRecordConflictError";
+    constructor(transactionId, expectedRevision, actualRevision) {
+        super(`Transaction ${transactionId} changed: expected revision ${String(expectedRevision)}, found ${String(actualRevision)}`);
+        this.transactionId = transactionId;
+        this.expectedRevision = expectedRevision;
+        this.actualRevision = actualRevision;
+    }
+}
+export class TempOwnerConflictError extends Error {
+    ownerId;
+    expectedRevision;
+    actualRevision;
+    name = "TempOwnerConflictError";
+    constructor(ownerId, expectedRevision, actualRevision) {
+        super(`Temp owner ${ownerId} changed: expected revision ${String(expectedRevision)}, found ${String(actualRevision)}`);
+        this.ownerId = ownerId;
+        this.expectedRevision = expectedRevision;
+        this.actualRevision = actualRevision;
+    }
+}
+export function createManifest(input) {
+    return {
+        version: input.expectedVersion === null ? 0 : input.expectedVersion + 1,
+        previousVersion: input.expectedVersion,
+        blockIds: [...new Set(input.blockIds)].sort(),
+        createdAt: input.createdAt ?? new Date().toISOString(),
+        ...(input.changedTableIds === undefined ? {} : { changedTableIds: [...input.changedTableIds] }),
+    };
+}
+/**
+ * Normalizes the additive L2 partition metadata while preserving legacy segment records verbatim.
+ */
+export function normalizeSegmentRecord(record) {
+    if (record.partitionOrdinal === undefined)
+        return structuredClone(record);
+    const partitionOrdinal = nonNegativeWholeNumber(record.partitionOrdinal, "Segment partition ordinal");
+    if (record.level !== 2) {
+        throw new TypeError("A partitioned segment must have explicit level two");
+    }
+    const kind = record.kind ?? "insert";
+    if (kind !== "insert" && kind !== "base") {
+        throw new TypeError("A partitioned segment must be an insert or a merged base");
+    }
+    if (record.logicalOrder === undefined) {
+        throw new TypeError("A partitioned segment requires an explicit logical order");
+    }
+    nonNegativeWholeNumber(record.logicalOrder, "Segment logical order");
+    const rowCount = positiveWholeNumber(record.rowCount, "Segment row count");
+    if (kind === "insert") {
+        // Append-row-range partition: one contiguous positive row-ID interval, no spans.
+        if (record.rowIdSpans !== undefined) {
+            throw new TypeError("A partitioned segment cannot contain row ID spans");
+        }
+        if (typeof record.rowIdStart !== "bigint" || record.rowIdStart <= 0n) {
+            throw new RangeError("Segment row ID start must be a positive bigint");
+        }
+        if (typeof record.rowIdEndExclusive !== "bigint" ||
+            record.rowIdEndExclusive !== record.rowIdStart + BigInt(rowCount)) {
+            throw new RangeError("A partitioned segment must have a contiguous positive row ID envelope");
+        }
+        return structuredClone({ ...record, partitionOrdinal });
+    }
+    // Keyed multi-range partition: a merged full-row base whose live rows keep their original
+    // ids, described by positive, sorted, non-overlapping spans that sum to the row count.
+    if (record.rowIdSpans === undefined || record.rowIdSpans.length === 0) {
+        throw new TypeError("A merged partitioned segment requires row ID spans");
+    }
+    let spanRows = 0;
+    let previousEnd = 0n;
+    for (const span of record.rowIdSpans) {
+        if (typeof span.rowIdStart !== "bigint" ||
+            span.rowIdStart <= 0n ||
+            !Number.isSafeInteger(span.rowCount) ||
+            span.rowCount <= 0) {
+            throw new RangeError("A partitioned segment span must be a positive non-empty interval");
+        }
+        if (span.rowIdStart < previousEnd) {
+            throw new RangeError("Partitioned segment spans must be sorted and non-overlapping");
+        }
+        previousEnd = span.rowIdStart + BigInt(span.rowCount);
+        spanRows += span.rowCount;
+    }
+    if (spanRows !== rowCount) {
+        throw new RangeError("Partitioned segment spans must cover exactly the row count");
+    }
+    return structuredClone({ ...record, partitionOrdinal });
+}
+export function updateTransactionRecord(record, update) {
+    return {
+        ...record,
+        ...(update.snapshotVersion === undefined ? {} : { snapshotVersion: update.snapshotVersion }),
+        ...(update.pendingBlockIds === undefined
+            ? {}
+            : { pendingBlockIds: [...new Set(update.pendingBlockIds)].sort() }),
+        ...(update.pendingSegmentIds === undefined
+            ? {}
+            : { pendingSegmentIds: [...new Set(update.pendingSegmentIds)].sort() }),
+        ...(update.status === undefined ? {} : { status: update.status }),
+        ...(update.committedVersion === undefined ? {} : { committedVersion: update.committedVersion }),
+        updatedAt: update.updatedAt,
+        revision: record.revision + 1,
+    };
+}
+export function createGarbageCollectionJobRecord(input) {
+    const candidateManifestVersions = uniqueWholeNumbers(input.candidateManifestVersions, "Garbage collection candidate manifest version");
+    const candidateSegmentIds = uniqueIds(input.candidateSegmentIds, "Garbage collection candidate segment ID", true);
+    const candidateBlockIds = uniqueIds(input.candidateBlockIds, "Garbage collection candidate block ID", true);
+    const createdAt = validTimestamp(input.createdAt, "Garbage collection creation timestamp");
+    const complete = candidateManifestVersions.length === 0 &&
+        candidateSegmentIds.length === 0 &&
+        candidateBlockIds.length === 0;
+    return {
+        id: nonEmptyString(input.id, "Garbage collection job ID"),
+        candidateManifestVersions,
+        candidateSegmentIds,
+        candidateBlockIds,
+        cursor: { manifestIndex: 0, segmentIndex: 0, blockIndex: 0 },
+        prunedManifestCount: 0,
+        alreadyPrunedManifestCount: 0,
+        retainedManifestCount: 0,
+        missingManifestCount: 0,
+        reclaimedSegmentCount: 0,
+        retainedSegmentCount: 0,
+        missingSegmentCount: 0,
+        reclaimedBlockCount: 0,
+        retainedBlockCount: 0,
+        missingBlockCount: 0,
+        reclaimedBlockBytes: 0,
+        state: complete ? "completed" : "planned",
+        revision: 0,
+        leaseCutoff: validTimestamp(input.leaseCutoff, "Garbage collection lease cutoff"),
+        createdAt,
+        updatedAt: createdAt,
+    };
+}
+export function normalizeGarbageCollectionJobRecord(record) {
+    const candidateManifestVersions = uniqueWholeNumbers(record.candidateManifestVersions, "Garbage collection candidate manifest version");
+    const candidateSegmentIds = uniqueIds(record.candidateSegmentIds, "Garbage collection candidate segment ID", true);
+    const candidateBlockIds = uniqueIds(record.candidateBlockIds, "Garbage collection candidate block ID", true);
+    const cursor = normalizeGarbageCollectionCursor(record.cursor);
+    const normalized = {
+        ...record,
+        id: nonEmptyString(record.id, "Garbage collection job ID"),
+        candidateManifestVersions,
+        candidateSegmentIds,
+        candidateBlockIds,
+        cursor,
+        prunedManifestCount: nonNegativeWholeNumber(record.prunedManifestCount, "Garbage collection pruned manifest count"),
+        alreadyPrunedManifestCount: nonNegativeWholeNumber(record.alreadyPrunedManifestCount, "Garbage collection already-pruned manifest count"),
+        retainedManifestCount: nonNegativeWholeNumber(record.retainedManifestCount, "Garbage collection retained manifest count"),
+        missingManifestCount: nonNegativeWholeNumber(record.missingManifestCount, "Garbage collection missing manifest count"),
+        reclaimedSegmentCount: nonNegativeWholeNumber(record.reclaimedSegmentCount, "Garbage collection reclaimed segment count"),
+        retainedSegmentCount: nonNegativeWholeNumber(record.retainedSegmentCount, "Garbage collection retained segment count"),
+        missingSegmentCount: nonNegativeWholeNumber(record.missingSegmentCount, "Garbage collection missing segment count"),
+        reclaimedBlockCount: nonNegativeWholeNumber(record.reclaimedBlockCount, "Garbage collection reclaimed block count"),
+        retainedBlockCount: nonNegativeWholeNumber(record.retainedBlockCount, "Garbage collection retained block count"),
+        missingBlockCount: nonNegativeWholeNumber(record.missingBlockCount, "Garbage collection missing block count"),
+        reclaimedBlockBytes: nonNegativeWholeNumber(record.reclaimedBlockBytes, "Garbage collection reclaimed block bytes"),
+        state: garbageCollectionJobState(record.state),
+        revision: nonNegativeWholeNumber(record.revision, "Garbage collection job revision"),
+        leaseCutoff: validTimestamp(record.leaseCutoff, "Garbage collection lease cutoff"),
+        createdAt: validTimestamp(record.createdAt, "Garbage collection creation timestamp"),
+        updatedAt: validTimestamp(record.updatedAt, "Garbage collection update timestamp"),
+    };
+    if (safeSum([
+        normalized.prunedManifestCount,
+        normalized.alreadyPrunedManifestCount,
+        normalized.retainedManifestCount,
+        normalized.missingManifestCount,
+    ], "Garbage collection examined manifest count") !== cursor.manifestIndex ||
+        safeSum([
+            normalized.reclaimedSegmentCount,
+            normalized.retainedSegmentCount,
+            normalized.missingSegmentCount,
+        ], "Garbage collection examined segment count") !== cursor.segmentIndex ||
+        safeSum([normalized.reclaimedBlockCount, normalized.retainedBlockCount, normalized.missingBlockCount], "Garbage collection examined block count") !== cursor.blockIndex) {
+        throw new TypeError("Garbage collection cursor does not match its persisted accounting");
+    }
+    if (cursor.manifestIndex > candidateManifestVersions.length ||
+        cursor.segmentIndex > candidateSegmentIds.length ||
+        cursor.blockIndex > candidateBlockIds.length) {
+        throw new RangeError("Garbage collection cursor is outside its candidate selection");
+    }
+    const complete = garbageCollectionJobComplete(normalized);
+    if ((normalized.state === "completed") !== complete) {
+        throw new TypeError(complete
+            ? "A finished garbage collection cursor requires completed state"
+            : "A completed garbage collection job requires a finished cursor");
+    }
+    if (normalized.state === "planned" &&
+        (cursor.manifestIndex !== 0 || cursor.segmentIndex !== 0 || cursor.blockIndex !== 0)) {
+        throw new TypeError("A planned garbage collection job cannot contain progress");
+    }
+    return structuredClone(normalized);
+}
+export function advanceGarbageCollectionJobRecord(record, accounting) {
+    const current = normalizeGarbageCollectionJobRecord(record);
+    if (current.state === "completed")
+        return current;
+    const increments = {
+        examinedManifestCount: nonNegativeWholeNumber(accounting.examinedManifestCount, "Garbage collection examined manifest increment"),
+        prunedManifestCount: nonNegativeWholeNumber(accounting.prunedManifestCount, "Garbage collection pruned manifest increment"),
+        alreadyPrunedManifestCount: nonNegativeWholeNumber(accounting.alreadyPrunedManifestCount, "Garbage collection already-pruned manifest increment"),
+        retainedManifestCount: nonNegativeWholeNumber(accounting.retainedManifestCount, "Garbage collection retained manifest increment"),
+        missingManifestCount: nonNegativeWholeNumber(accounting.missingManifestCount, "Garbage collection missing manifest increment"),
+        examinedSegmentCount: nonNegativeWholeNumber(accounting.examinedSegmentCount, "Garbage collection examined segment increment"),
+        reclaimedSegmentCount: nonNegativeWholeNumber(accounting.reclaimedSegmentCount, "Garbage collection reclaimed segment increment"),
+        retainedSegmentCount: nonNegativeWholeNumber(accounting.retainedSegmentCount, "Garbage collection retained segment increment"),
+        missingSegmentCount: nonNegativeWholeNumber(accounting.missingSegmentCount, "Garbage collection missing segment increment"),
+        examinedBlockCount: nonNegativeWholeNumber(accounting.examinedBlockCount, "Garbage collection examined block increment"),
+        reclaimedBlockCount: nonNegativeWholeNumber(accounting.reclaimedBlockCount, "Garbage collection reclaimed block increment"),
+        retainedBlockCount: nonNegativeWholeNumber(accounting.retainedBlockCount, "Garbage collection retained block increment"),
+        missingBlockCount: nonNegativeWholeNumber(accounting.missingBlockCount, "Garbage collection missing block increment"),
+        reclaimedBlockBytes: nonNegativeWholeNumber(accounting.reclaimedBlockBytes, "Garbage collection reclaimed block byte increment"),
+    };
+    if (increments.examinedManifestCount !==
+        safeSum([
+            increments.prunedManifestCount,
+            increments.alreadyPrunedManifestCount,
+            increments.retainedManifestCount,
+            increments.missingManifestCount,
+        ], "Garbage collection manifest increment") ||
+        increments.examinedSegmentCount !==
+            safeSum([
+                increments.reclaimedSegmentCount,
+                increments.retainedSegmentCount,
+                increments.missingSegmentCount,
+            ], "Garbage collection segment increment") ||
+        increments.examinedBlockCount !==
+            safeSum([
+                increments.reclaimedBlockCount,
+                increments.retainedBlockCount,
+                increments.missingBlockCount,
+            ], "Garbage collection block increment")) {
+        throw new TypeError("Garbage collection step accounting is incomplete");
+    }
+    const cursor = {
+        manifestIndex: safeSum([current.cursor.manifestIndex, increments.examinedManifestCount], "Garbage collection manifest cursor"),
+        segmentIndex: safeSum([current.cursor.segmentIndex, increments.examinedSegmentCount], "Garbage collection segment cursor"),
+        blockIndex: safeSum([current.cursor.blockIndex, increments.examinedBlockCount], "Garbage collection block cursor"),
+    };
+    const updated = {
+        ...current,
+        cursor,
+        prunedManifestCount: safeSum([current.prunedManifestCount, increments.prunedManifestCount], "Garbage collection pruned manifest count"),
+        alreadyPrunedManifestCount: safeSum([current.alreadyPrunedManifestCount, increments.alreadyPrunedManifestCount], "Garbage collection already-pruned manifest count"),
+        retainedManifestCount: safeSum([current.retainedManifestCount, increments.retainedManifestCount], "Garbage collection retained manifest count"),
+        missingManifestCount: safeSum([current.missingManifestCount, increments.missingManifestCount], "Garbage collection missing manifest count"),
+        reclaimedSegmentCount: safeSum([current.reclaimedSegmentCount, increments.reclaimedSegmentCount], "Garbage collection reclaimed segment count"),
+        retainedSegmentCount: safeSum([current.retainedSegmentCount, increments.retainedSegmentCount], "Garbage collection retained segment count"),
+        missingSegmentCount: safeSum([current.missingSegmentCount, increments.missingSegmentCount], "Garbage collection missing segment count"),
+        reclaimedBlockCount: safeSum([current.reclaimedBlockCount, increments.reclaimedBlockCount], "Garbage collection reclaimed block count"),
+        retainedBlockCount: safeSum([current.retainedBlockCount, increments.retainedBlockCount], "Garbage collection retained block count"),
+        missingBlockCount: safeSum([current.missingBlockCount, increments.missingBlockCount], "Garbage collection missing block count"),
+        reclaimedBlockBytes: safeSum([current.reclaimedBlockBytes, increments.reclaimedBlockBytes], "Garbage collection reclaimed block bytes"),
+        state: "running",
+        revision: current.revision + 1,
+        updatedAt: validTimestamp(accounting.updatedAt, "Garbage collection update timestamp"),
+    };
+    if (garbageCollectionJobComplete(updated))
+        updated.state = "completed";
+    return normalizeGarbageCollectionJobRecord(updated);
+}
+export function normalizeCompactionJobRecord(record) {
+    const error = record.error;
+    if (error !== undefined && typeof error !== "string") {
+        throw new TypeError("Compaction job error must be a string");
+    }
+    const rewritePlan = normalizeCompactionRewritePlan(record.rewritePlan);
+    const logicalBytes = nonNegativeWholeNumber(record.logicalBytes, "Compaction logical bytes");
+    const sourceStoredBytes = nonNegativeWholeNumber(record.sourceStoredBytes, "Compaction source stored bytes");
+    const outputStoredBytes = nonNegativeWholeNumber(record.outputStoredBytes, "Compaction output stored bytes");
+    const hasLevel0SourceStoredBytes = record.level0SourceStoredBytes !== undefined;
+    const hasAnchorSourceStoredBytes = record.anchorSourceStoredBytes !== undefined;
+    if (hasLevel0SourceStoredBytes !== hasAnchorSourceStoredBytes) {
+        throw new TypeError("Compaction source-level byte accounting requires both stored byte fields");
+    }
+    const sourceLevelStoredBytes = hasLevel0SourceStoredBytes
+        ? {
+            level0SourceStoredBytes: positiveWholeNumber(record.level0SourceStoredBytes, "Compaction level-zero source stored bytes"),
+            anchorSourceStoredBytes: nonNegativeWholeNumber(record.anchorSourceStoredBytes, "Compaction anchor source stored bytes"),
+        }
+        : undefined;
+    if (sourceLevelStoredBytes !== undefined &&
+        safeSum([
+            sourceLevelStoredBytes.level0SourceStoredBytes,
+            sourceLevelStoredBytes.anchorSourceStoredBytes,
+        ], "Compaction source-level stored bytes") !== sourceStoredBytes) {
+        throw new TypeError("Compaction source-level stored bytes must equal source stored bytes");
+    }
+    const level2PolicyValues = [
+        record.outputPartitionOrdinal,
+        record.maxWriteAmplification,
+        record.maximumOutputStoredBytes,
+        record.plannedOutputStoredBytesUpperBound,
+    ];
+    const level2PolicyFieldCount = level2PolicyValues.filter((value) => value !== undefined).length;
+    if (level2PolicyFieldCount !== 0 && level2PolicyFieldCount !== level2PolicyValues.length) {
+        throw new TypeError("Append-row-range L2 compaction policy fields must be present together");
+    }
+    if (record.priorAttemptOutputStoredBytes !== undefined && level2PolicyFieldCount === 0) {
+        throw new TypeError("Compaction prior-attempt accounting requires the L2 compaction policy fields");
+    }
+    let level2Policy;
+    if (level2PolicyFieldCount !== 0) {
+        if (rewritePlan.kind !== "rechunk-v1" && rewritePlan.kind !== "merge-v1") {
+            throw new TypeError("L2 compaction requires a rechunk or merge plan");
+        }
+        if (record.targetLevel !== 2) {
+            throw new TypeError("Append-row-range L2 compaction must target level two");
+        }
+        // Append-row-range promotions consume pure level-zero prefixes; keyed merge promotions may
+        // also fold a retained level-one anchor, whose bytes never count toward the L0 ceiling.
+        if (rewritePlan.kind === "rechunk-v1" &&
+            (sourceLevelStoredBytes?.level0SourceStoredBytes !== sourceStoredBytes ||
+                sourceLevelStoredBytes.anchorSourceStoredBytes !== 0)) {
+            throw new TypeError("Append-row-range L2 compaction requires only level-zero source bytes");
+        }
+        if (rewritePlan.kind === "merge-v1" && sourceLevelStoredBytes === undefined) {
+            throw new TypeError("Keyed L2 compaction requires source-level byte accounting");
+        }
+        const outputPartitionOrdinal = nonNegativeWholeNumber(record.outputPartitionOrdinal, "Compaction output partition ordinal");
+        const maxWriteAmplification = positiveFiniteNumber(record.maxWriteAmplification, "Compaction maximum write amplification");
+        const maximumOutputStoredBytes = positiveWholeNumber(record.maximumOutputStoredBytes, "Compaction maximum output stored bytes");
+        const plannedOutputStoredBytesUpperBound = positiveWholeNumber(record.plannedOutputStoredBytesUpperBound, "Compaction planned output stored byte upper bound");
+        const priorAttemptOutputStoredBytes = record.priorAttemptOutputStoredBytes === undefined
+            ? undefined
+            : nonNegativeWholeNumber(record.priorAttemptOutputStoredBytes, "Compaction prior-attempt output stored bytes");
+        const amplificationCeiling = floorWholeNumberProduct(sourceStoredBytes, maxWriteAmplification, "Compaction write amplification product");
+        // The persisted ceiling plus everything failed attempts already wrote must stay within
+        // the amplification limit — attempts share one lifetime budget.
+        if (maximumOutputStoredBytes + (priorAttemptOutputStoredBytes ?? 0) > amplificationCeiling) {
+            throw new RangeError("Compaction output stored byte ceiling exceeds its amplification limit");
+        }
+        if (plannedOutputStoredBytesUpperBound > maximumOutputStoredBytes) {
+            throw new RangeError("Compaction planned output exceeds its stored byte ceiling");
+        }
+        if (outputStoredBytes > plannedOutputStoredBytesUpperBound) {
+            throw new RangeError("Compaction output stored bytes exceed their planned upper bound");
+        }
+        level2Policy = {
+            outputPartitionOrdinal,
+            maxWriteAmplification,
+            maximumOutputStoredBytes,
+            plannedOutputStoredBytesUpperBound,
+            ...(priorAttemptOutputStoredBytes === undefined ? {} : { priorAttemptOutputStoredBytes }),
+        };
+    }
+    const normalized = {
+        ...record,
+        id: nonEmptyString(record.id, "Compaction job ID"),
+        tableId: nonEmptyString(record.tableId, "Compaction job table ID"),
+        sourceManifestVersion: nonNegativeWholeNumber(record.sourceManifestVersion, "Compaction source manifest version"),
+        sourceSegmentIds: rewritePlan.kind === "copy-v1"
+            ? uniqueIds(record.sourceSegmentIds, "Compaction source segment ID", false)
+            : orderedUniqueIds(record.sourceSegmentIds, "Compaction source segment ID"),
+        sourceBlockIds: rewritePlan.kind === "copy-v1"
+            ? uniqueIds(record.sourceBlockIds, "Compaction source block ID", true)
+            : orderedUniqueIds(record.sourceBlockIds, "Compaction source block ID").sort(),
+        outputBlockIds: rewritePlan.kind === "copy-v1"
+            ? uniqueIds(record.outputBlockIds, "Compaction output block ID", true)
+            : orderedUniqueIds(record.outputBlockIds, "Compaction output block ID"),
+        cursor: normalizeCompactionJobCursor(record.cursor),
+        processedRows: nonNegativeWholeNumber(record.processedRows, "Compaction processed row count"),
+        sourceStoredBytes,
+        outputStoredBytes,
+        logicalBytes,
+        rewritePlan,
+        outputCursor: normalizeCompactionOutputCursor(record.outputCursor, rewritePlan),
+        memoryBudgetBytes: nonNegativeWholeNumber(record.memoryBudgetBytes ?? 0, "Compaction memory budget"),
+        minimumMemoryBytes: nonNegativeWholeNumber(record.minimumMemoryBytes ?? 0, "Compaction minimum memory"),
+        ...(sourceLevelStoredBytes ?? {}),
+        ...(level2Policy ?? {}),
+        peakWorkingBytes: nonNegativeWholeNumber(record.peakWorkingBytes ?? 0, "Compaction peak working bytes"),
+        outputLogicalBytes: nonNegativeWholeNumber(record.outputLogicalBytes ?? (rewritePlan.kind === "copy-v1" ? logicalBytes : 0), "Compaction output logical bytes"),
+        targetLevel: nonNegativeWholeNumber(record.targetLevel, "Compaction target level"),
+        state: compactionJobState(record.state),
+        transactionId: nullableId(record.transactionId, "Compaction transaction ID"),
+        outputSegmentId: nullableId(record.outputSegmentId, "Compaction output segment ID"),
+        publishedVersion: record.publishedVersion === null
+            ? null
+            : nonNegativeWholeNumber(record.publishedVersion, "Compaction published version"),
+        revision: nonNegativeWholeNumber(record.revision, "Compaction job revision"),
+        createdAt: nonEmptyString(record.createdAt, "Compaction creation timestamp"),
+        updatedAt: nonEmptyString(record.updatedAt, "Compaction update timestamp"),
+    };
+    if (normalized.sourceSegmentIds.length === 0) {
+        throw new TypeError("Compaction requires at least one source segment");
+    }
+    if (normalized.cursor.sourceSegmentIndex > normalized.sourceSegmentIds.length) {
+        throw new RangeError("Compaction source segment cursor is outside the source selection");
+    }
+    if (normalized.cursor.sourceSegmentIndex === normalized.sourceSegmentIds.length &&
+        normalized.cursor.sourceBlockIndex !== 0) {
+        throw new RangeError("A completed compaction cursor must start at block zero");
+    }
+    validateCompactionRewrite(normalized);
+    validateCompactionJobState(normalized);
+    return structuredClone(normalized);
+}
+export function updateCompactionJobRecord(record, update) {
+    const current = normalizeCompactionJobRecord(record);
+    for (const field of [
+        "rewritePlan",
+        "memoryBudgetBytes",
+        "minimumMemoryBytes",
+        "level0SourceStoredBytes",
+        "anchorSourceStoredBytes",
+        "outputPartitionOrdinal",
+        "maxWriteAmplification",
+        "maximumOutputStoredBytes",
+        "plannedOutputStoredBytesUpperBound",
+        "priorAttemptOutputStoredBytes",
+    ]) {
+        if (Reflect.has(update, field)) {
+            throw new TypeError(`Compaction ${field} is immutable`);
+        }
+    }
+    if (isOutputDrivenCompactionPlan(current.rewritePlan)) {
+        for (const field of ["cursor", "sourceStoredBytes", "logicalBytes"]) {
+            if (Reflect.has(update, field)) {
+                throw new TypeError(`Output-driven compaction ${field} is immutable`);
+            }
+        }
+    }
+    const mirrorCopyLogicalBytes = current.rewritePlan?.kind === "copy-v1" &&
+        update.logicalBytes !== undefined &&
+        update.outputLogicalBytes === undefined;
+    const updated = {
+        ...current,
+        ...(update.outputBlockIds === undefined ? {} : { outputBlockIds: [...update.outputBlockIds] }),
+        ...(update.cursor === undefined ? {} : { cursor: update.cursor }),
+        ...(update.processedRows === undefined ? {} : { processedRows: update.processedRows }),
+        ...(update.sourceStoredBytes === undefined
+            ? {}
+            : { sourceStoredBytes: update.sourceStoredBytes }),
+        ...(update.outputStoredBytes === undefined
+            ? {}
+            : { outputStoredBytes: update.outputStoredBytes }),
+        ...(update.logicalBytes === undefined ? {} : { logicalBytes: update.logicalBytes }),
+        ...(update.outputCursor === undefined ? {} : { outputCursor: update.outputCursor }),
+        ...(update.peakWorkingBytes === undefined ? {} : { peakWorkingBytes: update.peakWorkingBytes }),
+        ...(update.outputLogicalBytes === undefined
+            ? mirrorCopyLogicalBytes
+                ? { outputLogicalBytes: update.logicalBytes }
+                : {}
+            : { outputLogicalBytes: update.outputLogicalBytes }),
+        ...(update.state === undefined ? {} : { state: update.state }),
+        ...(update.transactionId === undefined ? {} : { transactionId: update.transactionId }),
+        ...(update.outputSegmentId === undefined ? {} : { outputSegmentId: update.outputSegmentId }),
+        ...(update.publishedVersion === undefined ? {} : { publishedVersion: update.publishedVersion }),
+        updatedAt: update.updatedAt,
+        revision: current.revision + 1,
+    };
+    if (update.error === null)
+        delete updated.error;
+    else if (update.error !== undefined)
+        updated.error = update.error;
+    const normalized = normalizeCompactionJobRecord(updated);
+    validateCompactionJobTransition(current.state, normalized.state);
+    validateCompactionJobProgress(current, normalized);
+    return normalized;
+}
+function validateCompactionJobState(record) {
+    const plan = record.rewritePlan ?? { kind: "copy-v1" };
+    if (plan.kind === "merge-v1") {
+        if (plan.totalRows === 0 && record.outputSegmentId !== null) {
+            throw new TypeError("An empty merge compaction cannot have an output segment");
+        }
+        if (plan.totalRows > 0 && record.outputSegmentId === null) {
+            throw new TypeError("A non-empty merge compaction requires an output segment ID");
+        }
+    }
+    if (record.state === "cancelled" && record.error !== undefined) {
+        throw new TypeError("A cancelled compaction cannot contain an error");
+    }
+    if (record.state === "planned") {
+        const isCopy = record.rewritePlan?.kind === "copy-v1";
+        const hasProgress = record.cursor.sourceSegmentIndex !== 0 ||
+            record.cursor.sourceBlockIndex !== 0 ||
+            record.outputBlockIds.length !== 0 ||
+            record.processedRows !== 0 ||
+            (isCopy && record.sourceStoredBytes !== 0) ||
+            record.outputStoredBytes !== 0 ||
+            (isCopy && record.logicalBytes !== 0) ||
+            record.outputLogicalBytes !== 0 ||
+            record.peakWorkingBytes !== 0;
+        if (hasProgress || record.transactionId !== null || !isInitialOutputCursor(record)) {
+            throw new TypeError("A planned compaction cannot contain transaction progress");
+        }
+    }
+    if (record.state === "running" && record.transactionId === null) {
+        throw new TypeError("A running compaction requires a transaction ID");
+    }
+    if (record.state === "ready" || record.state === "published") {
+        if (record.transactionId === null ||
+            (record.outputSegmentId === null && !(plan.kind === "merge-v1" && plan.totalRows === 0))) {
+            throw new TypeError(`${record.state} compaction requires its transaction and output segment`);
+        }
+        if (!hasCompletedCompactionCursor(record)) {
+            throw new TypeError(`${record.state} compaction requires a completed cursor`);
+        }
+        if (record.outputBlockIds.length !== expectedCompactionOutputCount(record)) {
+            throw new TypeError(`${record.state} compaction requires every output block`);
+        }
+        if (isOutputDrivenCompactionPlan(record.rewritePlan) &&
+            expectedCompactionOutputCount(record) > 0 &&
+            (record.peakWorkingBytes ?? 0) < (record.minimumMemoryBytes ?? 0)) {
+            throw new TypeError(`${record.state} compaction requires complete memory accounting`);
+        }
+    }
+    if (record.state === "published") {
+        if (record.publishedVersion === null) {
+            throw new TypeError("A published compaction requires a manifest version");
+        }
+    }
+    else if (record.publishedVersion !== null) {
+        throw new TypeError("Only a published compaction can have a manifest version");
+    }
+}
+function validateCompactionRewrite(record) {
+    const plan = record.rewritePlan ?? { kind: "copy-v1" };
+    const outputLogicalBytes = record.outputLogicalBytes ?? 0;
+    const memoryBudgetBytes = record.memoryBudgetBytes ?? 0;
+    const minimumMemoryBytes = record.minimumMemoryBytes ?? 0;
+    const peakWorkingBytes = record.peakWorkingBytes ?? 0;
+    if (plan.kind === "copy-v1") {
+        if (record.outputCursor !== null) {
+            throw new TypeError("A copy compaction cannot have an output cursor");
+        }
+        if (memoryBudgetBytes !== 0 || minimumMemoryBytes !== 0 || peakWorkingBytes !== 0) {
+            throw new TypeError("A copy compaction cannot have rechunk memory accounting");
+        }
+        if (outputLogicalBytes !== record.logicalBytes) {
+            throw new TypeError("A copy compaction must preserve its logical byte count");
+        }
+        if (record.outputBlockIds.length > record.sourceBlockIds.length) {
+            throw new RangeError("Compaction output cannot contain more blocks than its source selection");
+        }
+        return;
+    }
+    if (record.cursor.sourceSegmentIndex !== 0 || record.cursor.sourceBlockIndex !== 0) {
+        throw new TypeError("An output-driven compaction does not use the source cursor");
+    }
+    const permitsZeroMinimum = plan.kind === "merge-v1" && plan.totalRows === 0;
+    if (memoryBudgetBytes === 0 || (minimumMemoryBytes === 0 && !permitsZeroMinimum)) {
+        throw new RangeError("An output-driven compaction requires a memory budget and minimum memory");
+    }
+    if (minimumMemoryBytes > memoryBudgetBytes) {
+        throw new RangeError("Compaction minimum memory exceeds its memory budget");
+    }
+    if (peakWorkingBytes > memoryBudgetBytes) {
+        throw new RangeError("Compaction peak working bytes exceed its memory budget");
+    }
+    const plannedBlocks = plan.kind === "rechunk-v1"
+        ? plan.columns.flatMap((column) => column.sourceBlocks)
+        : plan.sourceSegments.flatMap((segment) => segment.columns.flatMap((column) => column.sourceBlocks));
+    const plannedBlockIds = plannedBlocks.map((block) => block.blockId);
+    if (new Set(plannedBlockIds).size !== plannedBlockIds.length) {
+        throw new TypeError("A planned source block can only appear once in its source layout");
+    }
+    const sortedPlannedIds = [...plannedBlockIds].sort();
+    if (sortedPlannedIds.length !== record.sourceBlockIds.length ||
+        sortedPlannedIds.some((id, index) => id !== record.sourceBlockIds[index])) {
+        throw new TypeError("The rewrite source layout must describe every selected source block");
+    }
+    const plannedStoredBytes = safeSum(plannedBlocks.map((block) => block.storedBytes), "Rechunk source stored bytes");
+    const plannedEncodedBytes = safeSum(plannedBlocks.map((block) => block.encodedBytes), "Rechunk source encoded bytes");
+    if (record.sourceStoredBytes !== plannedStoredBytes) {
+        throw new TypeError("Source stored bytes must match the immutable rewrite layout");
+    }
+    if (record.logicalBytes !== plannedEncodedBytes) {
+        throw new TypeError("Logical bytes must match the immutable rewrite layout");
+    }
+    if (plan.kind === "merge-v1") {
+        if (plan.totalRows === 0 &&
+            (record.outputBlockIds.length !== 0 ||
+                record.outputStoredBytes !== 0 ||
+                outputLogicalBytes !== 0 ||
+                peakWorkingBytes !== 0 ||
+                minimumMemoryBytes !== 0)) {
+            throw new TypeError("An empty merge compaction cannot contain physical output progress");
+        }
+        const plannedSegmentIds = plan.sourceSegments.map((segment) => segment.segmentId);
+        if (plannedSegmentIds.length !== record.sourceSegmentIds.length ||
+            plannedSegmentIds.some((id, index) => id !== record.sourceSegmentIds[index])) {
+            throw new TypeError("Merge source layout must preserve every selected source segment in order");
+        }
+    }
+    const cursor = record.outputCursor;
+    if (cursor === null || cursor === undefined) {
+        throw new TypeError("An output-driven compaction requires an output cursor");
+    }
+    const completedOutputs = safeSum([
+        safeProduct(cursor.outputIndex, plan.columns.length, "Rechunk output cursor"),
+        cursor.columnIndex,
+    ], "Rechunk output cursor");
+    if (record.outputBlockIds.length !== completedOutputs) {
+        throw new TypeError("Compaction output IDs must match the output cursor");
+    }
+    const expectedProcessedRows = cursor.outputIndex === plan.outputs.length
+        ? plan.totalRows
+        : (plan.outputs[cursor.outputIndex]?.rowStart ?? 0);
+    if (record.processedRows !== expectedProcessedRows) {
+        throw new TypeError("Processed rows must match completed output windows");
+    }
+}
+function validateCompactionJobProgress(previous, next) {
+    for (const [label, previousValue, nextValue] of [
+        ["processed rows", previous.processedRows, next.processedRows],
+        ["source stored bytes", previous.sourceStoredBytes, next.sourceStoredBytes],
+        ["output stored bytes", previous.outputStoredBytes, next.outputStoredBytes],
+        ["logical bytes", previous.logicalBytes, next.logicalBytes],
+        ["output logical bytes", previous.outputLogicalBytes ?? 0, next.outputLogicalBytes ?? 0],
+        ["peak working bytes", previous.peakWorkingBytes ?? 0, next.peakWorkingBytes ?? 0],
+    ]) {
+        if (nextValue < previousValue) {
+            throw new RangeError(`Compaction ${label} cannot decrease`);
+        }
+    }
+    if (next.outputBlockIds.length < previous.outputBlockIds.length) {
+        throw new TypeError("Compaction output block IDs cannot be removed");
+    }
+    if (isOutputDrivenCompactionPlan(previous.rewritePlan)) {
+        if (previous.outputBlockIds.some((id, index) => next.outputBlockIds[index] !== id)) {
+            throw new TypeError("Output block IDs are an append-only ordered checkpoint");
+        }
+        if (compactionOutputOrdinal(next) < compactionOutputOrdinal(previous)) {
+            throw new RangeError("Output cursor cannot move backwards");
+        }
+        if (previous.rewritePlan.kind === "merge-v1" &&
+            previous.outputSegmentId !== next.outputSegmentId) {
+            throw new TypeError("Merge output segment ID is immutable");
+        }
+    }
+    else {
+        const nextIds = new Set(next.outputBlockIds);
+        if (previous.outputBlockIds.some((id) => !nextIds.has(id))) {
+            throw new TypeError("Compaction output block IDs cannot be removed");
+        }
+        const previousCursor = previous.cursor;
+        const nextCursor = next.cursor;
+        if (nextCursor.sourceSegmentIndex < previousCursor.sourceSegmentIndex ||
+            (nextCursor.sourceSegmentIndex === previousCursor.sourceSegmentIndex &&
+                nextCursor.sourceBlockIndex < previousCursor.sourceBlockIndex)) {
+            throw new RangeError("Compaction source cursor cannot move backwards");
+        }
+    }
+}
+function isInitialOutputCursor(record) {
+    const plan = record.rewritePlan ?? { kind: "copy-v1" };
+    if (plan.kind === "copy-v1")
+        return record.outputCursor === null;
+    const cursor = record.outputCursor;
+    const initialRowStart = plan.outputs[0]?.rowStart ?? plan.totalRows;
+    return (cursor?.outputIndex === 0 && cursor.columnIndex === 0 && cursor.rowStart === initialRowStart);
+}
+function hasCompletedCompactionCursor(record) {
+    const plan = record.rewritePlan ?? { kind: "copy-v1" };
+    if (plan.kind === "copy-v1") {
+        return record.cursor.sourceSegmentIndex === record.sourceSegmentIds.length;
+    }
+    const cursor = record.outputCursor;
+    return (cursor?.outputIndex === plan.outputs.length &&
+        cursor.columnIndex === 0 &&
+        cursor.rowStart === plan.totalRows);
+}
+function expectedCompactionOutputCount(record) {
+    const plan = record.rewritePlan ?? { kind: "copy-v1" };
+    return plan.kind === "copy-v1"
+        ? record.sourceBlockIds.length
+        : safeProduct(plan.outputs.length, plan.columns.length, "Rechunk output block count");
+}
+function compactionOutputOrdinal(record) {
+    const plan = record.rewritePlan;
+    const cursor = record.outputCursor;
+    if (!isOutputDrivenCompactionPlan(plan) || cursor === null || cursor === undefined)
+        return 0;
+    return safeSum([
+        safeProduct(cursor.outputIndex, plan.columns.length, "Rechunk output cursor"),
+        cursor.columnIndex,
+    ], "Rechunk output cursor");
+}
+function isOutputDrivenCompactionPlan(plan) {
+    return plan?.kind === "rechunk-v1" || plan?.kind === "merge-v1";
+}
+function validateCompactionJobTransition(previous, next) {
+    const allowed = {
+        planned: ["planned", "running", "cancelled", "aborted"],
+        running: ["running", "ready", "published", "cancelled", "aborted"],
+        ready: ["ready", "running", "published", "cancelled", "aborted"],
+        published: ["published"],
+        cancelled: ["cancelled"],
+        aborted: ["aborted"],
+    };
+    if (!allowed[previous].includes(next)) {
+        throw new TypeError(`Invalid compaction state transition: ${previous} to ${next}`);
+    }
+}
+function normalizeCompactionJobCursor(value) {
+    if (typeof value !== "object" || value === null) {
+        throw new TypeError("Compaction cursor must be an object");
+    }
+    return {
+        sourceSegmentIndex: nonNegativeWholeNumber(Reflect.get(value, "sourceSegmentIndex"), "Compaction source segment cursor"),
+        sourceBlockIndex: nonNegativeWholeNumber(Reflect.get(value, "sourceBlockIndex"), "Compaction source block cursor"),
+    };
+}
+function normalizeCompactionRewritePlan(value) {
+    if (value === undefined)
+        return { kind: "copy-v1" };
+    if (typeof value !== "object" || value === null) {
+        throw new TypeError("Compaction rewrite plan must be an object");
+    }
+    const kind = Reflect.get(value, "kind");
+    if (kind === "copy-v1")
+        return { kind: "copy-v1" };
+    if (kind === "merge-v1")
+        return normalizeMergeCompactionRewritePlan(value);
+    if (kind !== "rechunk-v1") {
+        throw new TypeError(`Invalid compaction rewrite plan: ${String(kind)}`);
+    }
+    const totalRows = positiveWholeNumber(Reflect.get(value, "totalRows"), "Rechunk total row count");
+    const rowIdStart = nonNegativeBigInt(Reflect.get(value, "rowIdStart"), "Rechunk row ID start");
+    const rowIdEndExclusive = nonNegativeBigInt(Reflect.get(value, "rowIdEndExclusive"), "Rechunk row ID end");
+    if (rowIdEndExclusive - rowIdStart !== BigInt(totalRows)) {
+        throw new RangeError("Rechunk row ID range must match its total row count");
+    }
+    const columnsValue = Reflect.get(value, "columns");
+    if (!Array.isArray(columnsValue) || columnsValue.length === 0) {
+        throw new TypeError("A rechunk plan requires at least one source column");
+    }
+    const columns = columnsValue.map((column, index) => normalizeRechunkSourceColumn(column, totalRows, index));
+    const columnIds = columns.map((column) => column.columnId);
+    if (new Set(columnIds).size !== columnIds.length) {
+        throw new TypeError("A rechunk plan cannot contain duplicate source columns");
+    }
+    const outputsValue = Reflect.get(value, "outputs");
+    if (!Array.isArray(outputsValue) || outputsValue.length === 0) {
+        throw new TypeError("A rechunk plan requires at least one output window");
+    }
+    const outputs = outputsValue.map((output, index) => {
+        if (typeof output !== "object" || output === null) {
+            throw new TypeError(`Rechunk output window ${String(index)} must be an object`);
+        }
+        return {
+            rowStart: nonNegativeWholeNumber(Reflect.get(output, "rowStart"), `Rechunk output window ${String(index)} row start`),
+            rowCount: positiveUint32(Reflect.get(output, "rowCount"), `Rechunk output window ${String(index)} row count`),
+        };
+    });
+    validateContiguousRows(outputs, totalRows, "Rechunk output windows");
+    return {
+        kind: "rechunk-v1",
+        targetBlockBytes: positiveWholeNumber(Reflect.get(value, "targetBlockBytes"), "Rechunk target block bytes"),
+        outputCompression: compactionOutputCompression(Reflect.get(value, "outputCompression")),
+        totalRows,
+        rowIdStart,
+        rowIdEndExclusive,
+        logicalOrder: nonNegativeWholeNumber(Reflect.get(value, "logicalOrder"), "Rechunk logical order"),
+        columns,
+        outputs,
+    };
+}
+function normalizeRechunkSourceColumn(value, totalRows, columnIndex) {
+    if (typeof value !== "object" || value === null) {
+        throw new TypeError(`Rechunk source column ${String(columnIndex)} must be an object`);
+    }
+    const sourceBlocksValue = Reflect.get(value, "sourceBlocks");
+    if (!Array.isArray(sourceBlocksValue) || sourceBlocksValue.length === 0) {
+        throw new TypeError(`Rechunk source column ${String(columnIndex)} requires source blocks`);
+    }
+    const sourceBlocks = sourceBlocksValue.map((block, blockIndex) => {
+        if (typeof block !== "object" || block === null) {
+            throw new TypeError(`Rechunk source block ${String(columnIndex)}:${String(blockIndex)} must be an object`);
+        }
+        return {
+            blockId: nonEmptyString(Reflect.get(block, "blockId"), `Rechunk source block ${String(columnIndex)}:${String(blockIndex)} ID`),
+            rowStart: nonNegativeWholeNumber(Reflect.get(block, "rowStart"), `Rechunk source block ${String(columnIndex)}:${String(blockIndex)} row start`),
+            rowCount: positiveUint32(Reflect.get(block, "rowCount"), `Rechunk source block ${String(columnIndex)}:${String(blockIndex)} row count`),
+            storedBytes: positiveWholeNumber(Reflect.get(block, "storedBytes"), `Rechunk source block ${String(columnIndex)}:${String(blockIndex)} stored bytes`),
+            encodedBytes: nonNegativeWholeNumber(Reflect.get(block, "encodedBytes"), `Rechunk source block ${String(columnIndex)}:${String(blockIndex)} encoded bytes`),
+            checksum: uint32(Reflect.get(block, "checksum"), `Rechunk source block ${String(columnIndex)}:${String(blockIndex)} checksum`),
+        };
+    });
+    validateContiguousRows(sourceBlocks, totalRows, `Rechunk source column ${String(columnIndex)} blocks`);
+    return {
+        columnId: nonEmptyString(Reflect.get(value, "columnId"), `Rechunk source column ${String(columnIndex)} ID`),
+        type: simpleDataType(Reflect.get(value, "type")),
+        sourceBlocks,
+    };
+}
+function normalizeMergeCompactionRewritePlan(value) {
+    const totalRows = nonNegativeWholeNumber(Reflect.get(value, "totalRows"), "Merge total row count");
+    const rowIdStart = nonNegativeBigInt(Reflect.get(value, "rowIdStart"), "Merge row ID start");
+    const rowIdEndExclusive = nonNegativeBigInt(Reflect.get(value, "rowIdEndExclusive"), "Merge row ID end");
+    const rowIdSpans = normalizeRowIdSpans(Reflect.get(value, "rowIdSpans"), totalRows, rowIdStart, rowIdEndExclusive, "Merge output row ID spans");
+    const keyColumnId = nonEmptyString(Reflect.get(value, "keyColumnId"), "Merge key column ID");
+    const sourceSegmentsValue = Reflect.get(value, "sourceSegments");
+    if (!Array.isArray(sourceSegmentsValue) || sourceSegmentsValue.length === 0) {
+        throw new TypeError("A merge plan requires at least one source segment");
+    }
+    const sourceSegments = sourceSegmentsValue.map((segment, index) => normalizeMergeSourceSegment(segment, index));
+    const sourceSegmentIds = sourceSegments.map((segment) => segment.segmentId);
+    if (new Set(sourceSegmentIds).size !== sourceSegmentIds.length) {
+        throw new TypeError("A merge source segment can only appear once");
+    }
+    for (let index = 1; index < sourceSegments.length; index += 1) {
+        const previous = sourceSegments[index - 1];
+        const current = sourceSegments[index];
+        if (previous !== undefined &&
+            current !== undefined &&
+            compareMergeSourceSegments(previous, current) >= 0) {
+            throw new TypeError("Merge source segments must use canonical logical order");
+        }
+    }
+    const sourceBlocks = new Map();
+    for (const segment of sourceSegments) {
+        for (const column of segment.columns) {
+            for (const block of column.sourceBlocks) {
+                if (sourceBlocks.has(block.blockId)) {
+                    throw new TypeError("A merge source block can only appear once");
+                }
+                sourceBlocks.set(block.blockId, {
+                    columnId: column.columnId,
+                    type: column.type,
+                    rowCount: block.rowCount,
+                });
+            }
+        }
+    }
+    const columnsValue = Reflect.get(value, "columns");
+    if (!Array.isArray(columnsValue) || columnsValue.length === 0) {
+        throw new TypeError("A merge plan requires at least one output column");
+    }
+    const columns = columnsValue.map((column, index) => normalizeMergeOutputColumn(column, totalRows, sourceBlocks, index));
+    const columnIds = columns.map((column) => column.columnId);
+    if (new Set(columnIds).size !== columnIds.length) {
+        throw new TypeError("A merge plan cannot contain duplicate output columns");
+    }
+    if (!columnIds.includes(keyColumnId)) {
+        throw new TypeError("A merge plan must output its key column");
+    }
+    validateMergeSourceShapes(sourceSegments, columns, keyColumnId);
+    const outputsValue = Reflect.get(value, "outputs");
+    if (!Array.isArray(outputsValue))
+        throw new TypeError("Merge outputs must be an array");
+    if ((totalRows === 0) !== (outputsValue.length === 0)) {
+        throw new TypeError("Merge output windows must be empty exactly when no rows survive");
+    }
+    const outputs = outputsValue.map((output, index) => {
+        if (typeof output !== "object" || output === null) {
+            throw new TypeError(`Merge output window ${String(index)} must be an object`);
+        }
+        return {
+            rowStart: nonNegativeWholeNumber(Reflect.get(output, "rowStart"), `Merge output window ${String(index)} row start`),
+            rowCount: positiveUint32(Reflect.get(output, "rowCount"), `Merge output window ${String(index)} row count`),
+        };
+    });
+    validateContiguousRows(outputs, totalRows, "Merge output windows");
+    const logicalOrder = nonNegativeWholeNumber(Reflect.get(value, "logicalOrder"), "Merge logical order");
+    if (logicalOrder !== sourceSegments[0]?.logicalOrder) {
+        throw new TypeError("Merge logical order must match its earliest source segment");
+    }
+    return {
+        kind: "merge-v1",
+        targetBlockBytes: positiveWholeNumber(Reflect.get(value, "targetBlockBytes"), "Merge target block bytes"),
+        outputCompression: compactionOutputCompression(Reflect.get(value, "outputCompression")),
+        keyColumnId,
+        totalRows,
+        rowIdStart,
+        rowIdEndExclusive,
+        rowIdSpans,
+        logicalOrder,
+        sourceSegments,
+        columns,
+        outputs,
+    };
+}
+function normalizeMergeSourceSegment(value, segmentIndex) {
+    if (typeof value !== "object" || value === null) {
+        throw new TypeError(`Merge source segment ${String(segmentIndex)} must be an object`);
+    }
+    const label = `Merge source segment ${String(segmentIndex)}`;
+    const kind = segmentKind(Reflect.get(value, "kind"));
+    const rowCount = positiveWholeNumber(Reflect.get(value, "rowCount"), `${label} row count`);
+    const rowIdStart = nonNegativeBigInt(Reflect.get(value, "rowIdStart"), `${label} row ID start`);
+    const rowIdEndExclusive = nonNegativeBigInt(Reflect.get(value, "rowIdEndExclusive"), `${label} row ID end`);
+    let rowIdSpans;
+    if (kind === "insert" || kind === "upsert" || kind === "base") {
+        rowIdSpans = normalizeRowIdSpans(Reflect.get(value, "rowIdSpans"), rowCount, rowIdStart, rowIdEndExclusive, `${label} row ID spans`);
+    }
+    else {
+        const spans = Reflect.get(value, "rowIdSpans");
+        if (!Array.isArray(spans) || spans.length !== 0) {
+            throw new TypeError(`${label} mutation markers cannot own row IDs`);
+        }
+        if (rowIdStart !== 0n || rowIdEndExclusive !== 0n) {
+            throw new TypeError(`${label} mutation marker row ID envelope must be empty`);
+        }
+        rowIdSpans = [];
+    }
+    const columnsValue = Reflect.get(value, "columns");
+    if (!Array.isArray(columnsValue) || columnsValue.length === 0) {
+        throw new TypeError(`${label} requires at least one source column`);
+    }
+    const columns = columnsValue.map((column, columnIndex) => normalizeMergeSourceColumn(column, rowCount, segmentIndex, columnIndex));
+    const columnIds = columns.map((column) => column.columnId);
+    if (new Set(columnIds).size !== columnIds.length) {
+        throw new TypeError(`${label} cannot contain duplicate source columns`);
+    }
+    return {
+        segmentId: nonEmptyString(Reflect.get(value, "segmentId"), `${label} ID`),
+        transactionId: nonEmptyString(Reflect.get(value, "transactionId"), `${label} transaction ID`),
+        committedVersion: nonNegativeWholeNumber(Reflect.get(value, "committedVersion"), `${label} committed version`),
+        kind,
+        keyColumnId: nullableId(Reflect.get(value, "keyColumnId"), `${label} key column ID`),
+        level: nonNegativeWholeNumber(Reflect.get(value, "level"), `${label} level`),
+        logicalOrder: nonNegativeWholeNumber(Reflect.get(value, "logicalOrder"), `${label} logical order`),
+        rowCount,
+        rowIdStart,
+        rowIdEndExclusive,
+        rowIdSpans,
+        columns,
+    };
+}
+function normalizeMergeSourceColumn(value, segmentRowCount, segmentIndex, columnIndex) {
+    const label = `Merge source column ${String(segmentIndex)}:${String(columnIndex)}`;
+    if (typeof value !== "object" || value === null) {
+        throw new TypeError(`${label} must be an object`);
+    }
+    const sourceBlocksValue = Reflect.get(value, "sourceBlocks");
+    if (!Array.isArray(sourceBlocksValue) || sourceBlocksValue.length === 0) {
+        throw new TypeError(`${label} requires source blocks`);
+    }
+    const sourceBlocks = sourceBlocksValue.map((block, blockIndex) => {
+        if (typeof block !== "object" || block === null) {
+            throw new TypeError(`${label} block ${String(blockIndex)} must be an object`);
+        }
+        return {
+            blockId: nonEmptyString(Reflect.get(block, "blockId"), `${label} block ID`),
+            rowStart: nonNegativeWholeNumber(Reflect.get(block, "rowStart"), `${label} block row start`),
+            rowCount: positiveUint32(Reflect.get(block, "rowCount"), `${label} block row count`),
+            storedBytes: positiveWholeNumber(Reflect.get(block, "storedBytes"), `${label} block stored bytes`),
+            encodedBytes: nonNegativeWholeNumber(Reflect.get(block, "encodedBytes"), `${label} block encoded bytes`),
+            checksum: uint32(Reflect.get(block, "checksum"), `${label} block checksum`),
+        };
+    });
+    validateContiguousRows(sourceBlocks, segmentRowCount, `${label} blocks`);
+    return {
+        columnId: nonEmptyString(Reflect.get(value, "columnId"), `${label} ID`),
+        type: simpleDataType(Reflect.get(value, "type")),
+        sourceBlocks,
+    };
+}
+function normalizeMergeOutputColumn(value, totalRows, sourceBlocks, columnIndex) {
+    const label = `Merge output column ${String(columnIndex)}`;
+    if (typeof value !== "object" || value === null) {
+        throw new TypeError(`${label} must be an object`);
+    }
+    const columnId = nonEmptyString(Reflect.get(value, "columnId"), `${label} ID`);
+    const type = simpleDataType(Reflect.get(value, "type"));
+    const rangesValue = Reflect.get(value, "sourceRanges");
+    if (!Array.isArray(rangesValue))
+        throw new TypeError(`${label} source ranges must be an array`);
+    const sourceRanges = rangesValue.map((range, rangeIndex) => {
+        if (typeof range !== "object" || range === null) {
+            throw new TypeError(`${label} source range ${String(rangeIndex)} must be an object`);
+        }
+        const normalized = {
+            outputRowStart: nonNegativeWholeNumber(Reflect.get(range, "outputRowStart"), `${label} source range output row start`),
+            sourceBlockId: nonEmptyString(Reflect.get(range, "sourceBlockId"), `${label} source range block ID`),
+            sourceRowStart: nonNegativeWholeNumber(Reflect.get(range, "sourceRowStart"), `${label} source range block row start`),
+            rowCount: positiveUint32(Reflect.get(range, "rowCount"), `${label} source range row count`),
+        };
+        const source = sourceBlocks.get(normalized.sourceBlockId);
+        if (source === undefined)
+            throw new TypeError(`${label} references an unknown source block`);
+        if (source.columnId !== columnId || source.type !== type) {
+            throw new TypeError(`${label} source range has the wrong column or type`);
+        }
+        if (safeSum([normalized.sourceRowStart, normalized.rowCount], `${label} source range rows`) >
+            source.rowCount) {
+            throw new RangeError(`${label} source range is outside its source block`);
+        }
+        return normalized;
+    });
+    let outputRowStart = 0;
+    for (let index = 0; index < sourceRanges.length; index += 1) {
+        const range = sourceRanges[index];
+        if (range === undefined)
+            continue;
+        if (range.outputRowStart !== outputRowStart) {
+            throw new RangeError(`${label} source ranges must cover output rows contiguously`);
+        }
+        const previous = sourceRanges[index - 1];
+        if (previous?.sourceBlockId === range.sourceBlockId &&
+            previous.sourceRowStart + previous.rowCount === range.sourceRowStart) {
+            throw new TypeError(`${label} contains adjacent source ranges that must be coalesced`);
+        }
+        outputRowStart = safeSum([outputRowStart, range.rowCount], `${label} output row count`);
+    }
+    if (outputRowStart !== totalRows) {
+        throw new RangeError(`${label} source ranges must cover every merged output row`);
+    }
+    return { columnId, type, sourceRanges };
+}
+function validateMergeSourceShapes(sourceSegments, outputColumns, keyColumnId) {
+    const outputIds = outputColumns.map((column) => column.columnId);
+    const outputTypes = new Map(outputColumns.map((column) => [column.columnId, column.type]));
+    for (const segment of sourceSegments) {
+        if (segment.keyColumnId !== keyColumnId) {
+            throw new TypeError(`Merge source segment ${segment.segmentId} has the wrong key column`);
+        }
+        const sourceIds = segment.columns.map((column) => column.columnId);
+        if (segment.columns.some((column) => outputTypes.get(column.columnId) !== column.type)) {
+            throw new TypeError(`Merge source segment ${segment.segmentId} has an unknown column or type`);
+        }
+        const canonicalIds = outputIds.filter((id) => sourceIds.includes(id));
+        if (canonicalIds.some((id, index) => sourceIds[index] !== id)) {
+            throw new TypeError(`Merge source segment ${segment.segmentId} columns are not canonical`);
+        }
+        if (segment.kind === "insert" || segment.kind === "upsert" || segment.kind === "base") {
+            if (sourceIds.length !== outputIds.length ||
+                sourceIds.some((id, index) => outputIds[index] !== id)) {
+                throw new TypeError(`Merge ${segment.kind} segment must contain every output column`);
+            }
+        }
+        else if (segment.kind === "delete") {
+            if (sourceIds.length !== 1 || sourceIds[0] !== keyColumnId) {
+                throw new TypeError("A merge delete segment must contain only its key column");
+            }
+        }
+        else if (sourceIds.length < 2 ||
+            !sourceIds.includes(keyColumnId) ||
+            sourceIds.every((id) => id === keyColumnId)) {
+            throw new TypeError("A merge update segment requires its key and a changed column");
+        }
+    }
+}
+function normalizeRowIdSpans(value, totalRows, rowIdStart, rowIdEndExclusive, label) {
+    if (!Array.isArray(value))
+        throw new TypeError(`${label} must be an array`);
+    const spans = value.map((span, index) => {
+        if (typeof span !== "object" || span === null) {
+            throw new TypeError(`${label} ${String(index)} must be an object`);
+        }
+        return {
+            rowStart: nonNegativeWholeNumber(Reflect.get(span, "rowStart"), `${label} ${String(index)} row start`),
+            rowCount: positiveWholeNumber(Reflect.get(span, "rowCount"), `${label} ${String(index)} row count`),
+            rowIdStart: nonNegativeBigInt(Reflect.get(span, "rowIdStart"), `${label} ${String(index)} row ID start`),
+        };
+    });
+    let rowStart = 0;
+    for (let index = 0; index < spans.length; index += 1) {
+        const span = spans[index];
+        if (span === undefined)
+            continue;
+        if (span.rowStart !== rowStart)
+            throw new RangeError(`${label} must cover rows contiguously`);
+        const previous = spans[index - 1];
+        if (previous !== undefined &&
+            previous.rowIdStart + BigInt(previous.rowCount) === span.rowIdStart) {
+            throw new TypeError(`${label} contains adjacent spans that must be coalesced`);
+        }
+        rowStart = safeSum([rowStart, span.rowCount], `${label} row count`);
+    }
+    if (rowStart !== totalRows)
+        throw new RangeError(`${label} must cover every row`);
+    if (spans.length === 0) {
+        if (totalRows !== 0 || rowIdStart !== 0n || rowIdEndExclusive !== 0n) {
+            throw new RangeError(`${label} has an invalid empty row ID envelope`);
+        }
+        return spans;
+    }
+    const intervals = spans
+        .map((span) => ({ start: span.rowIdStart, end: span.rowIdStart + BigInt(span.rowCount) }))
+        .sort((left, right) => (left.start < right.start ? -1 : left.start > right.start ? 1 : 0));
+    for (let index = 1; index < intervals.length; index += 1) {
+        const previous = intervals[index - 1];
+        const current = intervals[index];
+        if (previous !== undefined && current !== undefined && current.start < previous.end) {
+            throw new RangeError(`${label} cannot contain overlapping row IDs`);
+        }
+    }
+    const minimum = intervals[0]?.start;
+    const maximum = intervals[intervals.length - 1]?.end;
+    if (minimum !== rowIdStart || maximum !== rowIdEndExclusive) {
+        throw new RangeError(`${label} must match its row ID envelope`);
+    }
+    return spans;
+}
+function compareMergeSourceSegments(left, right) {
+    return (left.logicalOrder - right.logicalOrder ||
+        left.committedVersion - right.committedVersion ||
+        left.segmentId.localeCompare(right.segmentId));
+}
+function normalizeCompactionOutputCursor(value, plan) {
+    if (plan.kind === "copy-v1") {
+        if (value !== undefined && value !== null) {
+            throw new TypeError("A copy compaction cannot have an output cursor");
+        }
+        return null;
+    }
+    if (value === undefined) {
+        if (plan.kind === "merge-v1") {
+            throw new TypeError("A merge compaction requires an explicit output cursor");
+        }
+        return { outputIndex: 0, columnIndex: 0, rowStart: plan.outputs[0]?.rowStart ?? 0 };
+    }
+    if (typeof value !== "object" || value === null) {
+        throw new TypeError("Rechunk output cursor must be an object");
+    }
+    const cursor = {
+        outputIndex: nonNegativeWholeNumber(Reflect.get(value, "outputIndex"), "Rechunk output cursor index"),
+        columnIndex: nonNegativeWholeNumber(Reflect.get(value, "columnIndex"), "Rechunk output cursor column index"),
+        rowStart: nonNegativeWholeNumber(Reflect.get(value, "rowStart"), "Rechunk output cursor row start"),
+    };
+    if (cursor.outputIndex === plan.outputs.length) {
+        if (cursor.columnIndex !== 0 || cursor.rowStart !== plan.totalRows) {
+            throw new RangeError("A completed rechunk output cursor is not canonical");
+        }
+        return cursor;
+    }
+    const output = plan.outputs[cursor.outputIndex];
+    if (output === undefined || cursor.columnIndex >= plan.columns.length) {
+        throw new RangeError("Rechunk output cursor is outside the output plan");
+    }
+    if (cursor.rowStart !== output.rowStart) {
+        throw new RangeError("Rechunk output cursor row start does not match its output window");
+    }
+    return cursor;
+}
+function validateContiguousRows(ranges, totalRows, label) {
+    let rowStart = 0;
+    for (const range of ranges) {
+        if (range.rowStart !== rowStart) {
+            throw new RangeError(`${label} must cover rows contiguously from zero`);
+        }
+        rowStart = safeSum([rowStart, range.rowCount], `${label} row count`);
+    }
+    if (rowStart !== totalRows) {
+        throw new RangeError(`${label} must cover every planned row`);
+    }
+}
+function compactionOutputCompression(value) {
+    if (typeof value !== "string" ||
+        !compactionOutputCompressions.includes(value)) {
+        throw new TypeError(`Invalid compaction output compression: ${String(value)}`);
+    }
+    return value;
+}
+function simpleDataType(value) {
+    if (typeof value !== "string" || !simpleDataTypes.includes(value)) {
+        throw new TypeError(`Invalid compaction column type: ${String(value)}`);
+    }
+    return value;
+}
+function segmentKind(value) {
+    if (value !== "insert" &&
+        value !== "upsert" &&
+        value !== "update" &&
+        value !== "delete" &&
+        value !== "base") {
+        throw new TypeError(`Invalid merge source segment kind: ${String(value)}`);
+    }
+    return value;
+}
+function compactionJobState(state) {
+    if (typeof state !== "string" || !compactionJobStates.includes(state)) {
+        throw new TypeError(`Invalid compaction job state: ${String(state)}`);
+    }
+    return state;
+}
+function garbageCollectionJobState(state) {
+    if (typeof state !== "string" ||
+        !garbageCollectionJobStates.includes(state)) {
+        throw new TypeError(`Invalid garbage collection job state: ${String(state)}`);
+    }
+    return state;
+}
+function normalizeGarbageCollectionCursor(value) {
+    if (typeof value !== "object" || value === null) {
+        throw new TypeError("Garbage collection cursor must be an object");
+    }
+    return {
+        manifestIndex: nonNegativeWholeNumber(Reflect.get(value, "manifestIndex"), "Garbage collection manifest cursor"),
+        segmentIndex: nonNegativeWholeNumber(Reflect.get(value, "segmentIndex"), "Garbage collection segment cursor"),
+        blockIndex: nonNegativeWholeNumber(Reflect.get(value, "blockIndex"), "Garbage collection block cursor"),
+    };
+}
+function garbageCollectionJobComplete(record) {
+    return (record.cursor.manifestIndex === record.candidateManifestVersions.length &&
+        record.cursor.segmentIndex === record.candidateSegmentIds.length &&
+        record.cursor.blockIndex === record.candidateBlockIds.length);
+}
+function uniqueIds(ids, label, sort) {
+    if (!Array.isArray(ids))
+        throw new TypeError(`${label}s must be an array`);
+    const unique = [...new Set(ids.map((id) => nonEmptyString(id, label)))];
+    return sort ? unique.sort() : unique;
+}
+function orderedUniqueIds(ids, label) {
+    if (!Array.isArray(ids))
+        throw new TypeError(`${label}s must be an array`);
+    const normalized = ids.map((id) => nonEmptyString(id, label));
+    if (new Set(normalized).size !== normalized.length) {
+        throw new TypeError(`${label}s cannot contain duplicates`);
+    }
+    return normalized;
+}
+function uniqueWholeNumbers(values, label) {
+    if (!Array.isArray(values))
+        throw new TypeError(`${label}s must be an array`);
+    return [...new Set(values.map((value) => nonNegativeWholeNumber(value, label)))].sort((left, right) => left - right);
+}
+function nullableId(id, label) {
+    return id === null ? null : nonEmptyString(id, label);
+}
+function nonEmptyString(value, label) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new TypeError(`${label} cannot be empty`);
+    }
+    return value;
+}
+function validTimestamp(value, label) {
+    const timestamp = nonEmptyString(value, label);
+    if (!Number.isFinite(Date.parse(timestamp)))
+        throw new TypeError(`${label} must be valid`);
+    return timestamp;
+}
+function nonNegativeWholeNumber(value, label) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new RangeError(`${label} must be a non-negative whole number`);
+    }
+    return value;
+}
+function nonNegativeBigInt(value, label) {
+    if (typeof value !== "bigint" || value < 0n) {
+        throw new RangeError(`${label} must be a non-negative bigint`);
+    }
+    return value;
+}
+function positiveWholeNumber(value, label) {
+    const normalized = nonNegativeWholeNumber(value, label);
+    if (normalized === 0)
+        throw new RangeError(`${label} must be positive`);
+    return normalized;
+}
+function positiveFiniteNumber(value, label) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        throw new RangeError(`${label} must be a positive finite number`);
+    }
+    return value;
+}
+function uint32(value, label) {
+    const normalized = nonNegativeWholeNumber(value, label);
+    if (normalized > 0xffff_ffff)
+        throw new RangeError(`${label} must fit in 32 bits`);
+    return normalized;
+}
+function positiveUint32(value, label) {
+    const normalized = uint32(value, label);
+    if (normalized === 0)
+        throw new RangeError(`${label} must be positive`);
+    return normalized;
+}
+function safeSum(values, label) {
+    let total = 0;
+    for (const value of values) {
+        total += value;
+        if (!Number.isSafeInteger(total))
+            throw new RangeError(`${label} exceeds the safe range`);
+    }
+    return total;
+}
+function safeProduct(left, right, label) {
+    const product = left * right;
+    if (!Number.isSafeInteger(product))
+        throw new RangeError(`${label} exceeds the safe range`);
+    return product;
+}
+/** Floors an integer-times-double product without rounding the binary double upward. */
+export function floorWholeNumberProduct(left, right, label) {
+    if (!Number.isSafeInteger(left) || left < 0 || !Number.isFinite(right) || right < 0) {
+        throw new RangeError(`${label} exceeds the safe range`);
+    }
+    const bytes = new ArrayBuffer(8);
+    const view = new DataView(bytes);
+    view.setFloat64(0, right, false);
+    const high = view.getUint32(0, false);
+    const low = view.getUint32(4, false);
+    const exponentBits = (high >>> 20) & 0x7ff;
+    const fraction = (BigInt(high & 0x000f_ffff) << 32n) | BigInt(low);
+    const significand = exponentBits === 0 ? fraction : (1n << 52n) | fraction;
+    const binaryExponent = exponentBits === 0 ? -1074 : exponentBits - 1023 - 52;
+    let product = BigInt(left) * significand;
+    if (binaryExponent >= 0)
+        product <<= BigInt(binaryExponent);
+    else
+        product >>= BigInt(-binaryExponent);
+    if (product > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new RangeError(`${label} exceeds the safe range`);
+    }
+    return Number(product);
+}
+//# sourceMappingURL=types.js.map