niceeval 0.16.2 → 0.17.0

package/dist/run/storage/sqlite.cjs

@@ -98,13 +98,13 @@ function requireClosure(bytes, digest) {
     }
 }
 function metadataGeneration(connection) {
-    const row = (0, database_ts_1.recordStatement)(connection, "SELECT storage_generation FROM ne18_record_metadata WHERE singleton=1").get();
+    const row = (0, database_ts_1.recordStatement)(connection, "SELECT storage_generation FROM ne19_record_metadata WHERE singleton=1").get();
     if (row === undefined)
         throw invalid("ProjectDatabase storage generation is missing");
     return text(row, "storage_generation");
 }
 function currentRevision(connection) {
-    const row = (0, database_ts_1.recordStatement)(connection, "SELECT revision FROM ne18_run_publication_clock WHERE singleton=1").get();
+    const row = (0, database_ts_1.recordStatement)(connection, "SELECT revision FROM ne19_run_publication_clock WHERE singleton=1").get();
     if (row === undefined)
         throw invalid("Run publication clock is missing");
     return integer(row, "revision");
@@ -113,7 +113,7 @@ function cutoffAt(connection, revision) {
     return Object.freeze({ storeGeneration: metadataGeneration(connection), revision });
 }
 function nextRevision(connection) {
-    const changed = (0, database_ts_1.recordStatement)(connection, "UPDATE ne18_run_publication_clock SET revision=revision+1 WHERE singleton=1").run();
+    const changed = (0, database_ts_1.recordStatement)(connection, "UPDATE ne19_run_publication_clock SET revision=revision+1 WHERE singleton=1").run();
     if (Number(changed.changes) !== 1)
         throw invalid("Run publication clock could not advance");
     return currentRevision(connection);
@@ -130,7 +130,7 @@ function requireCutoff(connection, requested) {
 }
 function runHeader(connection, runId) {
     const row = (0, database_ts_1.recordStatement)(connection, `SELECT run_id,current_writer_generation,terminal_state,created_revision,close_revision
-    FROM ne18_run_resources WHERE run_id=?`).get(runId);
+    FROM ne19_run_resources WHERE run_id=?`).get(runId);
     if (row === undefined)
         return undefined;
     const terminalState = optionalText(row, "terminal_state");
@@ -145,7 +145,7 @@ function runHeader(connection, runId) {
     });
 }
 function requireActiveWriter(connection, runId, writerGeneration) {
-    const barrier = (0, database_ts_1.recordStatement)(connection, "SELECT barrier_state FROM ne18_record_metadata WHERE singleton=1").get();
+    const barrier = (0, database_ts_1.recordStatement)(connection, "SELECT barrier_state FROM ne19_record_metadata WHERE singleton=1").get();
     if (barrier === undefined || text(barrier, "barrier_state") !== "open") {
         throw new errors_ts_2.RunStorageError("run-not-active", "ProjectDatabase writer barrier is not open");
     }
@@ -160,15 +160,15 @@ function requireActiveWriter(connection, runId, writerGeneration) {
     return run;
 }
 function slotExists(connection, runId, slotId) {
-    return (0, database_ts_1.recordStatement)(connection, "SELECT 1 AS present FROM ne18_run_expected_slots WHERE run_id=? AND slot_id=?")
+    return (0, database_ts_1.recordStatement)(connection, "SELECT 1 AS present FROM ne19_run_expected_slots WHERE run_id=? AND slot_id=?")
         .get(runId, slotId) !== undefined;
 }
 function slotBound(connection, runId, slotId) {
-    return (0, database_ts_1.recordStatement)(connection, "SELECT 1 AS present FROM ne18_run_slot_bindings WHERE target_run_id=? AND slot_id=?")
+    return (0, database_ts_1.recordStatement)(connection, "SELECT 1 AS present FROM ne19_run_slot_bindings WHERE target_run_id=? AND slot_id=?")
         .get(runId, slotId) !== undefined;
 }
 function sourceDeleted(connection, runId) {
-    return (0, database_ts_1.recordStatement)(connection, "SELECT 1 AS present FROM ne18_run_deletion_tombstones WHERE run_id=?").get(runId) !== undefined;
+    return (0, database_ts_1.recordStatement)(connection, "SELECT 1 AS present FROM ne19_run_deletion_tombstones WHERE run_id=?").get(runId) !== undefined;
 }
 function validateExpectedSlots(slots) {
     if (slots.length > types_ts_1.RECORD_SQLITE_MAX_ROW_BYTES / 256) {
@@ -201,7 +201,7 @@ function createRunResourceOnConnection(connection, input) {
     requireIsoInstant(input.startedAt, "startedAt");
     validateExpectedSlots(input.expectedSlots);
     return (0, transaction_ts_1.withImmediateTransaction)(connection, input.deadlineEpochMs, "create-run-resource", () => {
-        const barrier = (0, database_ts_1.recordStatement)(connection, "SELECT barrier_state FROM ne18_record_metadata WHERE singleton=1").get();
+        const barrier = (0, database_ts_1.recordStatement)(connection, "SELECT barrier_state FROM ne19_record_metadata WHERE singleton=1").get();
         if (barrier === undefined || text(barrier, "barrier_state") !== "open") {
             throw new errors_ts_2.RunStorageError("run-not-active", "ProjectDatabase writer barrier is not open");
         }
@@ -209,10 +209,10 @@ function createRunResourceOnConnection(connection, input) {
             throw new errors_ts_2.RunStorageError("run-storage-invalid", `Run ${input.runId} already exists`);
         }
         const revision = nextRevision(connection);
-        (0, database_ts_1.recordStatement)(connection, `INSERT INTO ne18_run_resources(run_id,invocation_id,experiment_id,started_at,
+        (0, database_ts_1.recordStatement)(connection, `INSERT INTO ne19_run_resources(run_id,invocation_id,experiment_id,started_at,
       initial_writer_generation,current_writer_generation,terminal_state,completed_at,created_revision,close_revision)
       VALUES (?,?,?,?,?,?,NULL,NULL,?,NULL)`).run(input.runId, input.invocationId, input.experimentId, input.startedAt, input.writerGeneration, input.writerGeneration, revision);
-        const insertSlot = (0, database_ts_1.recordStatement)(connection, `INSERT INTO ne18_run_expected_slots(run_id,slot_id,ordinal,eval_id,
+        const insertSlot = (0, database_ts_1.recordStatement)(connection, `INSERT INTO ne19_run_expected_slots(run_id,slot_id,ordinal,eval_id,
       attempt_ordinal,execution_identity_digest) VALUES (?,?,?,?,?,?)`);
         input.expectedSlots.forEach((slot, ordinal) => insertSlot.run(input.runId, slot.slotId, ordinal, slot.evalId, slot.attemptOrdinal, slot.executionIdentityDigest));
         return Object.freeze({ runId: input.runId, cutoff: cutoffAt(connection, revision) });
@@ -237,13 +237,13 @@ function publishOriginAttemptOnConnection(connection, input) {
         if (slotBound(connection, input.runId, input.slotId)) {
             throw new errors_ts_2.RunStorageError("slot-already-bound", `Run ${input.runId} slot ${input.slotId} is already bound`);
         }
-        if ((0, database_ts_1.recordStatement)(connection, "SELECT 1 AS present FROM ne18_attempt_publications WHERE attempt_id=?").get(input.attemptId) !== undefined) {
+        if ((0, database_ts_1.recordStatement)(connection, "SELECT 1 AS present FROM ne19_attempt_publications WHERE attempt_id=?").get(input.attemptId) !== undefined) {
             throw new errors_ts_2.RunStorageError("attempt-already-published", `Attempt ${input.attemptId} is already published`);
         }
         const aggregate = (0, database_ts_1.recordStatement)(connection, `SELECT r.status,r.writer_generation,a.attempt_locator,a.publication_state,a.core_payload,a.core_digest,
-      m.slot_id AS member_slot FROM ne18_runs r
-      JOIN ne18_attempts a ON a.origin_run_id=r.run_id AND a.attempt_id=?
-      JOIN ne18_members m ON m.target_run_id=r.run_id AND m.slot_id=? AND m.origin_run_id=r.run_id AND m.attempt_id=a.attempt_id
+      m.slot_id AS member_slot FROM ne19_runs r
+      JOIN ne19_attempts a ON a.origin_run_id=r.run_id AND a.attempt_id=?
+      JOIN ne19_members m ON m.target_run_id=r.run_id AND m.slot_id=? AND m.origin_run_id=r.run_id AND m.attempt_id=a.attempt_id
       WHERE r.run_id=?`).get(input.attemptId, input.slotId, input.runId);
         if (aggregate === undefined || text(aggregate, "writer_generation") !== input.writerGeneration ||
             (text(aggregate, "status") !== "open" && text(aggregate, "status") !== "sealing") ||
@@ -252,8 +252,8 @@ function publishOriginAttemptOnConnection(connection, input) {
             typeof aggregate.core_digest !== "string") {
             throw new errors_ts_2.RunStorageError("run-storage-invalid", "Attempt aggregate is not complete at its publication fence");
         }
-        const incomplete = (0, database_ts_1.recordStatement)(connection, `SELECT count(*) AS count FROM ne18_attachments a
-      LEFT JOIN ne18_contents c ON c.attachment_id=a.attachment_id
+        const incomplete = (0, database_ts_1.recordStatement)(connection, `SELECT count(*) AS count FROM ne19_attachments a
+      LEFT JOIN ne19_contents c ON c.attachment_id=a.attachment_id
       WHERE a.owner_run_id=? AND a.owner_attempt_id=? AND
         (a.logical_identity IS NULL OR a.canonical_payload IS NULL OR a.canonical_digest IS NULL OR
          a.logical_inventory IS NULL OR a.inventory_digest IS NULL OR
@@ -262,17 +262,17 @@ function publishOriginAttemptOnConnection(connection, input) {
         if (integer(incomplete, "count") !== 0) {
             throw new errors_ts_2.RunStorageError("run-storage-invalid", "Attempt attachment closure is incomplete at its publication fence");
         }
-        const barrier = (0, database_ts_1.recordStatement)(connection, "SELECT barrier_state FROM ne18_record_metadata WHERE singleton=1").get();
+        const barrier = (0, database_ts_1.recordStatement)(connection, "SELECT barrier_state FROM ne19_record_metadata WHERE singleton=1").get();
         if (barrier === undefined || text(barrier, "barrier_state") !== "open") {
             throw new errors_ts_2.RunStorageError("run-not-active", "ProjectDatabase portable barrier is not open");
         }
         const revision = nextRevision(connection);
-        (0, database_ts_1.recordStatement)(connection, `INSERT INTO ne18_attempt_publications(attempt_id,attempt_locator,origin_run_id,origin_slot_id,
+        (0, database_ts_1.recordStatement)(connection, `INSERT INTO ne19_attempt_publications(attempt_id,attempt_locator,origin_run_id,origin_slot_id,
       closure_payload,closure_digest,published_revision) VALUES (?,?,?,?,?,?,?)`).run(input.attemptId, input.attemptLocator, input.runId, input.slotId, input.closureBytes, input.closureDigest, revision);
-        (0, database_ts_1.recordStatement)(connection, `INSERT INTO ne18_run_slot_bindings(target_run_id,slot_id,attempt_id,origin_run_id,
+        (0, database_ts_1.recordStatement)(connection, `INSERT INTO ne19_run_slot_bindings(target_run_id,slot_id,attempt_id,origin_run_id,
       origin_slot_id,attempt_publication_revision,action,binding_revision) VALUES (?,?,?,?,?,?,'executed',?)`).run(input.runId, input.slotId, input.attemptId, input.runId, input.slotId, revision, revision);
         const publicationIdentity = Object.freeze({ originRunId: input.runId, attemptId: input.attemptId, revision });
-        const frozen = (0, database_ts_1.recordStatement)(connection, `UPDATE ne18_attempts SET publication_state='published'
+        const frozen = (0, database_ts_1.recordStatement)(connection, `UPDATE ne19_attempts SET publication_state='published'
       WHERE origin_run_id=? AND attempt_id=? AND publication_state='sealing'`).run(input.runId, input.attemptId);
         if (Number(frozen.changes) !== 1) {
             throw new errors_ts_2.RunStorageError("run-storage-invalid", "Attempt publication fence changed before freeze");
@@ -304,7 +304,7 @@ function bindAttemptReferenceOnConnection(connection, input) {
         if (slotBound(connection, input.runId, input.slotId)) {
             throw new errors_ts_2.RunStorageError("slot-already-bound", `Run ${input.runId} slot ${input.slotId} is already bound`);
         }
-        const source = (0, database_ts_1.recordStatement)(connection, `SELECT origin_run_id,origin_slot_id,published_revision FROM ne18_attempt_publications
+        const source = (0, database_ts_1.recordStatement)(connection, `SELECT origin_run_id,origin_slot_id,published_revision FROM ne19_attempt_publications
       WHERE attempt_id=?`).get(input.publicationIdentity.attemptId);
         if (source === undefined || text(source, "origin_run_id") !== input.publicationIdentity.originRunId ||
             integer(source, "published_revision") !== input.publicationIdentity.revision) {
@@ -314,7 +314,7 @@ function bindAttemptReferenceOnConnection(connection, input) {
             throw new errors_ts_2.RunStorageError("source-run-deleted", `Origin Run ${input.publicationIdentity.originRunId} is deleted`);
         }
         const revision = nextRevision(connection);
-        (0, database_ts_1.recordStatement)(connection, `INSERT INTO ne18_run_slot_bindings(target_run_id,slot_id,attempt_id,origin_run_id,
+        (0, database_ts_1.recordStatement)(connection, `INSERT INTO ne19_run_slot_bindings(target_run_id,slot_id,attempt_id,origin_run_id,
       origin_slot_id,attempt_publication_revision,action,binding_revision) VALUES (?,?,?,?,?,?,?,?)`).run(input.runId, input.slotId, input.publicationIdentity.attemptId, input.publicationIdentity.originRunId, text(source, "origin_slot_id"), input.publicationIdentity.revision, input.action, revision);
         return Object.freeze({
             runId: input.runId,
@@ -325,8 +325,8 @@ function bindAttemptReferenceOnConnection(connection, input) {
     });
 }
 function pendingSlotIds(connection, runId) {
-    const rows = (0, database_ts_1.recordStatement)(connection, `SELECT s.slot_id FROM ne18_run_expected_slots s
-    LEFT JOIN ne18_run_slot_bindings b ON b.target_run_id=s.run_id AND b.slot_id=s.slot_id
+    const rows = (0, database_ts_1.recordStatement)(connection, `SELECT s.slot_id FROM ne19_run_expected_slots s
+    LEFT JOIN ne19_run_slot_bindings b ON b.target_run_id=s.run_id AND b.slot_id=s.slot_id
     WHERE s.run_id=? AND b.slot_id IS NULL ORDER BY s.ordinal`).all(runId);
     return Object.freeze(rows.map((row) => text(row, "slot_id")));
 }
@@ -346,7 +346,7 @@ function validateAbsenceClosure(connection, runId, absences) {
     }
 }
 function insertAbsences(connection, runId, revision, absences) {
-    const insert = (0, database_ts_1.recordStatement)(connection, `INSERT INTO ne18_run_slot_absences(run_id,slot_id,reason,absence_revision)
+    const insert = (0, database_ts_1.recordStatement)(connection, `INSERT INTO ne19_run_slot_absences(run_id,slot_id,reason,absence_revision)
     VALUES (?,?,?,?)`);
     for (const absence of absences)
         insert.run(runId, absence.slotId, absence.reason, revision);
@@ -360,19 +360,19 @@ function closeRunResourceOnConnection(connection, input) {
     return (0, transaction_ts_1.withImmediateTransaction)(connection, input.deadlineEpochMs, "close-run-resource", () => {
         requireActiveWriter(connection, input.runId, input.writerGeneration);
         validateAbsenceClosure(connection, input.runId, input.absences);
-        const aggregate = (0, database_ts_1.recordStatement)(connection, "SELECT status,writer_generation FROM ne18_runs WHERE run_id=?")
+        const aggregate = (0, database_ts_1.recordStatement)(connection, "SELECT status,writer_generation FROM ne19_runs WHERE run_id=?")
             .get(input.runId);
         if (aggregate === undefined || text(aggregate, "status") !== "sealed" ||
             text(aggregate, "writer_generation") !== input.writerGeneration) {
             throw new errors_ts_2.RunStorageError("run-storage-invalid", `Run ${input.runId} aggregate is not sealed at close`);
         }
-        const barrier = (0, database_ts_1.recordStatement)(connection, "SELECT barrier_state FROM ne18_record_metadata WHERE singleton=1").get();
+        const barrier = (0, database_ts_1.recordStatement)(connection, "SELECT barrier_state FROM ne19_record_metadata WHERE singleton=1").get();
         if (barrier === undefined || text(barrier, "barrier_state") !== "open") {
             throw new errors_ts_2.RunStorageError("run-not-active", "ProjectDatabase portable barrier is not open");
         }
         const revision = nextRevision(connection);
         insertAbsences(connection, input.runId, revision, input.absences);
-        const changed = (0, database_ts_1.recordStatement)(connection, `UPDATE ne18_run_resources SET terminal_state=?,completed_at=?,close_revision=?
+        const changed = (0, database_ts_1.recordStatement)(connection, `UPDATE ne19_run_resources SET terminal_state=?,completed_at=?,close_revision=?
       WHERE run_id=? AND terminal_state IS NULL AND current_writer_generation=?`).run(input.state, input.completedAt, revision, input.runId, input.writerGeneration);
         if (Number(changed.changes) !== 1)
             throw new errors_ts_2.RunStorageError("run-not-active", `Run ${input.runId} changed before close`);
@@ -400,20 +400,20 @@ function recoverRunResourceOnConnection(connection, input) {
         }));
         const revision = nextRevision(connection);
         insertAbsences(connection, input.runId, revision, absences);
-        const changed = (0, database_ts_1.recordStatement)(connection, `UPDATE ne18_run_resources SET current_writer_generation=?,terminal_state='interrupted',
+        const changed = (0, database_ts_1.recordStatement)(connection, `UPDATE ne19_run_resources SET current_writer_generation=?,terminal_state='interrupted',
       completed_at=?,close_revision=? WHERE run_id=? AND terminal_state IS NULL AND current_writer_generation=?`).run(input.recoveryWriterGeneration, input.completedAt, revision, input.runId, input.expectedWriterGeneration);
         if (Number(changed.changes) !== 1) {
             throw new errors_ts_2.RunStorageError("writer-generation-mismatch", `Run ${input.runId} changed before recovery fence`);
         }
-        (0, database_ts_1.recordStatement)(connection, `DELETE FROM ne18_attachments WHERE owner_run_id=? AND
-      (owner_kind='run' OR owner_attempt_id NOT IN (SELECT attempt_id FROM ne18_attempt_publications WHERE origin_run_id=?))`)
+        (0, database_ts_1.recordStatement)(connection, `DELETE FROM ne19_attachments WHERE owner_run_id=? AND
+      (owner_kind='run' OR owner_attempt_id NOT IN (SELECT attempt_id FROM ne19_attempt_publications WHERE origin_run_id=?))`)
             .run(input.runId, input.runId);
-        (0, database_ts_1.recordStatement)(connection, `DELETE FROM ne18_members WHERE target_run_id=? AND
-      (attempt_id IS NULL OR attempt_id NOT IN (SELECT attempt_id FROM ne18_attempt_publications WHERE origin_run_id=?))`)
+        (0, database_ts_1.recordStatement)(connection, `DELETE FROM ne19_members WHERE target_run_id=? AND
+      (attempt_id IS NULL OR attempt_id NOT IN (SELECT attempt_id FROM ne19_attempt_publications WHERE origin_run_id=?))`)
             .run(input.runId, input.runId);
-        (0, database_ts_1.recordStatement)(connection, `DELETE FROM ne18_attempts WHERE origin_run_id=? AND
-      attempt_id NOT IN (SELECT attempt_id FROM ne18_attempt_publications WHERE origin_run_id=?)`).run(input.runId, input.runId);
-        (0, database_ts_1.recordStatement)(connection, `INSERT INTO ne18_run_recoveries(run_id,previous_writer_generation,recovery_writer_generation,
+        (0, database_ts_1.recordStatement)(connection, `DELETE FROM ne19_attempts WHERE origin_run_id=? AND
+      attempt_id NOT IN (SELECT attempt_id FROM ne19_attempt_publications WHERE origin_run_id=?)`).run(input.runId, input.runId);
+        (0, database_ts_1.recordStatement)(connection, `INSERT INTO ne19_run_recoveries(run_id,previous_writer_generation,recovery_writer_generation,
       evidence_kind,evidence_identity,evidence_observed_at,recovery_revision) VALUES (?,?,?,?,?,?,?)`).run(input.runId, input.expectedWriterGeneration, input.recoveryWriterGeneration, input.evidence.kind, input.evidence.identity, input.evidence.observedAt, revision);
         return Object.freeze({
             runId: input.runId,
@@ -426,8 +426,8 @@ function recoverRunResourceOnConnection(connection, input) {
 }
 function incomingReferences(connection, originRunId) {
     const rows = (0, database_ts_1.recordStatement)(connection, `SELECT b.target_run_id,b.slot_id,b.attempt_id,a.attempt_locator
-    FROM ne18_run_slot_bindings b JOIN ne18_attempt_publications a ON a.attempt_id=b.attempt_id
-    LEFT JOIN ne18_run_deletion_tombstones d ON d.run_id=b.target_run_id
+    FROM ne19_run_slot_bindings b JOIN ne19_attempt_publications a ON a.attempt_id=b.attempt_id
+    LEFT JOIN ne19_run_deletion_tombstones d ON d.run_id=b.target_run_id
     WHERE b.origin_run_id=? AND b.target_run_id<>? AND d.run_id IS NULL
     ORDER BY b.target_run_id,b.slot_id,b.attempt_id LIMIT ?`).all(originRunId, originRunId, Math.trunc(types_ts_1.RECORD_SQLITE_MAX_ROW_BYTES / 256) + 1);
     if (rows.length > types_ts_1.RECORD_SQLITE_MAX_ROW_BYTES / 256) {
@@ -448,15 +448,15 @@ function deleteRunResourceOnConnection(connection, input) {
     requireTerminalState(input.expectedState);
     requireIsoInstant(input.deletedAt, "deletedAt");
     return (0, transaction_ts_1.withImmediateTransaction)(connection, input.deadlineEpochMs, "delete-run-resource", () => {
-        const barrier = (0, database_ts_1.recordStatement)(connection, "SELECT barrier_state FROM ne18_record_metadata WHERE singleton=1").get();
+        const barrier = (0, database_ts_1.recordStatement)(connection, "SELECT barrier_state FROM ne19_record_metadata WHERE singleton=1").get();
         if (barrier === undefined || text(barrier, "barrier_state") === "draining") {
             throw new errors_ts_2.RunStorageError("run-not-active", "ProjectDatabase writer barrier is not open");
         }
         if (text(barrier, "barrier_state") === "portable") {
             const generation = (0, node_crypto_1.randomUUID)();
-            (0, database_ts_1.recordStatement)(connection, `UPDATE ne18_record_metadata SET barrier_state='open',storage_generation=?,portable_generation=NULL,
+            (0, database_ts_1.recordStatement)(connection, `UPDATE ne19_record_metadata SET barrier_state='open',storage_generation=?,portable_generation=NULL,
         portable_revision=NULL,portable_gate_id=NULL WHERE singleton=1 AND barrier_state='portable'`).run(generation);
-            (0, database_ts_1.recordStatement)(connection, "UPDATE ne18_coordination_state SET operational_generation=?,revision=revision+1 WHERE singleton=1")
+            (0, database_ts_1.recordStatement)(connection, "UPDATE ne19_coordination_state SET operational_generation=?,revision=revision+1 WHERE singleton=1")
                 .run(generation);
         }
         const run = runHeader(connection, input.runId);
@@ -465,7 +465,7 @@ function deleteRunResourceOnConnection(connection, input) {
         if (run.terminalState !== input.expectedState) {
             throw new errors_ts_2.RunStorageError("run-state-mismatch", `Run ${input.runId} is ${run.terminalState ?? "active"}, not ${input.expectedState}`);
         }
-        const tombstone = (0, database_ts_1.recordStatement)(connection, "SELECT deletion_revision FROM ne18_run_deletion_tombstones WHERE run_id=?")
+        const tombstone = (0, database_ts_1.recordStatement)(connection, "SELECT deletion_revision FROM ne19_run_deletion_tombstones WHERE run_id=?")
             .get(input.runId);
         if (tombstone !== undefined) {
             const revision = integer(tombstone, "deletion_revision");
@@ -476,7 +476,7 @@ function deleteRunResourceOnConnection(connection, input) {
             throw new errors_ts_2.RunStorageError("run-delete-reference-conflict", `Run ${input.runId} has incoming Attempt references`, dependencies);
         }
         const revision = nextRevision(connection);
-        (0, database_ts_1.recordStatement)(connection, `INSERT INTO ne18_run_deletion_tombstones(run_id,terminal_state,deleted_at,deletion_revision)
+        (0, database_ts_1.recordStatement)(connection, `INSERT INTO ne19_run_deletion_tombstones(run_id,terminal_state,deleted_at,deletion_revision)
       VALUES (?,?,?,?)`).run(input.runId, input.expectedState, input.deletedAt, revision);
         return Object.freeze({ runId: input.runId, state: input.expectedState, cutoff: cutoffAt(connection, revision) });
     });
@@ -490,8 +490,8 @@ function publicationIdentity(row) {
 }
 function readSlotPublication(connection, runId, slotId, cutoff) {
     const binding = (0, database_ts_1.recordStatement)(connection, `SELECT b.action,b.binding_revision,b.attempt_id,b.origin_run_id,b.origin_slot_id,
-    b.attempt_publication_revision,a.attempt_locator FROM ne18_run_slot_bindings b
-    JOIN ne18_attempt_publications a ON a.attempt_id=b.attempt_id
+    b.attempt_publication_revision,a.attempt_locator FROM ne19_run_slot_bindings b
+    JOIN ne19_attempt_publications a ON a.attempt_id=b.attempt_id
     WHERE b.target_run_id=? AND b.slot_id=? AND b.binding_revision<=?`).get(runId, slotId, cutoff.revision);
     if (binding !== undefined) {
         const action = text(binding, "action");
@@ -509,7 +509,7 @@ function readSlotPublication(connection, runId, slotId, cutoff) {
             bindingRevision: integer(binding, "binding_revision"),
         });
     }
-    const absence = (0, database_ts_1.recordStatement)(connection, `SELECT reason,absence_revision FROM ne18_run_slot_absences
+    const absence = (0, database_ts_1.recordStatement)(connection, `SELECT reason,absence_revision FROM ne19_run_slot_absences
     WHERE run_id=? AND slot_id=? AND absence_revision<=?`).get(runId, slotId, cutoff.revision);
     if (absence !== undefined) {
         const reason = text(absence, "reason");
@@ -521,7 +521,7 @@ function readSlotPublication(connection, runId, slotId, cutoff) {
 function readRunAtCutoff(connection, runId, cutoff) {
     const row = (0, database_ts_1.recordStatement)(connection, `SELECT r.run_id,r.invocation_id,r.experiment_id,r.started_at,r.initial_writer_generation,r.current_writer_generation,
     r.terminal_state,r.completed_at,r.created_revision,r.close_revision,d.deletion_revision
-    FROM ne18_run_resources r LEFT JOIN ne18_run_deletion_tombstones d ON d.run_id=r.run_id WHERE r.run_id=?`).get(runId);
+    FROM ne19_run_resources r LEFT JOIN ne19_run_deletion_tombstones d ON d.run_id=r.run_id WHERE r.run_id=?`).get(runId);
     if (row === undefined || integer(row, "created_revision") > cutoff.revision ||
         row.deletion_revision !== null && row.deletion_revision !== undefined && integer(row, "deletion_revision") <= cutoff.revision) {
         return undefined;
@@ -535,7 +535,7 @@ function readRunAtCutoff(connection, runId, cutoff) {
         ? terminalState ?? (() => { throw invalid(`Run ${runId} close revision lacks terminal state`); })()
         : "active";
     const slotRows = (0, database_ts_1.recordStatement)(connection, `SELECT slot_id,eval_id,attempt_ordinal,execution_identity_digest
-    FROM ne18_run_expected_slots WHERE run_id=? ORDER BY ordinal LIMIT ?`).all(runId, Math.trunc(types_ts_1.RECORD_SQLITE_MAX_ROW_BYTES / 256) + 1);
+    FROM ne19_run_expected_slots WHERE run_id=? ORDER BY ordinal LIMIT ?`).all(runId, Math.trunc(types_ts_1.RECORD_SQLITE_MAX_ROW_BYTES / 256) + 1);
     if (slotRows.length > types_ts_1.RECORD_SQLITE_MAX_ROW_BYTES / 256) {
         throw invalid(`Run ${runId} expected slot inventory exceeds its bounded read`);
     }
@@ -576,12 +576,12 @@ function listRunResourcesOnConnection(connection, input = {}) {
     if (!Number.isSafeInteger(pageSize) || pageSize < 1 || pageSize > 256)
         throw invalid("Run page size must be between 1 and 256");
     const rows = (input.invocationId === undefined
-        ? (0, database_ts_1.recordStatement)(connection, `SELECT r.run_id FROM ne18_run_resources r
-        LEFT JOIN ne18_run_deletion_tombstones d ON d.run_id=r.run_id
+        ? (0, database_ts_1.recordStatement)(connection, `SELECT r.run_id FROM ne19_run_resources r
+        LEFT JOIN ne19_run_deletion_tombstones d ON d.run_id=r.run_id
         WHERE r.created_revision<=? AND (d.deletion_revision IS NULL OR d.deletion_revision>?) AND r.run_id>?
         ORDER BY r.run_id LIMIT ?`).all(cutoff.revision, cutoff.revision, afterRunId, pageSize + 1)
-        : (0, database_ts_1.recordStatement)(connection, `SELECT r.run_id FROM ne18_run_resources r
-        LEFT JOIN ne18_run_deletion_tombstones d ON d.run_id=r.run_id
+        : (0, database_ts_1.recordStatement)(connection, `SELECT r.run_id FROM ne19_run_resources r
+        LEFT JOIN ne19_run_deletion_tombstones d ON d.run_id=r.run_id
         WHERE r.created_revision<=? AND (d.deletion_revision IS NULL OR d.deletion_revision>?) AND r.invocation_id=? AND r.run_id>?
         ORDER BY r.run_id LIMIT ?`).all(cutoff.revision, cutoff.revision, input.invocationId, afterRunId, pageSize + 1));
     const selected = rows.slice(0, pageSize);
@@ -596,8 +596,8 @@ function readPublishedAttemptOnConnection(connection, attemptId, requestedCutoff
     requireIdentity(attemptId, "attemptId");
     const cutoff = requireCutoff(connection, requestedCutoff);
     const row = (0, database_ts_1.recordStatement)(connection, `SELECT a.attempt_id,a.attempt_locator,a.origin_run_id,a.origin_slot_id,a.closure_payload,
-    a.closure_digest,a.published_revision,d.deletion_revision FROM ne18_attempt_publications a
-    LEFT JOIN ne18_run_deletion_tombstones d ON d.run_id=a.origin_run_id WHERE a.attempt_id=?`).get(attemptId);
+    a.closure_digest,a.published_revision,d.deletion_revision FROM ne19_attempt_publications a
+    LEFT JOIN ne19_run_deletion_tombstones d ON d.run_id=a.origin_run_id WHERE a.attempt_id=?`).get(attemptId);
     if (row === undefined || integer(row, "published_revision") > cutoff.revision ||
         row.deletion_revision !== null && row.deletion_revision !== undefined && integer(row, "deletion_revision") <= cutoff.revision) {
         return undefined;