@minnowdb/core 0.9.1 → 0.10.0

package/dist/storage/indexeddb.js

@@ -1,8 +1,8 @@
-import { CompactionJobConflictError, assertCompactionOutputProvenance, compactionOutputSegmentIds, CompactionBacklogError, createManifest, createGarbageCollectionJobRecord, storeNames, advanceGarbageCollectionJobRecord as advanceGarbageCollectionJobRecordUnchecked, BlockReadBatchTooLargeError, activePostingStorageColumnIds, assertTempRunPageBatchLimits, assertStorageBulkReadItems, assertTransactionArtifactBatchLimits, assertTransactionArtifactJournalLimits, boundedMaintenanceBatchItems, canonicalManifestChangedTableIds, catalogRecordRetainedBytes, manifestRecordRetainedReservationBytes, segmentRecordRetainedBytes, collectFtsPostings, ftsPostingQueryMatches, invalidateUncoveredFtsColumns, invalidateUncoveredSecondaryIndexes, GarbageCollectionJobConflictError, LeaseConflictError, LeaseExpiredError, LeaseOwnerConflictError, MAX_FTS_CANDIDATE_ROW_IDS, MAX_ACTIVE_UNIQUE_KEY_BUILDS, MAX_UNIQUE_KEY_BUILD_STAGED_BYTES, MAX_UNIQUE_KEY_BUILD_STAGED_BYTES_TOTAL, MAX_UNIQUE_KEY_BUILD_CHUNK_BYTES, MAX_UNIQUE_KEY_BUILD_TOKENS_PER_CHUNK, MAX_UNIQUE_KEY_BUILD_TTL_MS, MAX_FTS_BASE_CHUNKS, MAX_FTS_DELTA_CHUNKS, MAX_FTS_POSTINGS_PER_CHUNK, MAX_FTS_POSTING_ROW_IDS_PER_CHUNK, MAX_FTS_POSTING_TERM_CHARACTERS, MAX_FTS_TOKENS_PER_DOCUMENT, MAX_FTS_ORDERED_READ_BYTES, MAX_MANIFEST_BLOCK_PRESENCE_IDS, MAX_MANIFEST_RECORDS, MAX_MANIFEST_RETAINED_BYTES, MAX_BLOCK_READ_BATCH_BYTES, MAX_STORAGE_ID_CHARACTERS, MAX_LEASE_TTL_MS, MAX_ACTIVE_LEASES, MAX_ACTIVE_TRANSACTIONS, MAX_GLOBAL_STAGED_ARTIFACT_BYTES, MAX_GLOBAL_STAGED_BLOCKS, MAX_GLOBAL_STAGED_SEGMENTS, MAX_RETIRED_HISTORY_BYTES, MAX_PINNED_MANIFEST_VERSION_LAG, MAX_PINNED_RETIRED_BLOCKS, MAX_PINNED_RETIRED_BYTES, MAX_TERMINAL_TRANSACTION_RECORDS, MAX_ACTIVE_COMPACTION_JOBS, MAX_ACTIVE_GARBAGE_COLLECTION_JOBS, MAX_TERMINAL_COMPACTION_JOB_RECORDS, MAX_COMPLETED_GARBAGE_COLLECTION_JOB_RECORDS, MAX_CATALOG_RECORDS, MAX_CATALOG_RETAINED_BYTES, MAX_SEGMENT_RECORDS, MAX_SEGMENT_RETAINED_BYTES, MAX_ACTIVE_FTS_BASE_BUILDS, MAX_ACTIVE_SECONDARY_INDEX_BUILDS, MAX_ACCELERATOR_BUILD_STAGED_BYTES_TOTAL, MAX_ACCELERATOR_BUILD_STAGED_ENTRIES_TOTAL, MAX_POSTING_BUILD_TTL_MS, MAX_SNAPSHOT_SESSION_TTL_MS, MAX_SNAPSHOT_FRAME_BATCH_BYTES, MAX_SNAPSHOT_FRAME_BATCH_ITEMS, MAX_SNAPSHOT_METADATA_BATCH_BYTES, MAX_SNAPSHOT_METADATA_FRAME_BYTES, SNAPSHOT_FRAME_KINDS, MAX_LEVEL_ZERO_SEGMENTS, MAX_AUTO_INCREMENT_EXCLUSIVE_END, MAX_ROW_ID, MAX_ROW_ID_EXCLUSIVE_END, StorageCorruptionError, StorageFormatVersionError, IndexedDbSchemaUpgradeBlockedError, StorageResourceLimitError, SnapshotManifestMissingError, SnapshotImportConflictError, PostingBuildConflictError, validateTableForeignKey, TableInUseError, TableRecordConflictError, TempOwnerConflictError, MAX_TEMP_OWNER_TTL_MS, MAX_ACTIVE_TEMP_OWNERS, MAX_TEMP_RUNS_PER_OWNER, MAX_TEMP_PAGES_PER_OWNER, MAX_TEMP_RUNS_TOTAL, MAX_TEMP_PAGES_TOTAL, MAX_TEMP_BYTES_PER_OWNER, MAX_TEMP_BYTES_TOTAL, TransactionRecordConflictError, UniqueKeyConflictError, UniqueKeyBuildConflictError, UniqueIndexCoverageError, SchemaConflictError, normalizeCompactionJobRecord, normalizeGarbageCollectionJobRecord, normalizeSegmentRecord, updateCompactionJobRecord as updateCompactionJobRecordUnchecked, updateGarbageCollectionPlanningRecord, updateTransactionRecord as updateTransactionRecordUnchecked, validateColumnDefault, validateCatalogName, validateCanonicalManifestChangedTableIds, validateEnumValues, validateFtsCandidateLimit, validateFtsOrderedReadLimits, validateFtsReadVersion, validateFtsPostingQueries, validateStorageId, validateStorageDatabaseName, validateTableColumns, validateSecondaryIndexes, validateTableRecordBounds, secondaryIndexColumnIds, secondaryIndexWriteContractChanged, secondaryUniqueKeyNamespace, transactionCommitDeltaRetainedBytes, uniqueKeyBuildChunkRetainedBytes, WriteConflictError } from "./types.js";
+import { CompactionJobConflictError, assertCompactionOutputProvenance, compactionOutputSegmentIds, CompactionBacklogError, createManifest, createGarbageCollectionJobRecord, storeNames, advanceGarbageCollectionJobRecord as advanceGarbageCollectionJobRecordUnchecked, BlockReadBatchTooLargeError, activePostingStorageColumnIds, assertTempRunPageBatchLimits, assertStorageBulkReadItems, assertTransactionArtifactBatchLimits, boundedMaintenanceBatchItems, canonicalManifestChangedTableIds, catalogRecordRetainedBytes, manifestRecordRetainedReservationBytes, segmentRecordRetainedBytes, collectFtsPostings, ftsPostingQueryMatches, invalidateUncoveredFtsColumns, invalidateUncoveredSecondaryIndexes, GarbageCollectionJobConflictError, LeaseConflictError, LeaseExpiredError, LeaseOwnerConflictError, MAX_FTS_CANDIDATE_ROW_IDS, MAX_ACTIVE_UNIQUE_KEY_BUILDS, MAX_UNIQUE_KEY_BUILD_STAGED_BYTES, MAX_UNIQUE_KEY_BUILD_STAGED_BYTES_TOTAL, MAX_UNIQUE_KEY_BUILD_CHUNK_BYTES, MAX_UNIQUE_KEY_BUILD_TOKENS_PER_CHUNK, MAX_UNIQUE_KEY_BUILD_TTL_MS, MAX_FTS_BASE_CHUNKS, MAX_FTS_DELTA_CHUNKS, MAX_FTS_POSTINGS_PER_CHUNK, MAX_FTS_POSTING_ROW_IDS_PER_CHUNK, MAX_FTS_POSTING_TERM_CHARACTERS, MAX_FTS_TOKENS_PER_DOCUMENT, MAX_FTS_ORDERED_READ_BYTES, MAX_MANIFEST_BLOCK_PRESENCE_IDS, MAX_MANIFEST_RECORDS, MAX_MANIFEST_RETAINED_BYTES, MAX_BLOCK_READ_BATCH_BYTES, MAX_STORAGE_ID_CHARACTERS, MAX_LEASE_TTL_MS, MAX_ACTIVE_LEASES, MAX_ACTIVE_TRANSACTIONS, MAX_GLOBAL_STAGED_ARTIFACT_BYTES, MAX_GLOBAL_STAGED_BLOCKS, MAX_GLOBAL_STAGED_SEGMENTS, MAX_RETIRED_HISTORY_BYTES, MAX_PINNED_MANIFEST_VERSION_LAG, MAX_PINNED_RETIRED_BLOCKS, MAX_PINNED_RETIRED_BYTES, MAX_TERMINAL_TRANSACTION_RECORDS, MAX_ACTIVE_COMPACTION_JOBS, MAX_ACTIVE_GARBAGE_COLLECTION_JOBS, MAX_TERMINAL_COMPACTION_JOB_RECORDS, MAX_COMPLETED_GARBAGE_COLLECTION_JOB_RECORDS, MAX_CATALOG_RECORDS, MAX_CATALOG_RETAINED_BYTES, MAX_SEGMENT_RECORDS, MAX_SEGMENT_RETAINED_BYTES, MAX_ACTIVE_FTS_BASE_BUILDS, MAX_ACTIVE_SECONDARY_INDEX_BUILDS, MAX_ACCELERATOR_BUILD_STAGED_BYTES_TOTAL, MAX_ACCELERATOR_BUILD_STAGED_ENTRIES_TOTAL, MAX_POSTING_BUILD_TTL_MS, MAX_SNAPSHOT_SESSION_TTL_MS, MAX_SNAPSHOT_FRAME_BATCH_BYTES, MAX_SNAPSHOT_FRAME_BATCH_ITEMS, MAX_SNAPSHOT_METADATA_BATCH_BYTES, MAX_SNAPSHOT_METADATA_FRAME_BYTES, SNAPSHOT_FRAME_KINDS, MAX_LEVEL_ZERO_SEGMENTS, MAX_AUTO_INCREMENT_EXCLUSIVE_END, MAX_ROW_ID, MAX_ROW_ID_EXCLUSIVE_END, StorageCorruptionError, StorageFormatVersionError, IndexedDbSchemaUpgradeBlockedError, StorageResourceLimitError, SnapshotManifestMissingError, SnapshotImportConflictError, PostingBuildConflictError, validateTableForeignKey, TableInUseError, TableRecordConflictError, TempOwnerConflictError, MAX_TEMP_OWNER_TTL_MS, MAX_ACTIVE_TEMP_OWNERS, MAX_TEMP_RUNS_PER_OWNER, MAX_TEMP_PAGES_PER_OWNER, MAX_TEMP_RUNS_TOTAL, MAX_TEMP_PAGES_TOTAL, MAX_TEMP_BYTES_PER_OWNER, MAX_TEMP_BYTES_TOTAL, TransactionRecordConflictError, UniqueKeyConflictError, UniqueKeyBuildConflictError, UniqueIndexCoverageError, SchemaConflictError, normalizeCompactionJobRecord, normalizeGarbageCollectionJobRecord, normalizeSegmentRecord, updateCompactionJobRecord as updateCompactionJobRecordUnchecked, updateGarbageCollectionPlanningRecord, updateTransactionRecord as updateTransactionRecordUnchecked, validateColumnDefault, validateCatalogName, validateCanonicalManifestChangedTableIds, validateEnumValues, validateFtsCandidateLimit, validateFtsOrderedReadLimits, validateFtsReadVersion, validateFtsPostingQueries, validateStorageId, validateStorageDatabaseName, validateTableColumns, validateSecondaryIndexes, validateTableRecordBounds, secondaryIndexColumnIds, secondaryIndexWriteContractChanged, secondaryUniqueKeyNamespace, transactionCommitDeltaRetainedBytes, uniqueKeyBuildChunkRetainedBytes, WriteConflictError } from "./types.js";
 import { crc32, verifyStoredBlock } from "../block-format/index.js";
 import { dateIsoString } from "../date-value.js";
 import { decodeSnapshotMetadataItems, encodeSnapshotMetadataPage, extendSnapshotFrameStreamChecksum, prepareSnapshotFrameStreamHeader, snapshotFrameEnvelopeParts, snapshotFrameStreamHeaderIdentity } from "./snapshot-stream.js";
-const SCHEMA_VERSION = 1;
+const SCHEMA_VERSION = 2;
 const FIRST_STABLE_SCHEMA_VERSION = 1;
 const CURRENT_MANIFEST_KEY = "manifest/current";
 const MANIFEST_PRUNE_CLEANUP_KEY = "manifest/prune-cleanup";
@@ -16,7 +16,13 @@ const SNAPSHOT_UNIQUE_OWNER_PREFIX = "snapshot/frame-import/unique-owner/";
 const SNAPSHOT_POSTING_STAGING_PREFIX = "snapshot/frame-import/posting/";
 const SNAPSHOT_POSTING_OWNER_PREFIX = "snapshot/frame-import/posting-owner/";
 const SNAPSHOT_HEADER_STORE = "snapshotHeaders";
-const indexedDbStoreNames = [...storeNames, SNAPSHOT_HEADER_STORE];
+const TRANSACTION_JOURNAL_STORE = "transactionJournal";
+const indexedDbStoreNames = [
+  ...storeNames,
+  SNAPSHOT_HEADER_STORE,
+  TRANSACTION_JOURNAL_STORE
+];
+const TRANSACTION_JOURNAL_CHUNK_ENTRIES = 1024;
 const SEGMENT_TABLE_INDEX = "byTable";
 const LEASE_EXPIRY_INDEX = "byExpiry";
 const TRANSACTION_STATUS_INDEX = "byStatus";
@@ -64,7 +70,50 @@ const ACTIVE_GARBAGE_COLLECTION_KEY = "maintenance/active-garbage-collection";
 const MAINTENANCE_QUOTA_KEY = "maintenance/quota";
 const storageTextEncoder = new TextEncoder();
 const storageTextBuffer = new Uint8Array(1024);
-const indexedDbSchemaMigrations = [];
+const indexedDbSchemaMigrations = [
+  {
+    targetVersion: 2,
+    migrate: migrateTransactionJournalsToChunks
+  }
+];
+function migrateTransactionJournalsToChunks(database, upgrade, fail) {
+  if (!database.objectStoreNames.contains("transactions") || database.objectStoreNames.contains(TRANSACTION_JOURNAL_STORE)) {
+    throw corruption("schema", "schema 1 layout cannot be migrated to schema 2");
+  }
+  database.createObjectStore(TRANSACTION_JOURNAL_STORE);
+  const transactionStore = upgrade.objectStore("transactions");
+  const journalStore = upgrade.objectStore(TRANSACTION_JOURNAL_STORE);
+  const request = transactionStore.openCursor();
+  request.onerror = () => fail(request.error ?? new Error("IndexedDB migration cursor failed"));
+  request.onsuccess = () => {
+    const cursor = request.result;
+    if (cursor === null)
+      return;
+    try {
+      const key = cursor.key;
+      if (typeof key !== "string")
+        throw corruption("transactions", "record key is invalid");
+      const value = cursor.value;
+      if (!isRecord(value))
+        throw corruption(`transactions/${key}`, "record is not an object");
+      const { pendingBlockIds, pendingSegmentIds, ...header } = value;
+      const blockIds = requiredUniqueStringArray(pendingBlockIds, `transactions/${key}/pendingBlockIds`);
+      const segmentIds = requiredUniqueStringArray(pendingSegmentIds, `transactions/${key}/pendingSegmentIds`);
+      packTransactionJournal(blockIds, segmentIds).forEach((chunk, index) => {
+        journalStore.add(chunk, transactionJournalChunkKey(key, index));
+      });
+      cursor.update({
+        ...header,
+        journalChunkCount: transactionJournalChunkCount(blockIds.length, segmentIds.length),
+        pendingBlockCount: blockIds.length,
+        pendingSegmentCount: segmentIds.length
+      });
+      cursor.continue();
+    } catch (error) {
+      fail(error instanceof Error ? error : new Error(String(error)));
+    }
+  };
+}
 assertIndexedDbSchemaMigrationRegistry();
 const DEFAULT_UNIQUE_KEY_CACHE_BYTES = 8 * 1024 * 1024;
 const TABLE_NAME_CACHE_LIMIT = 256;
@@ -76,6 +125,7 @@ class IndexedDbBlockStore {
   #tableIdsByName = /* @__PURE__ */ new Map();
   #uniqueKeyCache;
   #manifestCache;
+  #journalCache;
   #snapshotPeakRetainedItems = 0;
   #snapshotPeakRetainedBytes = 0;
   #closed = false;
@@ -113,7 +163,10 @@ class IndexedDbBlockStore {
           createCurrentIndexedDbSchema(request.result, upgrade);
           return;
         }
-        applyIndexedDbSchemaMigrations(request.result, upgrade, event.oldVersion);
+        applyIndexedDbSchemaMigrations(request.result, upgrade, event.oldVersion, (error) => {
+          upgradeError ??= error;
+          abortIfActive(upgrade);
+        });
       } catch (error) {
         upgradeError = error instanceof Error ? error : new Error(String(error));
         request.transaction?.abort();
@@ -1125,6 +1178,7 @@ class IndexedDbBlockStore {
       await bumpSchemaEpoch(catalog);
       await transactionDone(transaction);
       this.#manifestCache = void 0;
+      this.#journalCache = void 0;
       if (this.#uniqueKeyCache?.tableId === input.tableId || this.#uniqueKeyCache?.tableId.startsWith(`${input.tableId}\0secondary-index\0`) === true) {
         this.#uniqueKeyCache = void 0;
       } else if (this.#uniqueKeyCache !== void 0) {
@@ -1265,6 +1319,7 @@ class IndexedDbBlockStore {
       await bumpSchemaEpoch(catalog);
       await transactionDone(transaction);
       this.#manifestCache = void 0;
+      this.#journalCache = void 0;
       if (this.#uniqueKeyCache !== void 0)
         this.#uniqueKeyCache.version = manifest.version;
       return manifest;
@@ -1845,12 +1900,10 @@ class IndexedDbBlockStore {
       if (segment.id !== segmentId || segment.transactionId !== expectedTransactionId) {
         throw new Error(`Segment ${segmentId} is not owned by transaction ${expectedTransactionId}`);
       }
-      const transactionStore = transaction.objectStore("transactions");
-      const ownerValue = await requestResult(transactionStore.get(expectedTransactionId));
-      if (ownerValue === void 0) {
+      const owner = await readTransactionRecord(transaction, expectedTransactionId);
+      if (owner === void 0) {
         throw corruption(`segments/${segmentId}`, `owning transaction ${expectedTransactionId} is missing`);
       }
-      const owner = asTransactionRecord(ownerValue, expectedTransactionId);
       if (owner.status !== "aborted") {
         throw new Error(`Segment ${segmentId} owner must be aborted; found ${owner.status}`);
       }
@@ -1861,10 +1914,7 @@ class IndexedDbBlockStore {
       if (published !== void 0) {
         throw new Error(`Segment ${segmentId} is published by manifest ${String(published.version)}`);
       }
-      await visitObjectStoreSequentially(transactionStore, (candidateValue, key) => {
-        if (typeof key !== "string")
-          throw corruption("transactions", "record key is invalid");
-        const candidate = asTransactionRecord(candidateValue, key);
+      await visitTransactionRecords(transaction, (candidate) => {
         if (candidate.status === "active" && candidate.pendingSegmentIds.includes(segmentId)) {
           throw new Error(`Segment ${segmentId} is referenced by active transaction ${candidate.id}`);
         }
@@ -1903,7 +1953,7 @@ class IndexedDbBlockStore {
       segmentStore.delete(segmentId);
       for (const { next } of rebasedSegments)
         segmentStore.put(next, next.id);
-      transactionStore.put(updatedOwner, owner.id);
+      putTransactionRecord(transaction, updatedOwner, journalChunkCountOf(owner));
       await transactionDone(transaction);
       return true;
     } catch (error) {
@@ -1925,11 +1975,10 @@ class IndexedDbBlockStore {
     const transaction = this.#transaction(["blocks", "catalog", "gc", "manifests", "segments", "statistics", "transactions"], "readwrite");
     try {
       const segmentStore = transaction.objectStore("segments");
-      const transactionStore = transaction.objectStore("transactions");
-      const [storedValue, abortedValue, replacementValue] = await Promise.all([
+      const [storedValue, aborted, replacement] = await Promise.all([
         requestResult(segmentStore.get(desired.id)),
-        requestResult(transactionStore.get(input.expectedAbortedTransactionId)),
-        requestResult(transactionStore.get(input.replacementTransactionId))
+        readTransactionRecord(transaction, input.expectedAbortedTransactionId),
+        readTransactionRecord(transaction, input.replacementTransactionId)
       ]);
       if (storedValue === void 0)
         throw new Error(`Segment does not exist: ${desired.id}`);
@@ -1943,11 +1992,9 @@ class IndexedDbBlockStore {
       if (stored.transactionId !== input.expectedAbortedTransactionId || !sameStructuredValue(storedContent, desiredContent)) {
         throw new Error(`Segment ${desired.id} does not match the immutable adoption record`);
       }
-      const aborted = abortedValue === void 0 ? void 0 : asTransactionRecord(abortedValue, input.expectedAbortedTransactionId);
       if (aborted?.revision !== input.expectedAbortedTransactionRevision) {
         throw new TransactionRecordConflictError(input.expectedAbortedTransactionId, input.expectedAbortedTransactionRevision, aborted?.revision ?? null);
       }
-      const replacement = replacementValue === void 0 ? void 0 : asTransactionRecord(replacementValue, input.replacementTransactionId);
       if (replacement?.revision !== input.expectedReplacementTransactionRevision) {
         throw new TransactionRecordConflictError(input.replacementTransactionId, input.expectedReplacementTransactionRevision, replacement?.revision ?? null);
       }
@@ -1985,10 +2032,7 @@ class IndexedDbBlockStore {
       if (await findReadableManifestBlock(transaction, segmentBlockIds(stored)) !== void 0) {
         throw new Error(`Segment ${desired.id} is still reachable from a readable manifest`);
       }
-      await visitObjectStoreSequentially(transactionStore, (candidateValue, key) => {
-        if (typeof key !== "string")
-          throw corruption("transactions", "record key is invalid");
-        const candidate = asTransactionRecord(candidateValue, key);
+      await visitTransactionRecords(transaction, (candidate) => {
         if (candidate.id !== aborted.id && candidate.id !== replacement.id && candidate.status === "active" && candidate.pendingSegmentIds.includes(desired.id)) {
           throw new Error(`Segment ${desired.id} is referenced by active transaction ${candidate.id}`);
         }
@@ -2033,7 +2077,6 @@ class IndexedDbBlockStore {
         revision: incrementSafeInteger(replacement.revision, "Transaction revision"),
         updatedAt: input.updatedAt
       };
-      assertTransactionArtifactJournalLimits(updatedReplacement.pendingBlockIds, updatedReplacement.pendingSegmentIds);
       const statistics = transaction.objectStore("statistics");
       await updateTransactionResourceLedger(statistics, aborted.id, {
         blockCount: 0,
@@ -2051,8 +2094,8 @@ class IndexedDbBlockStore {
       segmentStore.put(desired, desired.id);
       for (const { next } of rebasedAbortedSegments)
         segmentStore.put(next, next.id);
-      transactionStore.put(updatedAborted, updatedAborted.id);
-      transactionStore.put(updatedReplacement, updatedReplacement.id);
+      putTransactionRecord(transaction, updatedAborted, journalChunkCountOf(aborted));
+      putTransactionRecord(transaction, updatedReplacement, journalChunkCountOf(replacement));
       await transactionDone(transaction);
       return structuredClone(updatedReplacement);
     } catch (error) {
@@ -2194,17 +2237,13 @@ class IndexedDbBlockStore {
       }
       segments.sort((left, right) => left.id.localeCompare(right.id));
       const transactionIds = [...new Set(segments.map((segment) => segment.transactionId))];
-      const transactionStore = transaction.objectStore("transactions");
       const transactions = [];
       for (let start = 0; start < transactionIds.length; start += 64) {
         const window = transactionIds.slice(start, start + 64);
-        const values = await Promise.all(window.map((id) => requestResult(transactionStore.get(id))));
-        values.forEach((value, index) => {
-          const id = window[index];
-          if (value !== void 0 && id !== void 0) {
-            transactions.push(asTransactionRecord(value, id));
-          }
-        });
+        for (const record of await readTransactionRecords(transaction, window)) {
+          if (record !== void 0)
+            transactions.push(record);
+        }
       }
       await transactionDone(transaction);
       return {
@@ -2316,7 +2355,9 @@ class IndexedDbBlockStore {
         currentVersion: current ?? null,
         replacementTransaction: normalized
       });
-      transaction.objectStore("transactions").add(normalized, normalized.id);
+      addTransactionRecord(transaction, normalized);
+      if (this.#journalCache?.transactionId === normalized.id)
+        this.#journalCache = void 0;
       let rowIds;
       if (input.reserveRowIds !== void 0) {
         validateCount(input.reserveRowIds.count);
@@ -2395,7 +2436,7 @@ class IndexedDbBlockStore {
           retainedBytes
         });
       }
-      transaction.objectStore("transactions").add(normalized, normalized.id);
+      addTransactionRecord(transaction, normalized);
       await transactionDone(transaction);
     } catch (error) {
       abortIfActive(transaction);
@@ -2406,54 +2447,58 @@ class IndexedDbBlockStore {
   async getTransaction(id) {
     validateId(id, "Transaction ID");
     const transaction = this.#transaction("transactions", "readonly");
-    const value = await requestResult(transaction.objectStore("transactions").get(id));
+    const record = await readTransactionRecord(transaction, id);
     await transactionDone(transaction);
-    return value === void 0 ? void 0 : asTransactionRecord(value, id);
+    return record;
   }
   async getTransactions(ids) {
     assertStorageBulkReadItems(ids, "Transaction read");
     for (const id of ids)
       validateId(id, "Transaction ID");
     const transaction = this.#transaction("transactions", "readonly");
-    const store = transaction.objectStore("transactions");
-    const values = await Promise.all(ids.map((id) => requestResult(store.get(id))));
+    const records = await readTransactionRecords(transaction, ids);
     await transactionDone(transaction);
-    return values.map((value, index) => value === void 0 ? void 0 : asTransactionRecord(value, ids[index]));
+    return records;
   }
   async listTransactionPage(afterId, limit) {
     validatePageLimit(limit);
     const transaction = this.#transaction("transactions", "readonly");
-    const records = await readCursorPage(transaction.objectStore("transactions"), limit, (value, key) => {
+    const page = await readCursorPage(transaction.objectStore("transactions"), limit, (value, key) => {
       if (typeof key !== "string")
         throw corruption("transactions", "record key is invalid");
-      return asTransactionRecord(value, key);
+      return asStoredTransactionRecord(value, key);
     }, (key) => typeof key === "string" && (afterId === null || key > afterId), afterId ?? void 0);
+    const records = await Promise.all(page.map((stored) => assembleTransactionRecord(transaction, stored)));
     await transactionDone(transaction);
     return { records, nextCursor: records.length === limit ? records.at(-1)?.id ?? null : null };
   }
   async updateTransaction(id, expectedRevision, update) {
     validateId(id, "Transaction ID");
     const transaction = this.#transaction(["transactions", "manifests", "blocks", "catalog", "segments", "statistics"], "readwrite");
-    const store = transaction.objectStore("transactions");
-    const value = await requestResult(store.get(id));
-    const current = value === void 0 ? void 0 : asTransactionRecord(value, id);
-    if (current?.revision !== expectedRevision) {
-      transaction.abort();
+    const stored = await readStoredTransactionRecord(transaction, id);
+    if (stored?.revision !== expectedRevision) {
+      abortIfActive(transaction);
       await ignoreAbort(transaction);
-      throw new TransactionRecordConflictError(id, expectedRevision, current?.revision ?? null);
+      throw new TransactionRecordConflictError(id, expectedRevision, stored?.revision ?? null);
     }
     try {
+      const current = await assembleTransactionRecord(transaction, stored);
       assertGenericTransactionUpdateAllowed(current, update);
       const updated = updateTransactionRecord(current, update);
       if (update.snapshotVersion !== void 0) {
         await assertSnapshotAvailableInTransaction(transaction, updated.snapshotVersion);
       }
       await assertPendingArtifactsAvailableInTransaction(transaction, updated, update.pendingBlockIds !== void 0, update.pendingSegmentIds !== void 0, update.pendingSegmentIds !== void 0);
-      const addedBlocks = updated.pendingBlockIds.filter((blockId) => !current.pendingBlockIds.includes(blockId));
-      const addedSegments = updated.pendingSegmentIds.filter((segmentId) => !current.pendingSegmentIds.includes(segmentId));
-      if (update.pendingBlockIds !== void 0 && current.pendingBlockIds.some((blockId) => !updated.pendingBlockIds.includes(blockId)) || update.pendingSegmentIds !== void 0 && current.pendingSegmentIds.some((segmentId) => !updated.pendingSegmentIds.includes(segmentId))) {
+      const updatedBlocks = new Set(updated.pendingBlockIds);
+      const updatedSegments = new Set(updated.pendingSegmentIds);
+      if (current.pendingBlockIds.some((blockId) => !updatedBlocks.has(blockId)) || current.pendingSegmentIds.some((segmentId) => !updatedSegments.has(segmentId))) {
         throw new TypeError("Use rollbackTransactionArtifacts to remove journaled artifacts");
       }
+      if (!extendsJournalOrder(current.pendingBlockIds, updated.pendingBlockIds) || !extendsJournalOrder(current.pendingSegmentIds, updated.pendingSegmentIds)) {
+        throw new TypeError("Transaction journal updates must append after the journaled ids");
+      }
+      const addedBlocks = updated.pendingBlockIds.slice(current.pendingBlockIds.length);
+      const addedSegments = updated.pendingSegmentIds.slice(current.pendingSegmentIds.length);
       if (addedBlocks.length > 0 || addedSegments.length > 0) {
         let retainedBytes = 0;
         for (const id2 of addedBlocks) {
@@ -2465,9 +2510,12 @@ class IndexedDbBlockStore {
           retainedBytes
         });
       }
-      store.put(updated, id);
+      if (addedBlocks.length > 0 || addedSegments.length > 0) {
+        appendTransactionJournalChunks(transaction, stored, packTransactionJournal(current.pendingBlockIds, current.pendingSegmentIds).at(-1), addedBlocks, addedSegments);
+      }
+      putStoredTransactionRecord(transaction, storedTransactionRecord(updated));
       await transactionDone(transaction);
-      return structuredClone(updated);
+      return updated;
     } catch (error) {
       abortIfActive(transaction);
       await ignoreAbort(transaction);
@@ -2480,13 +2528,11 @@ class IndexedDbBlockStore {
     const cutoff = validateBoundedLeaseExpiration(input.expiresAtCutoff, input.expiresAt, "Transaction");
     const transaction = this.#transaction(["transactions", "catalog", "leases"], "readwrite");
     try {
-      const store = transaction.objectStore("transactions");
-      const value = await requestResult(store.get(input.transactionId));
-      if (value === void 0) {
+      const record = await readStoredTransactionRecord(transaction, input.transactionId);
+      if (record === void 0) {
         await transactionDone(transaction);
         return false;
       }
-      const record = asTransactionRecord(value, input.transactionId);
       if (record.status !== "active" || record.ownerId !== input.ownerId || Date.parse(record.expiresAt) <= cutoff) {
         await transactionDone(transaction);
         return false;
@@ -2499,7 +2545,7 @@ class IndexedDbBlockStore {
         replacementTransaction: renewed,
         excludeTransactionId: record.id
       });
-      store.put(renewed, input.transactionId);
+      putStoredTransactionRecord(transaction, renewed);
       await transactionDone(transaction);
       return true;
     } catch (error) {
@@ -2521,23 +2567,23 @@ class IndexedDbBlockStore {
     const transaction = this.#transaction("transactions", "readwrite");
     try {
       const store = transaction.objectStore("transactions");
-      const value = await requestResult(store.get(input.transactionId));
-      if (value === void 0) {
+      const stored = await readStoredTransactionRecord(transaction, input.transactionId);
+      if (stored === void 0) {
         await transactionDone(transaction);
         return void 0;
       }
-      const current = asTransactionRecord(value, input.transactionId);
-      if (current.status !== "active" || current.ownerId !== input.expectedOwnerId || Date.parse(current.expiresAt) > cutoff) {
+      if (stored.status !== "active" || stored.ownerId !== input.expectedOwnerId || Date.parse(stored.expiresAt) > cutoff) {
         await transactionDone(transaction);
         return void 0;
       }
+      const current = await assembleTransactionRecord(transaction, stored);
       const updated = updateTransactionRecord(current, {
         status: "aborted",
         updatedAt: input.updatedAt,
         committedVersion: null
       });
       await assertTerminalTransactionAdmission(store);
-      store.put(updated, updated.id);
+      putStoredTransactionRecord(transaction, storedTransactionRecord(updated));
       await transactionDone(transaction);
       return structuredClone(updated);
     } catch (error) {
@@ -2551,9 +2597,7 @@ class IndexedDbBlockStore {
     validateId(input.transactionId, "Transaction ID");
     const transaction = this.#transaction(["blocks", "catalog", "segments", "statistics", "transactions"], "readwrite");
     try {
-      const transactionStore = transaction.objectStore("transactions");
-      const value = await requestResult(transactionStore.get(input.transactionId));
-      const current = value === void 0 ? void 0 : asTransactionRecord(value, input.transactionId);
+      const current = await readStoredTransactionRecord(transaction, input.transactionId);
       if (current?.revision !== input.expectedRevision || current.status !== "active") {
         throw new TransactionRecordConflictError(input.transactionId, input.expectedRevision, current?.revision ?? null);
       }
@@ -2577,7 +2621,7 @@ class IndexedDbBlockStore {
         if (normalized.transactionId !== input.transactionId) {
           throw new Error(`Segment ${normalized.id} belongs to another transaction`);
         }
-        const expectedCommitOrdinal = current.pendingSegmentIds.length + normalizedSegments.length;
+        const expectedCommitOrdinal = current.pendingSegmentCount + normalizedSegments.length;
         if (normalized.commitOrdinal !== expectedCommitOrdinal) {
           throw new TypeError(`Segment ${normalized.id} commit ordinal must be ${String(expectedCommitOrdinal)}`);
         }
@@ -2585,14 +2629,9 @@ class IndexedDbBlockStore {
         segmentIds.add(normalized.id);
         normalizedSegments.push(normalized);
       }
-      const update = {
-        pendingBlockIds: [...current.pendingBlockIds, ...input.blocks.map((block) => block.id)],
-        pendingSegmentIds: [
-          ...current.pendingSegmentIds,
-          ...normalizedSegments.map((segment) => segment.id)
-        ],
-        updatedAt: input.updatedAt
-      };
+      const addedBlockIds = input.blocks.map((block) => block.id);
+      const addedSegmentIds = normalizedSegments.map((segment) => segment.id);
+      const update = { updatedAt: input.updatedAt };
       if (current.pendingTable !== void 0) {
         let nextRowId = current.pendingTableNextRowId;
         if (nextRowId === void 0)
@@ -2606,16 +2645,17 @@ class IndexedDbBlockStore {
         update.pendingTableNextRowId = nextRowId;
       }
       assertGenericTransactionUpdateAllowed(current, update);
-      const updated = updateTransactionRecord(current, update);
-      assertTransactionArtifactJournalLimits(updated.pendingBlockIds, updated.pendingSegmentIds);
-      const updatedBlockIds = new Set(updated.pendingBlockIds);
+      const tail = await readTransactionJournalTail(transaction, current);
+      const journal = await this.#journaledIds(transaction, current, tail);
+      const rejournaled = addedBlockIds.find((id) => journal.blockIdSet.has(id));
+      if (rejournaled !== void 0)
+        throw new Error(`Block already exists: ${rejournaled}`);
       for (const segment of normalizedSegments) {
-        const unjournaledBlock = segmentBlockIds(segment).find((id) => !updatedBlockIds.has(id));
+        const unjournaledBlock = segmentBlockIds(segment).find((id) => !ids.has(id) && !journal.blockIdSet.has(id));
         if (unjournaledBlock !== void 0) {
           throw new Error(`Segment ${segment.id} references block absent from the transaction journal: ${unjournaledBlock}`);
         }
       }
-      await assertPendingArtifactsAvailableInTransaction(transaction, current);
       await updateTransactionResourceLedger(transaction.objectStore("statistics"), input.transactionId, {
         blockCount: input.blocks.length,
         segmentCount: normalizedSegments.length,
@@ -2635,15 +2675,43 @@ class IndexedDbBlockStore {
       for (const segment of normalizedSegments) {
         segmentStore.add(segment, segment.id);
       }
-      transactionStore.put(updated, input.transactionId);
+      const updated = {
+        ...appendTransactionJournalChunks(transaction, current, tail, addedBlockIds, addedSegmentIds),
+        ...update.pendingTableNextRowId === void 0 ? {} : { pendingTableNextRowId: update.pendingTableNextRowId },
+        updatedAt: input.updatedAt,
+        revision: incrementSafeInteger(current.revision, "Transaction revision")
+      };
+      putStoredTransactionRecord(transaction, updated);
       await transactionDone(transaction);
-      return structuredClone(updated);
+      for (const id of addedBlockIds) {
+        journal.blockIds.push(id);
+        journal.blockIdSet.add(id);
+      }
+      for (const id of addedSegmentIds)
+        journal.segmentIds.push(id);
+      journal.revision = updated.revision;
+      this.#journalCache = journal;
+      return transactionRecordWithJournal(updated, journal.blockIds, journal.segmentIds);
     } catch (error) {
       abortIfActive(transaction);
       await ignoreAbort(transaction);
       throw error;
     }
   }
+  async #journaledIds(transaction, stored, tail) {
+    const cached = this.#journalCache;
+    if (cached?.transactionId === stored.id && cached.revision === stored.revision && cached.blockIds.length === stored.pendingBlockCount && cached.segmentIds.length === stored.pendingSegmentCount && journalTailMatches(cached, tail)) {
+      return cached;
+    }
+    const record = await assembleTransactionRecord(transaction, stored);
+    return {
+      transactionId: record.id,
+      revision: record.revision,
+      blockIds: record.pendingBlockIds,
+      segmentIds: record.pendingSegmentIds,
+      blockIdSet: new Set(record.pendingBlockIds)
+    };
+  }
   async rollbackTransactionArtifacts(input) {
     validateId(input.transactionId, "Transaction ID");
     for (const id of [...input.pendingBlockIds, ...input.removeBlockIds]) {
@@ -2654,9 +2722,7 @@ class IndexedDbBlockStore {
     }
     const transaction = this.#transaction(["blocks", "catalog", "gc", "manifests", "segments", "statistics", "transactions"], "readwrite");
     try {
-      const transactionStore = transaction.objectStore("transactions");
-      const value = await requestResult(transactionStore.get(input.transactionId));
-      const current = value === void 0 ? void 0 : asTransactionRecord(value, input.transactionId);
+      const current = await readTransactionRecord(transaction, input.transactionId);
       if (current?.revision !== input.expectedRevision || current.status !== "active") {
         throw new TransactionRecordConflictError(input.transactionId, input.expectedRevision, current?.revision ?? null);
       }
@@ -2679,12 +2745,9 @@ class IndexedDbBlockStore {
       if (publishedBlock !== void 0) {
         throw corruption(`transactions/${input.transactionId}`, `rollback journal names block ${publishedBlock.blockId} reachable by manifest ${String(publishedBlock.version)}`);
       }
-      await visitObjectStoreSequentially(transactionStore, (recordValue, key) => {
-        if (typeof key !== "string")
-          throw corruption("transactions", "record key is invalid");
+      await visitTransactionRecords(transaction, (record, key) => {
         if (key === input.transactionId)
           return;
-        const record = asTransactionRecord(recordValue, key);
         const shared = record.pendingBlockIds.find((id) => removedBlocks.has(id));
         const sharedSegment = record.pendingSegmentIds.find((id) => removedSegments.has(id));
         if (shared !== void 0 || sharedSegment !== void 0) {
@@ -2744,7 +2807,7 @@ class IndexedDbBlockStore {
       let pendingTableNextRowId;
       if (current.pendingTable !== void 0) {
         const retained = await Promise.all(input.pendingSegmentIds.map((id) => requestResult(segmentStore.get(id))));
-        const retainedSegments = retained.map((value2) => value2 === void 0 ? void 0 : asSegmentRecord(value2)).filter((segment) => segment?.tableId === current.pendingTable?.id);
+        const retainedSegments = retained.map((value) => value === void 0 ? void 0 : asSegmentRecord(value)).filter((segment) => segment?.tableId === current.pendingTable?.id);
         pendingTableNextRowId = 1n;
         for (const segment of retainedSegments) {
           if (segment.kind !== "insert" || segment.rowIdStart !== pendingTableNextRowId) {
@@ -2774,8 +2837,15 @@ class IndexedDbBlockStore {
       }
       for (const id of input.removeSegmentIds)
         segmentStore.delete(id);
-      transactionStore.put(updated, input.transactionId);
+      putTransactionRecord(transaction, updated, journalChunkCountOf(current));
       await transactionDone(transaction);
+      this.#journalCache = {
+        transactionId: updated.id,
+        revision: updated.revision,
+        blockIds: [...updated.pendingBlockIds],
+        segmentIds: [...updated.pendingSegmentIds],
+        blockIdSet: new Set(updated.pendingBlockIds)
+      };
       return structuredClone(updated);
     } catch (error) {
       abortIfActive(transaction);
@@ -2805,7 +2875,7 @@ class IndexedDbBlockStore {
     const transaction = this.#transaction(storeNames2, "readwrite");
     try {
       const record = await readActiveTransactionRecord(transaction, input.transactionId, input.expectedTransactionRevision);
-      const outcome = await this.#commitInTransaction(transaction, record, input);
+      const outcome = await this.#commitInTransaction(transaction, record, "stored", input);
       await transactionDone(transaction);
       outcome.settle();
       return outcome.manifest;
@@ -2863,7 +2933,6 @@ class IndexedDbBlockStore {
       storeNames2.push("gc");
     const transaction = this.#transaction(storeNames2, "readwrite");
     try {
-      const transactionStore = transaction.objectStore("transactions");
       let base;
       if ("record" in input.transaction) {
         const id = input.transaction.record.id;
@@ -2871,7 +2940,7 @@ class IndexedDbBlockStore {
           ...input.transaction.record,
           snapshotVersion: input.expectedManifestVersion
         });
-        if (await requestResult(transactionStore.getKey(id)) !== void 0) {
+        if (await requestResult(transaction.objectStore("transactions").getKey(id)) !== void 0) {
           throw new Error(`Transaction already exists: ${id}`);
         }
         const current = asOptionalManifestVersion(await requestResult(transaction.objectStore("catalog").get(CURRENT_MANIFEST_KEY)), CURRENT_MANIFEST_KEY);
@@ -2917,7 +2986,13 @@ class IndexedDbBlockStore {
         stageUpdate.pendingTableNextRowId = nextRowId;
       }
       const staged = updateTransactionRecord(base, stageUpdate);
-      assertTransactionArtifactJournalLimits(staged.pendingBlockIds, staged.pendingSegmentIds);
+      const stagedBlockIds = new Set(staged.pendingBlockIds);
+      for (const segment of normalizedSegments) {
+        const unjournaledBlock = segmentBlockIds(segment).find((id) => !stagedBlockIds.has(id));
+        if (unjournaledBlock !== void 0) {
+          throw new Error(`Segment ${segment.id} references block absent from the transaction journal: ${unjournaledBlock}`);
+        }
+      }
       await assertPendingArtifactsAvailableInTransaction(transaction, base);
       await updateRecordResourceLedger(transaction.objectStore("statistics"), {
         segments: normalizedSegments.map((segment) => ({ next: segment }))
@@ -2933,7 +3008,7 @@ class IndexedDbBlockStore {
       for (const segment of normalizedSegments) {
         segmentStore.add(segment, segment.id);
       }
-      const outcome = await this.#commitInTransaction(transaction, staged, input);
+      const outcome = await this.#commitInTransaction(transaction, staged, { replacedChunkCount: journalChunkCountOf(base) }, input);
       await transactionDone(transaction);
       outcome.settle();
       return outcome.manifest;
@@ -2943,7 +3018,7 @@ class IndexedDbBlockStore {
       throw error;
     }
   }
-  async #commitInTransaction(transaction, record, input) {
+  async #commitInTransaction(transaction, record, journal, input) {
     incrementSafeInteger(record.revision, "Transaction revision");
     const transactionStore = transaction.objectStore("transactions");
     const catalog = transaction.objectStore("catalog");
@@ -3378,7 +3453,11 @@ class IndexedDbBlockStore {
     if (ftsDeltaCounts.length > 0)
       manifest.ftsDeltaCounts = ftsDeltaCounts;
     await clearTransactionResourceLedger(transaction.objectStore("statistics"), committed.id);
-    transactionStore.put(committed, committed.id);
+    if (journal === "stored") {
+      putStoredTransactionRecord(transaction, storedTransactionRecord(committed));
+    } else {
+      putTransactionRecord(transaction, committed, journal.replacedChunkCount);
+    }
     const settle = () => {
       if (pendingTable !== void 0) {
         this.#tableIdsByName.set(pendingTable.name, pendingTable.id);
@@ -3439,6 +3518,7 @@ class IndexedDbBlockStore {
         this.#uniqueKeyCache.version = manifest.version;
       }
       this.#manifestCache = void 0;
+      this.#journalCache = void 0;
     };
     return { manifest, settle };
   }
@@ -3776,8 +3856,7 @@ class IndexedDbBlockStore {
     }
     await assertActiveCompactionMarker(jobStore, current);
     incrementSafeInteger(current.revision, "Compaction job revision");
-    const transactionValue = current.transactionId === null ? void 0 : await requestResult(transactionStore.get(current.transactionId));
-    const linkedTransaction = transactionValue === void 0 ? void 0 : asTransactionRecord(transactionValue);
+    const linkedTransaction = current.transactionId === null ? void 0 : await readTransactionRecord(transaction, current.transactionId);
     let updated;
     let updatedLinkedTransaction;
     try {
@@ -3815,7 +3894,7 @@ class IndexedDbBlockStore {
     const terminalCompactionJobs = checkedQuotaIncrement(quota.terminalCompactionJobs, "Terminal compaction job count");
     assertMaintenanceLimit("terminal compaction job", terminalCompactionJobs, MAX_TERMINAL_COMPACTION_JOB_RECORDS);
     if (updatedLinkedTransaction !== void 0) {
-      transactionStore.put(updatedLinkedTransaction, updatedLinkedTransaction.id);
+      putStoredTransactionRecord(transaction, storedTransactionRecord(updatedLinkedTransaction));
     }
     jobStore.put(compactionJobEnvelope(updated), key);
     jobStore.put({
@@ -3984,7 +4063,6 @@ class IndexedDbBlockStore {
       const manifestStore = transaction.objectStore("manifests");
       const segmentStore = transaction.objectStore("segments");
       const blockStore = transaction.objectStore("blocks");
-      const transactionStore = transaction.objectStore("transactions");
       const currentVersionValue = await requestResult(catalog.get(CURRENT_MANIFEST_KEY));
       const currentVersion = asOptionalManifestVersion(currentVersionValue, CURRENT_MANIFEST_KEY) ?? null;
       const leaseCutoff = Date.parse(current.leaseCutoff);
@@ -4082,8 +4160,7 @@ class IndexedDbBlockStore {
           if (id === void 0) {
             throw new Error("Garbage collection transaction cursor is invalid");
           }
-          const transactionValue = await requestResult(transactionStore.get(id));
-          const record = transactionValue === void 0 ? void 0 : asTransactionRecord(transactionValue, id);
+          const record = await readTransactionRecord(transaction, id);
           const manifestValue = record?.committedVersion === null || record?.committedVersion === void 0 ? void 0 : await requestResult(manifestStore.get(record.committedVersion));
           const manifest = manifestValue === void 0 ? void 0 : asStoredManifestRecord(manifestValue, record?.committedVersion ?? void 0);
           if (record === void 0)
@@ -4092,7 +4169,9 @@ class IndexedDbBlockStore {
             retainedTransactionIds.push(id);
           } else {
             await clearTransactionResourceLedger(transaction.objectStore("statistics"), id);
-            transactionStore.delete(id);
+            deleteTransactionRecord(transaction, storedTransactionRecord(record));
+            if (this.#journalCache?.transactionId === id)
+              this.#journalCache = void 0;
             reclaimedTransactionIds.push(id);
           }
           transactionIndex += 1;
@@ -4339,6 +4418,7 @@ class IndexedDbBlockStore {
       this.#tableIdsByName.clear();
       this.#uniqueKeyCache = void 0;
       this.#manifestCache = void 0;
+      this.#journalCache = void 0;
       return {
         identity,
         removedBlockCount: marker.kindItemCounts[SNAPSHOT_FRAME_KINDS.indexOf("block")] ?? 0,
@@ -4899,11 +4979,10 @@ class IndexedDbBlockStore {
         observedSegmentBytes = safeByteSum(observedSegmentBytes, segmentRecordRetainedBytes(segment), "Integrity segment bytes");
         if (segment.id !== key)
           throw corruption(`segments/${key}`, "record id differs from key");
-        const ownerValue = await requestResult(transactionStore.get(segment.transactionId));
-        if (ownerValue === void 0) {
+        const owner = await readTransactionRecord(transaction, segment.transactionId);
+        if (owner === void 0) {
           throw corruption(`segments/${key}`, `owning transaction ${segment.transactionId} is missing`);
         }
-        const owner = asTransactionRecord(ownerValue, segment.transactionId);
         const segmentTable = tablesById.get(segment.tableId) ?? (owner.status === "active" && owner.pendingTable?.id === segment.tableId ? owner.pendingTable : void 0);
         if (segmentTable === void 0) {
           throw corruption(`segments/${key}`, `table ${segment.tableId} is missing`);
@@ -4932,7 +5011,7 @@ class IndexedDbBlockStore {
       try {
         if (typeof key !== "string")
           throw corruption("transactions", "record key is invalid");
-        const record = asTransactionRecord(value, key);
+        const record = await assembleTransactionRecord(transaction, asStoredTransactionRecord(value, key));
         for (const [commitOrdinal, segmentId] of record.pendingSegmentIds.entries()) {
           const segmentValue = await requestResult(segmentStore.get(segmentId));
           if (segmentValue === void 0) {
@@ -4961,13 +5040,7 @@ class IndexedDbBlockStore {
             if (alreadyLive) {
               throw corruption(`transactions/${key}`, `pending block ${blockId} is already live in the current manifest`);
             }
-            const journaledByAnotherActiveTransaction = await visitObjectStoreSequentially(transactionStore, (candidateValue, candidateKey) => {
-              if (typeof candidateKey !== "string") {
-                throw corruption("transactions", "record key is invalid");
-              }
-              const candidate = asTransactionRecord(candidateValue, candidateKey);
-              return candidate.id !== record.id && candidate.status === "active" && candidate.pendingBlockIds.includes(blockId);
-            });
+            const journaledByAnotherActiveTransaction = await visitTransactionRecords(transaction, (candidate) => candidate.id !== record.id && candidate.status === "active" && candidate.pendingBlockIds.includes(blockId));
             if (journaledByAnotherActiveTransaction) {
               throw corruption(`transactions/${key}`, `pending block ${blockId} is journaled by another active transaction`);
             }
@@ -5053,6 +5126,25 @@ class IndexedDbBlockStore {
     } catch (error) {
       issue("invalid-pending-catalog", "transactions", error);
     }
+    await visitObjectStoreSequentially(transaction.objectStore(TRANSACTION_JOURNAL_STORE), async (value, key) => {
+      checkedRecords += 1;
+      try {
+        if (!Array.isArray(key) || key.length !== 2 || typeof key[0] !== "string" || typeof key[1] !== "number" || !Number.isSafeInteger(key[1]) || key[1] < 0) {
+          throw corruption(TRANSACTION_JOURNAL_STORE, "journal chunk key is invalid");
+        }
+        const [transactionId, chunkIndex] = key;
+        asTransactionJournalChunk(value, `transactions/${transactionId}/journal/${String(chunkIndex)}`);
+        const owner = await readStoredTransactionRecord(transaction, transactionId);
+        if (owner === void 0) {
+          throw corruption(`transactions/${transactionId}`, `journal chunk ${String(chunkIndex)} has no transaction record`);
+        }
+        if (chunkIndex >= owner.journalChunkCount) {
+          throw corruption(`transactions/${transactionId}`, `journal chunk ${String(chunkIndex)} lies beyond the declared ${String(owner.journalChunkCount)}`);
+        }
+      } catch (error) {
+        issue("orphan-transaction-journal", storageKeyLocation(key), error);
+      }
+    });
     const leaseIds = /* @__PURE__ */ new Set();
     await visitObjectStoreSequentially(transaction.objectStore("leases"), async (value, key) => {
       checkedRecords += 1;
@@ -5115,11 +5207,10 @@ class IndexedDbBlockStore {
               }
             }
             if (job.transactionId !== null) {
-              const transactionValue = await requestResult(transactionStore.get(job.transactionId));
-              if (transactionValue === void 0) {
+              const owner = await readTransactionRecord(transaction, job.transactionId);
+              if (owner === void 0) {
                 throw corruption(`gc/${key}`, "linked transaction is missing");
               }
-              const owner = asTransactionRecord(transactionValue, job.transactionId);
               if (job.state === "ready" || owner.pendingSegmentIds.length > 0) {
                 const table = tablesById.get(job.tableId);
                 if (table === void 0)
@@ -5164,11 +5255,8 @@ class IndexedDbBlockStore {
             if (candidate !== void 0)
               asBytes(candidate, `blocks/${id}`);
           }
-          for (const id of job.candidateTransactionIds) {
-            const candidate = await requestResult(transactionStore.get(id));
-            if (candidate !== void 0)
-              asTransactionRecord(candidate, id);
-          }
+          for (const id of job.candidateTransactionIds)
+            await readTransactionRecord(transaction, id);
         } else if (key.startsWith(ACTIVE_COMPACTION_KEY_PREFIX)) {
           let tableId;
           try {
@@ -5359,11 +5447,10 @@ class IndexedDbBlockStore {
         const ledger = asOptionalTransactionResourceLedger(value, transactionId);
         if (ledger === void 0)
           throw corruption(`statistics/${key}`, "transaction ledger is missing");
-        const transactionValue = await requestResult(transactionStore.get(transactionId));
-        if (transactionValue === void 0) {
+        const owner = await readTransactionRecord(transaction, transactionId);
+        if (owner === void 0) {
           throw corruption(`statistics/${key}`, "transaction resource ledger has no transaction");
         }
-        const owner = asTransactionRecord(transactionValue, transactionId);
         if (owner.status === "committed" || ledger.blockCount !== owner.pendingBlockIds.length || ledger.segmentCount !== owner.pendingSegmentIds.length) {
           throw corruption(`statistics/${key}`, "transaction resource ledger disagrees with its journal");
         }
@@ -5739,6 +5826,7 @@ class IndexedDbBlockStore {
         transaction.objectStore("manifests").clear();
         transaction.objectStore("segments").clear();
         transaction.objectStore("transactions").clear();
+        transaction.objectStore(TRANSACTION_JOURNAL_STORE).clear();
         transaction.objectStore(SNAPSHOT_HEADER_STORE).clear();
         const statistics = transaction.objectStore("statistics");
         statistics.clear();
@@ -5964,6 +6052,7 @@ class IndexedDbBlockStore {
       this.#tableIdsByName.clear();
       this.#uniqueKeyCache = void 0;
       this.#manifestCache = void 0;
+      this.#journalCache = void 0;
     } catch (error) {
       abortIfActive(transaction);
       await ignoreAbort(transaction);
@@ -6002,6 +6091,7 @@ class IndexedDbBlockStore {
       this.#tableIdsByName.clear();
       this.#uniqueKeyCache = void 0;
       this.#manifestCache = void 0;
+      this.#journalCache = void 0;
       return {
         identity: marker.identity,
         removedBlockCount: marker.kindItemCounts[SNAPSHOT_FRAME_KINDS.indexOf("block")] ?? 0,
@@ -6020,6 +6110,7 @@ class IndexedDbBlockStore {
     this.#tableIdsByName.clear();
     this.#uniqueKeyCache = void 0;
     this.#manifestCache = void 0;
+    this.#journalCache = void 0;
     this.#db.close();
   }
   _residentStateForTests() {
@@ -6306,9 +6397,10 @@ class IndexedDbBlockStore {
   #transaction(stores, mode, options = {}) {
     if (this.#closed)
       throw new Error("This IndexedDB store connection is closed");
-    const transaction = mode === "readwrite" ? this.#db.transaction(stores, mode, { durability: this.#durability }) : this.#db.transaction(stores, mode);
+    const requested = typeof stores === "string" ? [stores] : stores;
+    const storeList = requested.includes("transactions") && !requested.includes(TRANSACTION_JOURNAL_STORE) ? [...requested, TRANSACTION_JOURNAL_STORE] : requested;
+    const transaction = mode === "readwrite" ? this.#db.transaction(storeList, mode, { durability: this.#durability }) : this.#db.transaction(storeList, mode);
     void transactionDone(transaction).catch(() => void 0);
-    const storeList = typeof stores === "string" ? [stores] : stores;
     if (mode === "readwrite" && !options.allowSnapshotImport && storeList.includes("catalog")) {
       const catalog = transaction.objectStore("catalog");
       const marker = catalog.get(SNAPSHOT_FRAME_IMPORT_KEY);
@@ -6333,9 +6425,8 @@ function assertIndexedDbSchemaMigrationRegistry() {
   }
 }
 function createCurrentIndexedDbSchema(database, upgrade) {
-  for (const storeName of storeNames)
+  for (const storeName of indexedDbStoreNames)
     database.createObjectStore(storeName);
-  database.createObjectStore(SNAPSHOT_HEADER_STORE);
   for (const [storeName, indexes] of Object.entries(indexedDbIndexSchema)) {
     const store = upgrade.objectStore(storeName);
     for (const index of indexes) {
@@ -6348,10 +6439,10 @@ function createCurrentIndexedDbSchema(database, upgrade) {
   upgrade.objectStore("statistics").add(emptyCatalogResourceLedger(), CATALOG_RESOURCE_LEDGER_KEY);
   upgrade.objectStore("statistics").add(emptyRecordResourceLedger(), RECORD_RESOURCE_LEDGER_KEY);
 }
-function applyIndexedDbSchemaMigrations(database, upgrade, oldVersion) {
+function applyIndexedDbSchemaMigrations(database, upgrade, oldVersion, fail) {
   for (const migration of indexedDbSchemaMigrations) {
     if (migration.targetVersion > oldVersion)
-      migration.migrate(database, upgrade);
+      migration.migrate(database, upgrade, fail);
   }
 }
 const indexedDbIndexSchema = {
@@ -6791,7 +6882,7 @@ async function assertTableRemovalAllowed(transaction, tableId, expectedRevision)
   const segments = await readTableSegmentsForRemoval(transaction.objectStore("segments").index(SEGMENT_TABLE_INDEX), tableId);
   const transactionStore = transaction.objectStore("transactions");
   await visitObjectStoreSequentially(transactionStore, (candidateValue, key) => {
-    const candidate = asTransactionRecord(candidateValue, storageKeyLocation(key));
+    const candidate = asStoredTransactionRecord(candidateValue, storageKeyLocation(key));
     const pendingTable = candidate.status === "active" ? candidate.pendingTable : void 0;
     const foreignKey = (pendingTable?.foreignKeys ?? []).find((constraint) => constraint.parentTable === record.name);
     if (foreignKey !== void 0) {
@@ -6803,11 +6894,10 @@ async function assertTableRemovalAllowed(transaction, tableId, expectedRevision)
   for (const segment of segments) {
     let owner = owners.get(segment.transactionId);
     if (owner === void 0) {
-      const ownerValue = await requestResult(transactionStore.get(segment.transactionId));
-      if (ownerValue === void 0) {
+      owner = await readStoredTransactionRecord(transaction, segment.transactionId);
+      if (owner === void 0) {
         throw corruption(`segments/${segment.id}`, `references missing transaction ${segment.transactionId}`);
       }
-      owner = asTransactionRecord(ownerValue, segment.transactionId);
       owners.set(segment.transactionId, owner);
     }
     if (owner.status === "active")
@@ -7099,6 +7189,9 @@ function requiredUniqueStringArray(value, location) {
   }
   return [...value];
 }
+function extendsJournalOrder(current, updated) {
+  return current.length <= updated.length && current.every((id, index) => updated[index] === id);
+}
 function validateArtifactPartition(retained, removed, current) {
   if (retained.length + removed.length !== current.length)
     return false;
@@ -7813,7 +7906,7 @@ async function stageSnapshotMetadataFrame(transaction, frame) {
       await assertCatalogReservationAdmission(transaction, record.pendingTable);
       await assertTableForeignKeysInTransaction(catalog, record.pendingTable);
     }
-    transaction.objectStore("transactions").add(record, record.id);
+    addTransactionRecord(transaction, record);
     return;
   }
   if (item.kind === "unique-generation") {
@@ -7900,7 +7993,6 @@ async function readSnapshotGenerationId(catalog, key, label) {
 async function validateAndPromoteStagedSnapshot(transaction, marker) {
   const catalog = transaction.objectStore("catalog");
   const segments = transaction.objectStore("segments");
-  const transactions = transaction.objectStore("transactions");
   const blocks = transaction.objectStore("blocks");
   await visitObjectStoreSequentially(catalog, async (value, key) => {
     if (typeof key !== "string" || !key.startsWith(TABLE_ID_PREFIX))
@@ -7942,10 +8034,7 @@ async function validateAndPromoteStagedSnapshot(transaction, marker) {
       asSnapshotPostingStagingRecord(await requestResult(catalog.get(snapshotPostingStagingKey(generationId))), generationId);
     }
   });
-  await visitObjectStoreSequentially(transactions, (value, key) => {
-    if (typeof key !== "string")
-      throw corruption("transactions", "snapshot transaction key is invalid");
-    const record = asTransactionRecord(value, key);
+  await visitTransactionRecords(transaction, (record, key) => {
     if (record.status !== "committed" || record.committedVersion === null || record.committedVersion > marker.version || record.pendingBlockIds.length !== 0 || record.pendingSegmentIds.length !== 0) {
       throw corruption(`transactions/${key}`, "snapshot transaction is not canonical committed history");
     }
@@ -7959,10 +8048,9 @@ async function validateAndPromoteStagedSnapshot(transaction, marker) {
     if (await requestResult(catalog.getKey(`${TABLE_ID_PREFIX}${segment.tableId}`)) === void 0) {
       throw corruption(`segments/${key}`, "snapshot segment table is missing");
     }
-    const ownerValue = await requestResult(transactions.get(segment.transactionId));
-    if (ownerValue === void 0)
+    if (await readTransactionRecord(transaction, segment.transactionId) === void 0) {
       throw corruption(`segments/${key}`, "snapshot segment owner is missing");
-    asTransactionRecord(ownerValue, segment.transactionId);
+    }
     for (const blockId of segmentBlockIds(segment)) {
       const provenance = asManifestBlockRecord(await requestResult(catalog.get(manifestBlockKey(blockId))), blockId);
       if (!manifestBlockVisibleAt(provenance, marker.version)) {
@@ -8242,10 +8330,9 @@ async function writeSnapshotMetadataFramesInTransaction(input) {
   });
   await visitObjectStoreSequentially(input.transaction.objectStore("segments"), async (value) => {
     const record = asSegmentRecord(value);
-    const ownerValue = await requestResult(input.transaction.objectStore("transactions").get(record.transactionId));
-    if (ownerValue === void 0)
+    const owner = await readStoredTransactionRecord(input.transaction, record.transactionId);
+    if (owner === void 0)
       return;
-    const owner = asTransactionRecord(ownerValue, record.transactionId);
     if (owner.status !== "committed" || owner.committedVersion === null || owner.committedVersion > input.version) {
       return;
     }
@@ -8261,14 +8348,14 @@ async function writeSnapshotMetadataFramesInTransaction(input) {
   await visitObjectStoreSequentially(input.transaction.objectStore("transactions"), (value, key) => {
     if (typeof key !== "string")
       throw corruption("transactions", "record key is invalid");
-    const record = asTransactionRecord(value, key);
+    const record = asStoredTransactionRecord(value, key);
     if (record.status !== "committed" || record.committedVersion === null || record.committedVersion > input.version) {
       return;
     }
     input.observeRetainedItems(1);
     writeItem("transaction-page", {
       kind: "transaction",
-      record: { ...record, pendingBlockIds: [], pendingSegmentIds: [] }
+      record: transactionRecordWithJournal(record, [], [])
     });
   });
   await visitTables(async (table) => {
@@ -8510,34 +8597,74 @@ async function findReadableManifestBlock(transaction, ids, excludedVersions = /*
   });
   return found;
 }
-function asTransactionRecord(value, expectedId) {
+function journalTailMatches(cached, tail) {
+  if (tail === void 0)
+    return cached.blockIds.length === 0 && cached.segmentIds.length === 0;
+  const endsWith = (ids, suffix) => suffix.every((id, index) => ids[ids.length - suffix.length + index] === id);
+  return endsWith(cached.blockIds, tail.blockIds) && endsWith(cached.segmentIds, tail.segmentIds);
+}
+const TRANSACTION_RECORD_FIELDS = [
+  "id",
+  "ownerId",
+  "expiresAt",
+  "snapshotVersion",
+  "status",
+  "revision",
+  "startedAt",
+  "updatedAt",
+  "committedVersion",
+  "schemaEpochGuard",
+  "pendingTable",
+  "pendingTableNextRowId",
+  "catalogEpochGuard"
+];
+function transactionJournalChunkKey(transactionId, chunkIndex) {
+  return [transactionId, chunkIndex];
+}
+function transactionJournalEntryCount(blockCount, segmentCount) {
+  const total = blockCount + segmentCount;
+  if (!Number.isSafeInteger(total))
+    throw new RangeError("Transaction journal is too large");
+  return total;
+}
+function transactionJournalChunkCount(blockCount, segmentCount) {
+  return Math.ceil(transactionJournalEntryCount(blockCount, segmentCount) / TRANSACTION_JOURNAL_CHUNK_ENTRIES);
+}
+function journalChunkCountOf(record) {
+  return transactionJournalChunkCount(record.pendingBlockIds.length, record.pendingSegmentIds.length);
+}
+function packTransactionJournal(blockIds, segmentIds) {
+  const chunks = [];
+  let blockOffset = 0;
+  let segmentOffset = 0;
+  while (blockOffset < blockIds.length || segmentOffset < segmentIds.length) {
+    const blocks = blockIds.slice(blockOffset, blockOffset + TRANSACTION_JOURNAL_CHUNK_ENTRIES);
+    blockOffset += blocks.length;
+    const segments = segmentIds.slice(segmentOffset, segmentOffset + TRANSACTION_JOURNAL_CHUNK_ENTRIES - blocks.length);
+    segmentOffset += segments.length;
+    chunks.push({ blockIds: blocks, segmentIds: segments });
+  }
+  return chunks;
+}
+function asTransactionJournalChunk(value, location) {
   if (!isRecord(value))
-    throw corruption("transactions", "record is not an object");
-  assertKnownFields(value, [
-    "id",
-    "ownerId",
-    "expiresAt",
-    "snapshotVersion",
-    "pendingBlockIds",
-    "pendingSegmentIds",
-    "status",
-    "revision",
-    "startedAt",
-    "updatedAt",
-    "committedVersion",
-    "schemaEpochGuard",
-    "pendingTable",
-    "pendingTableNextRowId",
-    "catalogEpochGuard"
-  ], "transactions");
+    throw corruption(location, "journal chunk is not an object");
+  assertKnownFields(value, ["blockIds", "segmentIds"], location);
+  const blockIds = requiredUniqueStringArray(value.blockIds, `${location}/blockIds`);
+  const segmentIds = requiredUniqueStringArray(value.segmentIds, `${location}/segmentIds`);
+  const entries = blockIds.length + segmentIds.length;
+  if (entries === 0 || entries > TRANSACTION_JOURNAL_CHUNK_ENTRIES) {
+    throw corruption(location, `journal chunk holds ${String(entries)} ids`);
+  }
+  return { blockIds, segmentIds };
+}
+function asTransactionRecordBase(value, expectedId) {
   const id = nonEmptyStoredString(value.id, "transactions/id");
   if (expectedId !== void 0 && id !== expectedId) {
     throw corruption(`transactions/${expectedId}`, `record declares id ${id}`);
   }
   const snapshotVersion = asNullableStoredVersion(value.snapshotVersion, `transactions/${id}/snapshotVersion`);
   const committedVersion = asNullableStoredVersion(value.committedVersion, `transactions/${id}/committedVersion`);
-  const pendingBlockIds = requiredUniqueStringArray(value.pendingBlockIds, `transactions/${id}/pendingBlockIds`);
-  const pendingSegmentIds = requiredUniqueStringArray(value.pendingSegmentIds, `transactions/${id}/pendingSegmentIds`);
   if (!["active", "committed", "aborted"].includes(value.status)) {
     throw corruption(`transactions/${id}/status`, "status is invalid");
   }
@@ -8568,8 +8695,6 @@ function asTransactionRecord(value, expectedId) {
     ownerId,
     expiresAt,
     snapshotVersion,
-    pendingBlockIds,
-    pendingSegmentIds,
     status,
     revision,
     startedAt,
@@ -8584,6 +8709,185 @@ function asTransactionRecord(value, expectedId) {
   }
   return { ...base, pendingTable, pendingTableNextRowId, catalogEpochGuard };
 }
+function asTransactionRecord(value, expectedId) {
+  if (!isRecord(value))
+    throw corruption("transactions", "record is not an object");
+  assertKnownFields(value, [...TRANSACTION_RECORD_FIELDS, "pendingBlockIds", "pendingSegmentIds"], "transactions");
+  const base = asTransactionRecordBase(value, expectedId);
+  const pendingBlockIds = requiredUniqueStringArray(value.pendingBlockIds, `transactions/${base.id}/pendingBlockIds`);
+  const pendingSegmentIds = requiredUniqueStringArray(value.pendingSegmentIds, `transactions/${base.id}/pendingSegmentIds`);
+  transactionJournalEntryCount(pendingBlockIds.length, pendingSegmentIds.length);
+  return { ...base, pendingBlockIds, pendingSegmentIds };
+}
+function asStoredTransactionRecord(value, expectedId) {
+  if (!isRecord(value))
+    throw corruption("transactions", "record is not an object");
+  assertKnownFields(value, [...TRANSACTION_RECORD_FIELDS, "journalChunkCount", "pendingBlockCount", "pendingSegmentCount"], "transactions");
+  const base = asTransactionRecordBase(value, expectedId);
+  const pendingBlockCount = nonNegativeStoredInteger(value.pendingBlockCount, `transactions/${base.id}/pendingBlockCount`);
+  const pendingSegmentCount = nonNegativeStoredInteger(value.pendingSegmentCount, `transactions/${base.id}/pendingSegmentCount`);
+  const journalChunkCount = nonNegativeStoredInteger(value.journalChunkCount, `transactions/${base.id}/journalChunkCount`);
+  let expectedChunkCount;
+  try {
+    expectedChunkCount = transactionJournalChunkCount(pendingBlockCount, pendingSegmentCount);
+  } catch {
+    throw corruption(`transactions/${base.id}`, "journal counts are unsafe");
+  }
+  if (journalChunkCount !== expectedChunkCount) {
+    throw corruption(`transactions/${base.id}/journalChunkCount`, `chunk count ${String(journalChunkCount)} disagrees with ${String(pendingBlockCount)} blocks and ${String(pendingSegmentCount)} segments`);
+  }
+  return { ...base, journalChunkCount, pendingBlockCount, pendingSegmentCount };
+}
+function storedTransactionRecord(record) {
+  const { pendingBlockIds, pendingSegmentIds, ...header } = record;
+  return {
+    ...header,
+    journalChunkCount: journalChunkCountOf(record),
+    pendingBlockCount: pendingBlockIds.length,
+    pendingSegmentCount: pendingSegmentIds.length
+  };
+}
+function transactionRecordWithJournal(stored, pendingBlockIds, pendingSegmentIds) {
+  const { journalChunkCount: _chunkCount, pendingBlockCount: _blockCount, pendingSegmentCount: _segmentCount, ...header } = stored;
+  void _chunkCount;
+  void _blockCount;
+  void _segmentCount;
+  return {
+    ...header,
+    pendingBlockIds: [...pendingBlockIds],
+    pendingSegmentIds: [...pendingSegmentIds]
+  };
+}
+function transactionRecordFromJournal(stored, chunks) {
+  const location = `transactions/${stored.id}`;
+  if (chunks.length !== stored.journalChunkCount) {
+    throw corruption(location, "journal chunk count disagrees with its record");
+  }
+  const pendingBlockIds = [];
+  const pendingSegmentIds = [];
+  for (const [index, chunk] of chunks.entries()) {
+    const entries = chunk.blockIds.length + chunk.segmentIds.length;
+    if (index < chunks.length - 1 && entries !== TRANSACTION_JOURNAL_CHUNK_ENTRIES) {
+      throw corruption(`${location}/journal/${String(index)}`, "journal chunk is not packed");
+    }
+    for (const id of chunk.blockIds)
+      pendingBlockIds.push(id);
+    for (const id of chunk.segmentIds)
+      pendingSegmentIds.push(id);
+  }
+  if (pendingBlockIds.length !== stored.pendingBlockCount || pendingSegmentIds.length !== stored.pendingSegmentCount) {
+    throw corruption(location, "journal counts disagree with its chunks");
+  }
+  if (new Set(pendingBlockIds).size !== pendingBlockIds.length || new Set(pendingSegmentIds).size !== pendingSegmentIds.length) {
+    throw corruption(location, "journal repeats an id");
+  }
+  return transactionRecordWithJournal(stored, pendingBlockIds, pendingSegmentIds);
+}
+async function readTransactionJournalChunk(journalStore, transactionId, chunkIndex) {
+  const value = await requestResult(journalStore.get(transactionJournalChunkKey(transactionId, chunkIndex)));
+  return value === void 0 ? void 0 : asTransactionJournalChunk(value, `transactions/${transactionId}/journal/${String(chunkIndex)}`);
+}
+async function readTransactionJournalChunks(transaction, stored) {
+  const journalStore = transaction.objectStore(TRANSACTION_JOURNAL_STORE);
+  const values = await Promise.all(Array.from({ length: stored.journalChunkCount + 1 }, (_, index) => readTransactionJournalChunk(journalStore, stored.id, index)));
+  const extra = values.pop();
+  if (extra !== void 0) {
+    throw corruption(`transactions/${stored.id}`, "journal has more chunks than its record declares");
+  }
+  return values.map((chunk, index) => {
+    if (chunk === void 0) {
+      throw corruption(`transactions/${stored.id}/journal/${String(index)}`, "chunk is missing");
+    }
+    return chunk;
+  });
+}
+async function assembleTransactionRecord(transaction, stored) {
+  return transactionRecordFromJournal(stored, await readTransactionJournalChunks(transaction, stored));
+}
+async function readStoredTransactionRecord(transaction, id) {
+  const value = await requestResult(transaction.objectStore("transactions").get(id));
+  return value === void 0 ? void 0 : asStoredTransactionRecord(value, id);
+}
+async function readTransactionRecord(transaction, id) {
+  const stored = await readStoredTransactionRecord(transaction, id);
+  return stored === void 0 ? void 0 : assembleTransactionRecord(transaction, stored);
+}
+async function readTransactionRecords(transaction, ids) {
+  const stored = await Promise.all(ids.map((id) => readStoredTransactionRecord(transaction, id)));
+  return Promise.all(stored.map((record) => record === void 0 ? Promise.resolve(void 0) : assembleTransactionRecord(transaction, record)));
+}
+function visitTransactionRecords(transaction, visit) {
+  return visitObjectStoreSequentially(transaction.objectStore("transactions"), async (value, key) => {
+    if (typeof key !== "string")
+      throw corruption("transactions", "record key is invalid");
+    const record = await assembleTransactionRecord(transaction, asStoredTransactionRecord(value, key));
+    return visit(record, key);
+  });
+}
+function visitActiveTransactionRecords(transaction, visit) {
+  return visitIndexPartitionSequentially(transaction.objectStore("transactions").index(TRANSACTION_STATUS_INDEX), "active", async (value, key) => {
+    if (typeof key !== "string")
+      throw corruption("transactions", "record key is invalid");
+    const record = await assembleTransactionRecord(transaction, asStoredTransactionRecord(value, key));
+    return visit(record, key);
+  });
+}
+function putStoredTransactionRecord(transaction, stored) {
+  transaction.objectStore("transactions").put(stored, stored.id);
+}
+function putTransactionRecord(transaction, record, replacedChunkCount) {
+  const journalStore = transaction.objectStore(TRANSACTION_JOURNAL_STORE);
+  const chunks = packTransactionJournal(record.pendingBlockIds, record.pendingSegmentIds);
+  for (let index = chunks.length; index < replacedChunkCount; index += 1) {
+    journalStore.delete(transactionJournalChunkKey(record.id, index));
+  }
+  chunks.forEach((chunk, index) => {
+    journalStore.put(chunk, transactionJournalChunkKey(record.id, index));
+  });
+  putStoredTransactionRecord(transaction, storedTransactionRecord(record));
+}
+function addTransactionRecord(transaction, record) {
+  transaction.objectStore("transactions").add(storedTransactionRecord(record), record.id);
+  const journalStore = transaction.objectStore(TRANSACTION_JOURNAL_STORE);
+  packTransactionJournal(record.pendingBlockIds, record.pendingSegmentIds).forEach((chunk, index) => {
+    journalStore.put(chunk, transactionJournalChunkKey(record.id, index));
+  });
+}
+function deleteTransactionRecord(transaction, stored) {
+  const journalStore = transaction.objectStore(TRANSACTION_JOURNAL_STORE);
+  for (let index = 0; index < stored.journalChunkCount; index += 1) {
+    journalStore.delete(transactionJournalChunkKey(stored.id, index));
+  }
+  transaction.objectStore("transactions").delete(stored.id);
+}
+async function readTransactionJournalTail(transaction, stored) {
+  const lastIndex = stored.journalChunkCount - 1;
+  if (lastIndex < 0)
+    return void 0;
+  const tail = await readTransactionJournalChunk(transaction.objectStore(TRANSACTION_JOURNAL_STORE), stored.id, lastIndex);
+  if (tail === void 0) {
+    throw corruption(`transactions/${stored.id}/journal/${String(lastIndex)}`, "chunk is missing");
+  }
+  return tail;
+}
+function appendTransactionJournalChunks(transaction, stored, tail, addedBlockIds, addedSegmentIds) {
+  const journalStore = transaction.objectStore(TRANSACTION_JOURNAL_STORE);
+  const lastIndex = stored.journalChunkCount - 1;
+  const pendingBlockCount = stored.pendingBlockCount + addedBlockIds.length;
+  const pendingSegmentCount = stored.pendingSegmentCount + addedSegmentIds.length;
+  const journalChunkCount = transactionJournalChunkCount(pendingBlockCount, pendingSegmentCount);
+  const tailEntries = tail === void 0 ? 0 : tail.blockIds.length + tail.segmentIds.length;
+  const topUp = tail !== void 0 && tailEntries < TRANSACTION_JOURNAL_CHUNK_ENTRIES;
+  const firstIndex = topUp ? lastIndex : lastIndex + 1;
+  const chunks = packTransactionJournal([...topUp ? tail.blockIds : [], ...addedBlockIds], [...topUp ? tail.segmentIds : [], ...addedSegmentIds]);
+  if (firstIndex + chunks.length !== journalChunkCount) {
+    throw corruption(`transactions/${stored.id}`, "journal append does not reach the chunk count");
+  }
+  chunks.forEach((chunk, offset) => {
+    journalStore.put(chunk, transactionJournalChunkKey(stored.id, firstIndex + offset));
+  });
+  return { ...stored, journalChunkCount, pendingBlockCount, pendingSegmentCount };
+}
 function asTableRecord(value, location = "catalog/table") {
   if (!isRecord(value))
     throw corruption(location, "table record is not an object");
@@ -8951,8 +9255,7 @@ function asLeaseRecord(value, expectedId) {
   };
 }
 async function readActiveTransactionRecord(transaction, id, expectedRevision) {
-  const value = await requestResult(transaction.objectStore("transactions").get(id));
-  const record = value === void 0 ? void 0 : asTransactionRecord(value);
+  const record = await readTransactionRecord(transaction, id);
   if (record?.revision !== expectedRevision || record.status !== "active") {
     throw new TransactionRecordConflictError(id, expectedRevision, record?.revision ?? null);
   }
@@ -9012,11 +9315,9 @@ async function assertCompactionJobReferences(transaction, job) {
     }
   }
   if (job.transactionId !== null) {
-    const value = await requestResult(transaction.objectStore("transactions").get(job.transactionId));
-    if (value === void 0) {
+    if (await readTransactionRecord(transaction, job.transactionId) === void 0) {
       throw new Error(`Compaction job ${job.id} references missing transaction: ${job.transactionId}`);
     }
-    asTransactionRecord(value, job.transactionId);
   }
   if (job.state === "ready" || job.state === "published") {
     for (const outputId of compactionOutputSegmentIds(job)) {
@@ -9228,7 +9529,7 @@ function countVisibleLevelZeroSegments(index, transactions, tableId, currentBloc
           if (ownerRequest.result === void 0) {
             throw corruption(`segments/${segment.id}`, `owning transaction ${segment.transactionId} is missing`);
           }
-          const owner = asTransactionRecord(ownerRequest.result, segment.transactionId);
+          const owner = asStoredTransactionRecord(ownerRequest.result, segment.transactionId);
           statuses.set(owner.id, owner.status);
           if (owner.status === "committed")
             count += 1;
@@ -9267,10 +9568,7 @@ async function compactionJobRemovalPreservesProvenance(transaction, removedJob)
     for (const blockId of segmentBlockIds(segment))
       rootedBlocks.add(blockId);
   });
-  await visitObjectStoreSequentially(transaction.objectStore("transactions"), (value, key) => {
-    if (typeof key !== "string")
-      throw corruption("transactions", "record key is invalid");
-    const record = asTransactionRecord(value, key);
+  await visitTransactionRecords(transaction, (record) => {
     for (const blockId of record.pendingBlockIds)
       rootedBlocks.add(blockId);
     for (const segmentId of record.pendingSegmentIds)
@@ -9320,7 +9618,7 @@ async function garbageCollectionPinsInTransaction(transaction, currentVersion, l
   };
   pin(currentVersion);
   await visitObjectStoreReadBatches(transaction.objectStore("transactions"), (value) => {
-    const record = asTransactionRecord(value);
+    const record = asStoredTransactionRecord(value);
     if (record.status === "active") {
       pin(record.snapshotVersion);
     }
@@ -9341,10 +9639,9 @@ async function garbageCollectionPinsInTransaction(transaction, currentVersion, l
     pin(job.sourceManifestVersion);
     if (job.transactionId === null)
       return;
-    const transactionValue = await requestResult(transaction.objectStore("transactions").get(job.transactionId));
-    if (transactionValue === void 0)
+    const linkedTransaction = await readStoredTransactionRecord(transaction, job.transactionId);
+    if (linkedTransaction === void 0)
       return;
-    const linkedTransaction = asTransactionRecord(transactionValue);
     if (linkedTransaction.status !== "committed")
       return;
     if (linkedTransaction.committedVersion === null) {
@@ -9786,8 +10083,7 @@ async function assertGarbageCollectionCandidateProvenanceInTransaction(transacti
     }
   }
   for (const id of candidates.candidateTransactionIds) {
-    const value = await requestResult(transaction.objectStore("transactions").get(id));
-    const record = value === void 0 ? void 0 : asTransactionRecord(value);
+    const record = await readStoredTransactionRecord(transaction, id);
     if (record === void 0 || record.status !== "aborted" && (record.status !== "committed" || record.committedVersion === null)) {
       throw new Error(`Garbage collection transaction candidate is not terminal: ${id}`);
     }
@@ -9804,10 +10100,7 @@ async function assertGarbageCollectionCandidateProvenanceInTransaction(transacti
   const blockHasProvenance = async (id) => {
     if (manifestProvenBlockIds.has(id))
       return true;
-    const transactionProven = await visitObjectStoreSequentially(transaction.objectStore("transactions"), (value) => {
-      const record = asTransactionRecord(value);
-      return record.status === "aborted" && record.pendingBlockIds.includes(id);
-    });
+    const transactionProven = await visitTransactionRecords(transaction, (record) => record.status === "aborted" && record.pendingBlockIds.includes(id));
     if (transactionProven)
       return true;
     return visitObjectStoreSequentially(transaction.objectStore("gc"), (value, key) => {
@@ -9843,8 +10136,7 @@ async function collectBoundedPhysicalRootsInTransaction(transaction, candidateSe
         ownerBlockRootsComplete = false;
     }
   };
-  await visitIndexPartitionSequentially(transaction.objectStore("transactions").index(TRANSACTION_STATUS_INDEX), "active", (value) => {
-    const record = asTransactionRecord(value);
+  await visitActiveTransactionRecords(transaction, (record) => {
     if (record.status !== "active")
       return;
     rememberOwnerBlocks(record.pendingBlockIds);
@@ -9875,10 +10167,7 @@ async function collectBoundedPhysicalRootsInTransaction(transaction, candidateSe
       return cached;
     let rooted = ownerBlockRoots.has(id);
     if (!rooted && !ownerBlockRootsComplete) {
-      rooted = await visitIndexPartitionSequentially(transaction.objectStore("transactions").index(TRANSACTION_STATUS_INDEX), "active", (value) => {
-        const record = asTransactionRecord(value);
-        return record.status === "active" && record.pendingBlockIds.includes(id);
-      });
+      rooted = await visitActiveTransactionRecords(transaction, (record) => record.status === "active" && record.pendingBlockIds.includes(id));
       if (!rooted) {
         rooted = await visitObjectStoreSequentially(transaction.objectStore("gc"), (value, key) => {
           const job = asCompactionJobAtMaintenanceKey(value, key);
@@ -9899,15 +10188,13 @@ async function collectBoundedPhysicalRootsInTransaction(transaction, candidateSe
   const rootedBlockIds = /* @__PURE__ */ new Set();
   const rootedSegmentIds = /* @__PURE__ */ new Set();
   const segmentStore = transaction.objectStore("segments");
-  const transactionStore = transaction.objectStore("transactions");
   for (const id of candidateSegmentIds) {
     const value = await requestResult(segmentStore.get(id));
     if (value === void 0)
       continue;
     const segment = asSegmentRecord(value);
     const ids = segmentBlockIds(segment);
-    const ownerValue = await requestResult(transactionStore.get(segment.transactionId));
-    const owner = ownerValue === void 0 ? void 0 : asTransactionRecord(ownerValue);
+    const owner = await readStoredTransactionRecord(transaction, segment.transactionId);
     let allBlocksRooted = ids.length > 0;
     for (const blockId of ids) {
       if (await isDirectBlockRoot(blockId))
@@ -10728,7 +11015,7 @@ async function pendingCatalogReservations(store, excludeTransactionId) {
   await visitObjectStoreSequentially(store, (value, key) => {
     if (typeof key !== "string")
       throw corruption("transactions", "record key is invalid");
-    const transaction = asTransactionRecord(value, key);
+    const transaction = asStoredTransactionRecord(value, key);
     if (transaction.id === excludeTransactionId || transaction.status !== "active" || transaction.pendingTable === void 0) {
       return;
     }
@@ -10951,7 +11238,7 @@ async function assertPinnedHistoryAdmission(transaction, input) {
         throw corruption("transactions", "record key is invalid");
       if (key === input.excludeTransactionId)
         return;
-      const record = asTransactionRecord(value, key);
+      const record = asStoredTransactionRecord(value, key);
       if (record.status !== "active") {
         throw corruption(`transactions/${key}`, "status index does not match its record");
       }