@delali/sirannon-db 0.2.3-next.36 → 0.2.3-next.37

package/dist/backup/index.d.ts

@@ -1,6 +1,6 @@
-import { j as BackupDestination, k as BackupRunReport, a as SQLiteDriver } from '../types-Bm-biDkV.js';
-export { g as BackupChain, e as BackupChainBase, f as BackupChainChange, l as BackupChainPosition, h as BackupChainRecord, m as BackupCycle, n as BackupCycleOptions, o as BackupPiece, p as BackupProgress, q as BackupToDestinationOptions, r as DEFAULT_CHAIN_NAME, s as chainLogName, t as readBackupChains } from '../types-Bm-biDkV.js';
-export { B as BackupCapabilities, a as BackupRestorePlan, b as BackupSafeToDeleteOptions, c as backupPiecesSafeToDelete, p as planBackupRestore } from '../chain-queries-BzoS648g.js';
+import { j as BackupDestination, k as BackupRunReport, a as SQLiteDriver } from '../types-Xb0L3o3w.js';
+export { g as BackupChain, e as BackupChainBase, f as BackupChainChange, l as BackupChainPosition, h as BackupChainRecord, m as BackupCycle, n as BackupCycleOptions, o as BackupGroupMembership, p as BackupGroupSource, q as BackupNodePreference, r as BackupPiece, s as BackupProgress, t as BackupSkip, u as BackupSkipReason, v as BackupToDestinationOptions, w as DEFAULT_CHAIN_NAME, x as chainLogName, y as readBackupChains } from '../types-Xb0L3o3w.js';
+export { B as BackupCapabilities, a as BackupRestorePlan, b as BackupSafeToDeleteOptions, c as backupPiecesSafeToDelete, p as planBackupRestore } from '../chain-queries-D5aZ-8v2.js';
 import '../query-types-Cv8N7pXj.js';
 
 /** What one assembled file took to build.

package/dist/backup/index.mjs

@@ -1,9 +1,9 @@
 import { planBackupRestore } from '../chunk-YNTDOFTN.mjs';
 export { backupPiecesSafeToDelete, planBackupRestore } from '../chunk-YNTDOFTN.mjs';
 import { checkpointLog, LOG_HEADER_BYTES, LOG_FRAME_HEADER_BYTES, readLogHeader, foldLogChecksum, MAGIC_WITH_LITTLE_ENDIAN_CONTENT, LOG_FORMAT_VERSION } from '../chunk-72I5UI5C.mjs';
-import { destinationWithDeadline, DEFAULT_DESTINATION_TIMEOUT_MS } from '../chunk-TI6NWCHJ.mjs';
-import { readBackupChains, DEFAULT_CHAIN_NAME } from '../chunk-4H45GMYI.mjs';
-export { DEFAULT_CHAIN_NAME, chainLogName, readBackupChains } from '../chunk-4H45GMYI.mjs';
+import { destinationWithDeadline, DEFAULT_DESTINATION_TIMEOUT_MS } from '../chunk-GBM4AU24.mjs';
+import { readBackupChains, DEFAULT_CHAIN_NAME } from '../chunk-YVF2ZJTE.mjs';
+export { DEFAULT_CHAIN_NAME, chainLogName, readBackupChains } from '../chunk-YVF2ZJTE.mjs';
 import { randomHex } from '../chunk-V5FUJEYY.mjs';
 import { SirannonError } from '../chunk-PBRXXISQ.mjs';
 import { rename, open, rm, stat } from 'fs/promises';

package/dist/backup-scheduler/index.d.ts

@@ -1,4 +1,4 @@
-import { i as SQLiteConnection, u as BackupRunRequest, k as BackupRunReport, v as BackupScheduleOptions } from '../types-Bm-biDkV.js';
+import { i as SQLiteConnection, z as BackupRunRequest, k as BackupRunReport, E as BackupScheduleOptions } from '../types-Xb0L3o3w.js';
 import '../query-types-Cv8N7pXj.js';
 
 /** What one runtime needs before a copy can reach a destination without a local file.

package/dist/backup-scheduler/index.mjs

@@ -1,5 +1,5 @@
-export { BackupScheduler } from '../chunk-T65NT3SH.mjs';
-import '../chunk-TI6NWCHJ.mjs';
+export { BackupScheduler } from '../chunk-BQTVNI5H.mjs';
+import '../chunk-GBM4AU24.mjs';
 import '../chunk-W67A4H2E.mjs';
 import '../chunk-V5FUJEYY.mjs';
 import '../chunk-PBRXXISQ.mjs';

package/dist/{chain-queries-BzoS648g.d.ts → chain-queries-D5aZ-8v2.d.ts}

@@ -1,4 +1,4 @@
-import { e as BackupChainBase, f as BackupChainChange, g as BackupChain, h as BackupChainRecord } from './types-Bm-biDkV.js';
+import { e as BackupChainBase, f as BackupChainChange, g as BackupChain, h as BackupChainRecord } from './types-Xb0L3o3w.js';
 
 /**
  * What one runtime supports of the backup operations, so a caller learns

package/dist/{change-tracker-Cl-ugzWo.d.ts → change-tracker-DXHPFe9J.d.ts}

@@ -1,4 +1,4 @@
-import { i as SQLiteConnection } from './types-Bm-biDkV.js';
+import { i as SQLiteConnection } from './types-Xb0L3o3w.js';
 import { C as ChangeEvent } from './query-types-Cv8N7pXj.js';
 
 /**

package/dist/{chunk-T65NT3SH.mjs → chunk-BQTVNI5H.mjs}

@@ -1,4 +1,4 @@
-import { destinationWithDeadline, DEFAULT_DESTINATION_TIMEOUT_MS } from './chunk-TI6NWCHJ.mjs';
+import { destinationWithDeadline, DEFAULT_DESTINATION_TIMEOUT_MS } from './chunk-GBM4AU24.mjs';
 import { startCopyWithoutHoldingWriter } from './chunk-W67A4H2E.mjs';
 import { randomHex } from './chunk-V5FUJEYY.mjs';
 import { BackupError, SirannonError } from './chunk-PBRXXISQ.mjs';

package/dist/{chunk-TI6NWCHJ.mjs → chunk-GBM4AU24.mjs}

@@ -28,8 +28,12 @@ function destinationWithDeadline(destination, timeoutMs) {
     );
   }
   if (timeoutMs === 0) return destination;
+  const claim = destination.writePieceIfAbsent?.bind(destination);
   return {
     writePiece: (name, index, bytes) => withinDeadline(destination.writePiece(name, index, bytes), `store piece ${index} of '${name}'`, timeoutMs),
+    ...claim ? {
+      writePieceIfAbsent: (name, index, bytes) => withinDeadline(claim(name, index, bytes), `claim piece ${index} of '${name}'`, timeoutMs)
+    } : {},
     readPiece: (name, index) => withinDeadline(destination.readPiece(name, index), `return piece ${index} of '${name}'`, timeoutMs),
     listPieces: (name) => withinDeadline(destination.listPieces(name), `list the pieces of '${name}'`, timeoutMs)
   };

package/dist/{chunk-4H45GMYI.mjs → chunk-YVF2ZJTE.mjs}

@@ -29,6 +29,7 @@ function isBackupChainChange(value) {
 
 // src/core/backup/chain.ts
 var DEFAULT_CHAIN_NAME = "sirannon-backup-chain";
+var HEAD_APPEND_ATTEMPTS = 8;
 var encoder = new TextEncoder();
 var decoder = new TextDecoder();
 function destinationError(message, err) {
@@ -39,34 +40,44 @@ function destinationError(message, err) {
 function chainLogName(chainName, chainId) {
   return `${chainName}.${chainId}`;
 }
-async function appendRecord(destination, name, index, record) {
+async function storeRecord(store, name, index, record) {
   try {
-    await destination.writePiece(name, index, encoder.encode(JSON.stringify(record)));
+    return await store(encoder.encode(JSON.stringify(record)));
   } catch (err) {
     throw destinationError(`The destination refused record ${index} of '${name}'`, err);
   }
 }
-async function readRecords(destination, name) {
-  let listed;
+function appendRecord(destination, name, index, record) {
+  return storeRecord((bytes) => destination.writePiece(name, index, bytes), name, index, record);
+}
+function claimRecord(claim, name, index, record) {
+  return storeRecord((bytes) => claim(name, index, bytes), name, index, record);
+}
+async function listRecordIndices(destination, name) {
   try {
-    listed = await destination.listPieces(name);
+    return (await destination.listPieces(name)).map((piece) => piece.index);
   } catch (err) {
     throw destinationError(`The destination could not list the records of '${name}'`, err);
   }
-  const ordered = [...listed].sort((left, right) => left.index - right.index);
+}
+async function readRecord(destination, name, index) {
+  let bytes;
+  try {
+    bytes = await destination.readPiece(name, index);
+  } catch (err) {
+    throw destinationError(`The destination could not return record ${index} of '${name}'`, err);
+  }
+  try {
+    return JSON.parse(decoder.decode(bytes));
+  } catch (err) {
+    throw destinationError(`Record ${index} of '${name}' is not a record Sirannon wrote`, err);
+  }
+}
+async function readRecords(destination, name) {
+  const ordered = (await listRecordIndices(destination, name)).sort((left, right) => left - right);
   const records = [];
-  for (const piece of ordered) {
-    let bytes;
-    try {
-      bytes = await destination.readPiece(name, piece.index);
-    } catch (err) {
-      throw destinationError(`The destination could not return record ${piece.index} of '${name}'`, err);
-    }
-    try {
-      records.push(JSON.parse(decoder.decode(bytes)));
-    } catch (err) {
-      throw destinationError(`Record ${piece.index} of '${name}' is not a record Sirannon wrote`, err);
-    }
+  for (const index of ordered) {
+    records.push(await readRecord(destination, name, index));
   }
   return records;
 }
@@ -86,12 +97,32 @@ function chainRecords(records, name) {
   }
   return kept;
 }
-async function appendChainHead(destination, chainName, head, index) {
-  await appendRecord(destination, chainName, index, head);
+async function appendChainHead(destination, chainName, head) {
+  const taken = await listRecordIndices(destination, chainName);
+  let index = taken.reduce((next, piece) => Math.max(next, piece + 1), 0);
+  const claim = destination.writePieceIfAbsent?.bind(destination);
+  for (let attempt = 0; attempt < HEAD_APPEND_ATTEMPTS; attempt++) {
+    if (claim) {
+      if (await claimRecord(claim, chainName, index, head)) return index;
+      index++;
+      continue;
+    }
+    await appendRecord(destination, chainName, index, head);
+    const stored = await readRecord(destination, chainName, index);
+    if (isBackupChainHead(stored) && stored.chainId === head.chainId) return index;
+    index++;
+  }
+  throw destinationError(
+    `Another chain took every one of the ${HEAD_APPEND_ATTEMPTS} places Sirannon tried for chain '${head.chainId}' in '${chainName}'. Point one replication group at this chain name, and give any other group a chainName of its own.`
+  );
 }
 async function appendChainRecord(destination, chainName, record, index) {
   await appendRecord(destination, chainLogName(chainName, record.chainId), index, record);
 }
+async function readChainHeadAt(destination, chainName, index) {
+  const record = await readRecord(destination, chainName, index);
+  return isBackupChainHead(record) ? record : null;
+}
 async function readChainHeads(destination, chainName) {
   const records = await readRecords(destination, chainName);
   return records.filter(isBackupChainHead).reverse();
@@ -115,4 +146,4 @@ async function readBackupChains(destination, chainName = DEFAULT_CHAIN_NAME) {
   return chains;
 }
 
-export { DEFAULT_CHAIN_NAME, appendChainHead, appendChainRecord, chainLogName, isBackupChainPosition, readBackupChains, readChainHeads };
+export { DEFAULT_CHAIN_NAME, appendChainHead, appendChainRecord, chainLogName, isBackupChainPosition, readBackupChains, readChainHeadAt, readChainHeads };