niceeval 0.16.2 → 0.17.0

package/dist/record/sqlite/storage.cjs

@@ -24,6 +24,8 @@ exports.publishRunSeal = publishRunSeal;
 exports.verifyAllSealedRuns = verifyAllSealedRuns;
 exports.readSealedRunSummary = readSealedRunSummary;
 exports.readSealedRunCutoff = readSealedRunCutoff;
+exports.findSourceBarrierCandidate = findSourceBarrierCandidate;
+exports.findAcceptedAttemptRunIds = findAcceptedAttemptRunIds;
 exports.findExperimentRunIds = findExperimentRunIds;
 exports.listSealedRunSummaries = listSealedRunSummaries;
 exports.readSealedRunSummaryPage = readSealedRunSummaryPage;
@@ -50,19 +52,19 @@ function discardAttempt(connection, input) {
     requireIdentity(input.writerGeneration, "writerGeneration");
     requireIdentity(input.attemptId, "attemptId");
     (0, transaction_ts_1.withImmediateTransaction)(connection, input.deadlineEpochMs, "discard-attempt", () => {
-        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 (0, errors_ts_1.sqliteError)("record-command-conflict", "discard-attempt", "ProjectDatabase writer barrier is not open");
         }
-        const run = (0, database_ts_1.recordStatement)(connection, "SELECT status,writer_generation FROM ne18_runs WHERE run_id=?").get(input.runId);
+        const run = (0, database_ts_1.recordStatement)(connection, "SELECT status,writer_generation FROM ne19_runs WHERE run_id=?").get(input.runId);
         if (run === undefined || text(run, "status") !== "open" || text(run, "writer_generation") !== input.writerGeneration) {
             throw (0, errors_ts_1.sqliteError)("record-sqlite-error", "discard-attempt", "Attempt owner is no longer writable");
         }
-        (0, database_ts_1.recordStatement)(connection, "DELETE FROM ne18_attachments WHERE owner_kind='attempt' AND owner_run_id=? AND owner_attempt_id=?")
+        (0, database_ts_1.recordStatement)(connection, "DELETE FROM ne19_attachments WHERE owner_kind='attempt' AND owner_run_id=? AND owner_attempt_id=?")
             .run(input.runId, input.attemptId);
-        (0, database_ts_1.recordStatement)(connection, "DELETE FROM ne18_members WHERE target_run_id=? AND origin_run_id=? AND attempt_id=?")
+        (0, database_ts_1.recordStatement)(connection, "DELETE FROM ne19_members WHERE target_run_id=? AND origin_run_id=? AND attempt_id=?")
             .run(input.runId, input.runId, input.attemptId);
-        (0, database_ts_1.recordStatement)(connection, "DELETE FROM ne18_attempts WHERE origin_run_id=? AND attempt_id=?")
+        (0, database_ts_1.recordStatement)(connection, "DELETE FROM ne19_attempts WHERE origin_run_id=? AND attempt_id=?")
             .run(input.runId, input.attemptId);
     });
 }
@@ -385,24 +387,24 @@ function visitRunSealEntries(connection, runId, visit, verifyPayloadBytes = true
         }
         return value;
     };
-    const record = (0, database_ts_1.recordStatement)(connection, "SELECT record_payload,record_digest FROM ne18_record_metadata WHERE singleton=1").get();
+    const record = (0, database_ts_1.recordStatement)(connection, "SELECT record_payload,record_digest FROM ne19_record_metadata WHERE singleton=1").get();
     visit((0, seal_ts_1.recordSealEntry)(verified(record, "record_digest", "record_payload")));
-    const run = (0, database_ts_1.recordStatement)(connection, `SELECT run_id,writer_generation,started_at,core_payload,core_digest FROM ne18_runs WHERE run_id=?`).get(runId);
+    const run = (0, database_ts_1.recordStatement)(connection, `SELECT run_id,writer_generation,started_at,core_payload,core_digest FROM ne19_runs WHERE run_id=?`).get(runId);
     if (run === undefined)
         throw (0, errors_ts_1.sqliteError)("record-seal-incomplete", "verify-seal", `Run ${runId} is missing`);
     visit((0, seal_ts_1.runSealEntry)({ runId: text(run, "run_id"), writerGeneration: text(run, "writer_generation"), startedAt: text(run, "started_at"), coreDigest: verified(run, "core_digest", "core_payload") }));
-    for (const row of (0, database_ts_1.recordStatement)(connection, "SELECT slot_id,ordinal,core_payload,core_digest FROM ne18_slots WHERE run_id=?").iterate(runId)) {
+    for (const row of (0, database_ts_1.recordStatement)(connection, "SELECT slot_id,ordinal,core_payload,core_digest FROM ne19_slots WHERE run_id=?").iterate(runId)) {
         visit((0, seal_ts_1.slotSealEntry)(runId, { slotId: text(row, "slot_id"), ordinal: integer(row, "ordinal"), coreDigest: verified(row, "core_digest", "core_payload") }));
     }
-    for (const row of (0, database_ts_1.recordStatement)(connection, "SELECT attempt_id,attempt_locator,core_payload,core_digest FROM ne18_attempts WHERE origin_run_id=?").iterate(runId)) {
+    for (const row of (0, database_ts_1.recordStatement)(connection, "SELECT attempt_id,attempt_locator,core_payload,core_digest FROM ne19_attempts WHERE origin_run_id=?").iterate(runId)) {
         visit((0, seal_ts_1.attemptSealEntry)(runId, text(row, "attempt_id"), text(row, "attempt_locator"), verified(row, "core_digest", "core_payload")));
     }
-    for (const row of (0, database_ts_1.recordStatement)(connection, `SELECT slot_id,origin_run_id,attempt_id,action,core_payload,core_digest FROM ne18_members WHERE target_run_id=?`).iterate(runId)) {
+    for (const row of (0, database_ts_1.recordStatement)(connection, `SELECT slot_id,origin_run_id,attempt_id,action,core_payload,core_digest FROM ne19_members WHERE target_run_id=?`).iterate(runId)) {
         visit((0, seal_ts_1.memberSealEntry)(runId, { slotId: text(row, "slot_id"), originRunId: optionalText(row, "origin_run_id"),
             attemptId: optionalText(row, "attempt_id"), action: memberAction(row, "action"), coreDigest: verified(row, "core_digest", "core_payload") }));
     }
     for (const row of (0, database_ts_1.recordStatement)(connection, `SELECT attachment_id,owner_kind,owner_run_id,owner_attempt_id,family,family_revision,logical_identity,
-    canonical_payload,canonical_digest,logical_inventory,inventory_digest FROM ne18_attachments WHERE owner_run_id=?`).iterate(runId)) {
+    canonical_payload,canonical_digest,logical_inventory,inventory_digest FROM ne19_attachments WHERE owner_run_id=?`).iterate(runId)) {
         const canonicalDigest = verified(row, "canonical_digest", "canonical_payload");
         const inventoryDigest = verified(row, "inventory_digest", "logical_inventory");
         visit((0, seal_ts_1.attachmentSealEntry)({ attachmentId: text(row, "attachment_id"), ownerKind: ownerKind(row, "owner_kind"),
@@ -410,25 +412,25 @@ function visitRunSealEntries(connection, runId, visit, verifyPayloadBytes = true
             familyRevision: integer(row, "family_revision"), logicalIdentity: text(row, "logical_identity"), canonicalDigest, inventoryDigest }));
     }
     for (const row of (0, database_ts_1.recordStatement)(connection, `SELECT r.attachment_id,r.ordinal,r.target_owner_kind,r.target_family,r.canonical_payload,r.reference_digest
-    FROM ne18_attachment_references r JOIN ne18_attachments a ON a.attachment_id=r.attachment_id WHERE a.owner_run_id=?`).iterate(runId)) {
+    FROM ne19_attachment_references r JOIN ne19_attachments a ON a.attachment_id=r.attachment_id WHERE a.owner_run_id=?`).iterate(runId)) {
         visit((0, seal_ts_1.referenceSealEntry)(text(row, "attachment_id"), { ordinal: integer(row, "ordinal"), owner: ownerKind(row, "target_owner_kind"),
             family: text(row, "target_family"), referenceDigest: verified(row, "reference_digest", "canonical_payload") }));
     }
     for (const row of (0, database_ts_1.recordStatement)(connection, `SELECT i.attachment_id,i.ordinal,i.logical_identity,i.canonical_payload,i.canonical_digest
-    FROM ne18_collection_items i JOIN ne18_attachments a ON a.attachment_id=i.attachment_id WHERE a.owner_run_id=?`).iterate(runId)) {
+    FROM ne19_collection_items i JOIN ne19_attachments a ON a.attachment_id=i.attachment_id WHERE a.owner_run_id=?`).iterate(runId)) {
         visit((0, seal_ts_1.collectionItemSealEntry)(text(row, "attachment_id"), { ordinal: integer(row, "ordinal"), logicalIdentity: text(row, "logical_identity"),
             canonicalDigest: verified(row, "canonical_digest", "canonical_payload") }));
     }
     for (const row of (0, database_ts_1.recordStatement)(connection, `SELECT c.content_id,c.attachment_id,c.logical_handle,c.byte_length,c.overall_digest,c.chunk_count
-    FROM ne18_contents c JOIN ne18_attachments a ON a.attachment_id=c.attachment_id WHERE a.owner_run_id=?`).iterate(runId)) {
+    FROM ne19_contents c JOIN ne19_attachments a ON a.attachment_id=c.attachment_id WHERE a.owner_run_id=?`).iterate(runId)) {
         visit((0, seal_ts_1.contentSealEntry)(text(row, "attachment_id"), { contentId: text(row, "content_id"), logicalHandle: text(row, "logical_handle"),
             byteLength: integer(row, "byte_length"), digest: text(row, "overall_digest"), chunkCount: integer(row, "chunk_count") }));
     }
     const chunkSql = verifyContentChunkBytes
-        ? `SELECT c.content_id,c.ordinal,c.bytes,c.chunk_digest FROM ne18_content_chunks c
-      JOIN ne18_contents n ON n.content_id=c.content_id JOIN ne18_attachments a ON a.attachment_id=n.attachment_id WHERE a.owner_run_id=?`
-        : `SELECT c.content_id,c.ordinal,c.chunk_digest FROM ne18_content_chunks c
-      JOIN ne18_contents n ON n.content_id=c.content_id JOIN ne18_attachments a ON a.attachment_id=n.attachment_id WHERE a.owner_run_id=?`;
+        ? `SELECT c.content_id,c.ordinal,c.bytes,c.chunk_digest FROM ne19_content_chunks c
+      JOIN ne19_contents n ON n.content_id=c.content_id JOIN ne19_attachments a ON a.attachment_id=n.attachment_id WHERE a.owner_run_id=?`
+        : `SELECT c.content_id,c.ordinal,c.chunk_digest FROM ne19_content_chunks c
+      JOIN ne19_contents n ON n.content_id=c.content_id JOIN ne19_attachments a ON a.attachment_id=n.attachment_id WHERE a.owner_run_id=?`;
     for (const row of (0, database_ts_1.recordStatement)(connection, chunkSql).iterate(runId)) {
         const chunkDigest = text(row, "chunk_digest");
         requireDigest(chunkDigest, "chunk_digest");
@@ -444,8 +446,8 @@ function collectRunSealEntries(connection, runId) {
     return orderEntries(entries);
 }
 function runRow(connection, runId) {
-    return (0, database_ts_1.recordStatement)(connection, `SELECT run_id,status,writer_generation,started_at,core_payload,core_digest,mutation_sequence,
-    candidate_seal_identity,candidate_seal_entry_count,candidate_seal_staged_count,logical_seal_identity FROM ne18_runs WHERE run_id=?`)
+    return (0, database_ts_1.recordStatement)(connection, `SELECT run_id,experiment_id,status,writer_generation,started_at,core_payload,core_digest,mutation_sequence,
+    candidate_seal_identity,candidate_seal_entry_count,candidate_seal_staged_count,logical_seal_identity FROM ne19_runs WHERE run_id=?`)
         .get(runId);
 }
 function assertBoundedBatch(operation, rowCount, byteCount) {
@@ -460,11 +462,11 @@ function assertBoundedRow(operation, field, value) {
     }
 }
 function assertRunFence(connection, runId, writerGeneration, operation, expectedStatus = "open") {
-    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 (0, errors_ts_1.sqliteError)("record-command-conflict", operation, "ProjectDatabase writer barrier is not open");
     }
-    const active = (0, database_ts_1.recordStatement)(connection, "SELECT 1 FROM ne18_run_resources WHERE run_id=? AND terminal_state IS NULL AND current_writer_generation=?")
+    const active = (0, database_ts_1.recordStatement)(connection, "SELECT 1 FROM ne19_run_resources WHERE run_id=? AND terminal_state IS NULL AND current_writer_generation=?")
         .get(runId, writerGeneration);
     const row = runRow(connection, runId);
     if (active === undefined || row === undefined || text(row, "writer_generation") !== writerGeneration || text(row, "status") !== expectedStatus) {
@@ -473,23 +475,37 @@ function assertRunFence(connection, runId, writerGeneration, operation, expected
     return row;
 }
 function bumpMutationSequence(connection, runId) {
-    (0, database_ts_1.recordStatement)(connection, "UPDATE ne18_runs SET mutation_sequence=mutation_sequence+1 WHERE run_id=? AND status='open'").run(runId);
+    (0, database_ts_1.recordStatement)(connection, "UPDATE ne19_runs SET mutation_sequence=mutation_sequence+1 WHERE run_id=? AND status='open'").run(runId);
 }
 function assertAttachmentFence(connection, runId, attachmentId, operation) {
-    const row = (0, database_ts_1.recordStatement)(connection, `SELECT a.owner_run_id,a.owner_kind,at.publication_state FROM ne18_attachments a
-    LEFT JOIN ne18_attempts at ON at.origin_run_id=a.owner_run_id AND at.attempt_id=a.owner_attempt_id
+    const row = (0, database_ts_1.recordStatement)(connection, `SELECT a.owner_run_id,a.owner_kind,at.publication_state FROM ne19_attachments a
+    LEFT JOIN ne19_attempts at ON at.origin_run_id=a.owner_run_id AND at.attempt_id=a.owner_attempt_id
     WHERE a.attachment_id=?`).get(attachmentId);
     if (row === undefined || text(row, "owner_run_id") !== runId ||
         (text(row, "owner_kind") === "attempt" && optionalText(row, "publication_state") === "published")) {
         throw (0, errors_ts_1.sqliteError)("record-command-conflict", operation, `Attachment ${attachmentId} does not belong to Run ${runId}`);
     }
 }
+function validatedRunExperimentId(bytes, runId) {
+    let decoded;
+    try {
+        decoded = (0, core_ts_1.decodeRunDocument)(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes)));
+    }
+    catch (cause) {
+        throw (0, errors_ts_1.sqliteError)("record-content-invalid", "run-experiment-identity", "Run Core is not valid JSON", cause);
+    }
+    if (effect_1.Result.isFailure(decoded) || decoded.success.runId !== runId) {
+        throw (0, errors_ts_1.sqliteError)("record-content-invalid", "run-experiment-identity", "Run Core identity is invalid");
+    }
+    return decoded.success.experimentId;
+}
 function beginRun(connection, input) {
     requireIdentity(input.runId, "runId");
+    requireIdentity(input.experimentId, "experimentId");
     requireIdentity(input.writerGeneration, "writerGeneration");
     requireIdentity(input.startedAt, "startedAt");
     (0, transaction_ts_1.withImmediateTransaction)(connection, input.deadlineEpochMs, "begin-run", () => {
-        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)
             throw (0, errors_ts_1.sqliteError)("record-database-invalid", "begin-run", "ProjectDatabase barrier is missing");
         if (text(barrier, "barrier_state") === "draining") {
@@ -497,11 +513,11 @@ function beginRun(connection, input) {
         }
         if (text(barrier, "barrier_state") === "portable")
             throw (0, errors_ts_1.sqliteError)("record-command-conflict", "begin-run", "ProjectDatabase must reopen before writer admission");
-        (0, database_ts_1.recordStatement)(connection, `INSERT OR IGNORE INTO ne18_runs(run_id,status,writer_generation,started_at,core_payload,core_digest,
+        (0, database_ts_1.recordStatement)(connection, `INSERT OR IGNORE INTO ne19_runs(run_id,experiment_id,status,writer_generation,started_at,core_payload,core_digest,
       mutation_sequence,candidate_seal_identity,candidate_seal_entry_count,candidate_seal_staged_count,logical_seal_identity)
-      VALUES (?,'open',?,?,NULL,NULL,0,NULL,NULL,0,NULL)`).run(input.runId, input.writerGeneration, input.startedAt);
+      VALUES (?,?,'open',?,?,NULL,NULL,0,NULL,NULL,0,NULL)`).run(input.runId, input.experimentId, input.writerGeneration, input.startedAt);
         const stored = runRow(connection, input.runId);
-        if (stored === undefined || text(stored, "writer_generation") !== input.writerGeneration ||
+        if (stored === undefined || text(stored, "experiment_id") !== input.experimentId || text(stored, "writer_generation") !== input.writerGeneration ||
             text(stored, "started_at") !== input.startedAt) {
             throw (0, errors_ts_1.sqliteError)("record-command-conflict", "begin-run", `Run ${input.runId} conflicts with its durable admission`);
         }
@@ -515,9 +531,9 @@ function admitAttempt(connection, input) {
     requireAttemptLocator(input.attemptId, input.attemptLocator, "admit-attempt");
     (0, transaction_ts_1.withImmediateTransaction)(connection, input.deadlineEpochMs, "admit-attempt", () => {
         assertRunFence(connection, input.runId, input.writerGeneration, "admit-attempt");
-        const inserted = (0, database_ts_1.recordStatement)(connection, `INSERT OR IGNORE INTO ne18_attempts(origin_run_id,attempt_id,attempt_locator,core_payload,core_digest)
+        const inserted = (0, database_ts_1.recordStatement)(connection, `INSERT OR IGNORE INTO ne19_attempts(origin_run_id,attempt_id,attempt_locator,core_payload,core_digest)
       VALUES (?,?,?,NULL,NULL)`).run(input.runId, input.attemptId, input.attemptLocator);
-        const stored = (0, database_ts_1.recordStatement)(connection, "SELECT origin_run_id,attempt_locator FROM ne18_attempts WHERE origin_run_id=? AND attempt_id=?")
+        const stored = (0, database_ts_1.recordStatement)(connection, "SELECT origin_run_id,attempt_locator FROM ne19_attempts WHERE origin_run_id=? AND attempt_id=?")
             .get(input.runId, input.attemptId);
         if (stored === undefined || text(stored, "origin_run_id") !== input.runId || text(stored, "attempt_locator") !== input.attemptLocator) {
             throw (0, errors_ts_1.sqliteError)("record-command-conflict", "admit-attempt", `Attempt ${input.attemptId} conflicts with its durable admission`);
@@ -538,15 +554,15 @@ function admitAttachment(connection, input) {
     (0, transaction_ts_1.withImmediateTransaction)(connection, input.deadlineEpochMs, "admit-attachment", () => {
         assertRunFence(connection, input.runId, input.writerGeneration, "admit-attachment");
         if (input.ownerKind === "attempt") {
-            const admitted = (0, database_ts_1.recordStatement)(connection, "SELECT 1 AS admitted FROM ne18_attempts WHERE origin_run_id=? AND attempt_id=?")
+            const admitted = (0, database_ts_1.recordStatement)(connection, "SELECT 1 AS admitted FROM ne19_attempts WHERE origin_run_id=? AND attempt_id=?")
                 .get(input.runId, input.ownerAttemptId);
             if (admitted === undefined)
                 throw (0, errors_ts_1.sqliteError)("record-command-conflict", "admit-attachment", "attempt owner is not admitted");
         }
-        const inserted = (0, database_ts_1.recordStatement)(connection, `INSERT OR IGNORE INTO ne18_attachments(attachment_id,owner_kind,owner_run_id,owner_attempt_id,
+        const inserted = (0, database_ts_1.recordStatement)(connection, `INSERT OR IGNORE INTO ne19_attachments(attachment_id,owner_kind,owner_run_id,owner_attempt_id,
       family,family_revision,logical_identity,canonical_payload,canonical_digest,logical_inventory,inventory_digest)
       VALUES (?,?,?,?,?,?,NULL,NULL,NULL,NULL,NULL)`).run(input.attachmentId, input.ownerKind, input.ownerRunId, input.ownerAttemptId ?? null, input.family, input.familyRevision);
-        const stored = (0, database_ts_1.recordStatement)(connection, `SELECT owner_kind,owner_run_id,owner_attempt_id,family,family_revision FROM ne18_attachments
+        const stored = (0, database_ts_1.recordStatement)(connection, `SELECT owner_kind,owner_run_id,owner_attempt_id,family,family_revision FROM ne19_attachments
       WHERE attachment_id=?`).get(input.attachmentId);
         if (stored === undefined || text(stored, "owner_kind") !== input.ownerKind || text(stored, "owner_run_id") !== input.ownerRunId ||
             optionalText(stored, "owner_attempt_id") !== input.ownerAttemptId || text(stored, "family") !== input.family ||
@@ -562,16 +578,16 @@ function admitContent(connection, input) {
     requireIdentity(input.logicalHandle, "logicalHandle");
     (0, transaction_ts_1.withImmediateTransaction)(connection, input.deadlineEpochMs, "admit-content", () => {
         assertRunFence(connection, input.runId, input.writerGeneration, "admit-content");
-        const attachment = (0, database_ts_1.recordStatement)(connection, `SELECT a.owner_run_id,a.owner_kind,at.publication_state FROM ne18_attachments a
-      LEFT JOIN ne18_attempts at ON at.origin_run_id=a.owner_run_id AND at.attempt_id=a.owner_attempt_id WHERE a.attachment_id=?`)
+        const attachment = (0, database_ts_1.recordStatement)(connection, `SELECT a.owner_run_id,a.owner_kind,at.publication_state FROM ne19_attachments a
+      LEFT JOIN ne19_attempts at ON at.origin_run_id=a.owner_run_id AND at.attempt_id=a.owner_attempt_id WHERE a.attachment_id=?`)
             .get(input.attachmentId);
         if (attachment === undefined || text(attachment, "owner_run_id") !== input.runId ||
             (text(attachment, "owner_kind") === "attempt" && optionalText(attachment, "publication_state") === "published")) {
             throw (0, errors_ts_1.sqliteError)("record-command-conflict", "admit-content", "attachment admission is missing");
         }
-        const inserted = (0, database_ts_1.recordStatement)(connection, `INSERT OR IGNORE INTO ne18_contents(content_id,attachment_id,logical_handle,byte_length,overall_digest,chunk_count)
+        const inserted = (0, database_ts_1.recordStatement)(connection, `INSERT OR IGNORE INTO ne19_contents(content_id,attachment_id,logical_handle,byte_length,overall_digest,chunk_count)
       VALUES (?,?,?,NULL,NULL,NULL)`).run(input.contentId, input.attachmentId, input.logicalHandle);
-        const stored = (0, database_ts_1.recordStatement)(connection, "SELECT attachment_id,logical_handle FROM ne18_contents WHERE content_id=?")
+        const stored = (0, database_ts_1.recordStatement)(connection, "SELECT attachment_id,logical_handle FROM ne19_contents WHERE content_id=?")
             .get(input.contentId);
         if (stored === undefined || text(stored, "attachment_id") !== input.attachmentId || text(stored, "logical_handle") !== input.logicalHandle) {
             throw (0, errors_ts_1.sqliteError)("record-command-conflict", "admit-content", `Content ${input.contentId} conflicts with its durable admission`);
@@ -594,13 +610,13 @@ function stageAttachmentMetadata(connection, input) {
     const byteCount = attachment.canonicalBytes.byteLength + attachment.logicalInventoryBytes.byteLength;
     assertBoundedBatch("stage-attachment", 1 + attachment.contents.length, byteCount);
     (0, transaction_ts_1.withImmediateTransaction)(connection, input.deadlineEpochMs, "stage-attachment", () => {
-        (0, database_ts_1.recordStatement)(connection, `INSERT OR IGNORE INTO ne18_attachments(attachment_id,owner_kind,owner_run_id,owner_attempt_id,family,family_revision,logical_identity,canonical_payload,canonical_digest,logical_inventory,inventory_digest)
+        (0, database_ts_1.recordStatement)(connection, `INSERT OR IGNORE INTO ne19_attachments(attachment_id,owner_kind,owner_run_id,owner_attempt_id,family,family_revision,logical_identity,canonical_payload,canonical_digest,logical_inventory,inventory_digest)
       VALUES (?,?,?,?,?,?,?,?,?,?,?)`).run(attachment.attachmentId, attachment.ownerKind, attachment.ownerRunId, attachment.ownerAttemptId ?? null, attachment.family, attachment.familyRevision, attachment.logicalIdentity, attachment.canonicalBytes, attachment.canonicalDigest, attachment.logicalInventoryBytes, attachment.inventoryDigest);
         for (const content of attachment.contents)
-            (0, database_ts_1.recordStatement)(connection, `INSERT OR IGNORE INTO ne18_contents(content_id,attachment_id,logical_handle,byte_length,overall_digest,chunk_count)
+            (0, database_ts_1.recordStatement)(connection, `INSERT OR IGNORE INTO ne19_contents(content_id,attachment_id,logical_handle,byte_length,overall_digest,chunk_count)
       VALUES (?,?,?,?,?,?)`).run(content.contentId, attachment.attachmentId, content.logicalHandle, content.byteLength, content.digest, content.chunkCount);
         const stored = (0, database_ts_1.recordStatement)(connection, `SELECT owner_kind,owner_run_id,owner_attempt_id,family,family_revision,logical_identity,
-      canonical_payload,canonical_digest,logical_inventory,inventory_digest FROM ne18_attachments WHERE attachment_id=?`)
+      canonical_payload,canonical_digest,logical_inventory,inventory_digest FROM ne19_attachments WHERE attachment_id=?`)
             .get(attachment.attachmentId);
         if (stored === undefined || text(stored, "owner_kind") !== attachment.ownerKind || text(stored, "owner_run_id") !== attachment.ownerRunId ||
             optionalText(stored, "owner_attempt_id") !== attachment.ownerAttemptId || text(stored, "family") !== attachment.family ||
@@ -610,7 +626,7 @@ function stageAttachmentMetadata(connection, input) {
             throw (0, errors_ts_1.sqliteError)("record-command-conflict", "stage-attachment", `attachment ${attachment.attachmentId} conflicts with its durable retry`);
         for (const content of attachment.contents) {
             const persisted = (0, database_ts_1.recordStatement)(connection, `SELECT attachment_id,logical_handle,byte_length,overall_digest,chunk_count
-        FROM ne18_contents WHERE content_id=?`).get(content.contentId);
+        FROM ne19_contents WHERE content_id=?`).get(content.contentId);
             if (persisted === undefined || text(persisted, "attachment_id") !== attachment.attachmentId || text(persisted, "logical_handle") !== content.logicalHandle ||
                 integer(persisted, "byte_length") !== content.byteLength || text(persisted, "overall_digest") !== content.digest || integer(persisted, "chunk_count") !== content.chunkCount)
                 throw (0, errors_ts_1.sqliteError)("record-command-conflict", "stage-attachment", `content ${content.contentId} metadata conflicts with its durable retry`);
@@ -686,31 +702,31 @@ function assertFinalInputStored(connection, input) {
         text(header, "core_digest") !== input.runCoreDigest || !bytesEqual(bytes(header, "core_payload"), input.runCoreBytes)) {
         throw (0, errors_ts_1.sqliteError)("record-command-conflict", "finalize-run", `Run ${input.runId} conflicts with committed finalization`);
     }
-    const record = (0, database_ts_1.recordStatement)(connection, "SELECT record_payload,record_digest FROM ne18_record_metadata WHERE singleton=1").get();
+    const record = (0, database_ts_1.recordStatement)(connection, "SELECT record_payload,record_digest FROM ne19_record_metadata WHERE singleton=1").get();
     if (text(record, "record_digest") !== input.recordCoreDigest || !bytesEqual(bytes(record, "record_payload"), input.recordCoreBytes)) {
         throw (0, errors_ts_1.sqliteError)("record-command-conflict", "finalize-run", "Project RecordDocument conflicts with committed finalization");
     }
-    const counts = (0, database_ts_1.recordStatement)(connection, `SELECT (SELECT count(*) FROM ne18_slots WHERE run_id=?) slots,
-    (SELECT count(*) FROM ne18_attempts WHERE origin_run_id=?) attempts,(SELECT count(*) FROM ne18_members WHERE target_run_id=?) members,
-    (SELECT count(*) FROM ne18_attachments WHERE owner_run_id=?) attachments`).get(input.runId, input.runId, input.runId, input.runId);
+    const counts = (0, database_ts_1.recordStatement)(connection, `SELECT (SELECT count(*) FROM ne19_slots WHERE run_id=?) slots,
+    (SELECT count(*) FROM ne19_attempts WHERE origin_run_id=?) attempts,(SELECT count(*) FROM ne19_members WHERE target_run_id=?) members,
+    (SELECT count(*) FROM ne19_attachments WHERE owner_run_id=?) attachments`).get(input.runId, input.runId, input.runId, input.runId);
     if (integer(counts, "slots") !== input.slots.length || integer(counts, "attempts") !== input.attempts.length ||
         integer(counts, "members") !== input.members.length || integer(counts, "attachments") !== input.attachments.length) {
         throw (0, errors_ts_1.sqliteError)("record-command-conflict", "finalize-run", "committed inventory differs from retry input");
     }
     for (const slot of input.slots) {
-        const stored = (0, database_ts_1.recordStatement)(connection, "SELECT ordinal,core_payload,core_digest FROM ne18_slots WHERE run_id=? AND slot_id=?").get(input.runId, slot.slotId);
+        const stored = (0, database_ts_1.recordStatement)(connection, "SELECT ordinal,core_payload,core_digest FROM ne19_slots WHERE run_id=? AND slot_id=?").get(input.runId, slot.slotId);
         if (stored === undefined || integer(stored, "ordinal") !== slot.ordinal || text(stored, "core_digest") !== slot.coreDigest || !bytesEqual(bytes(stored, "core_payload"), slot.coreBytes)) {
             throw (0, errors_ts_1.sqliteError)("record-command-conflict", "finalize-run", `Slot ${slot.slotId} conflicts with committed finalization`);
         }
     }
     for (const attempt of input.attempts) {
-        const stored = (0, database_ts_1.recordStatement)(connection, "SELECT attempt_locator,core_payload,core_digest FROM ne18_attempts WHERE origin_run_id=? AND attempt_id=?").get(input.runId, attempt.attemptId);
+        const stored = (0, database_ts_1.recordStatement)(connection, "SELECT attempt_locator,core_payload,core_digest FROM ne19_attempts WHERE origin_run_id=? AND attempt_id=?").get(input.runId, attempt.attemptId);
         if (stored === undefined || text(stored, "attempt_locator") !== attempt.attemptLocator || text(stored, "core_digest") !== attempt.coreDigest || !bytesEqual(bytes(stored, "core_payload"), attempt.coreBytes)) {
             throw (0, errors_ts_1.sqliteError)("record-command-conflict", "finalize-run", `Attempt ${attempt.attemptId} conflicts with committed finalization`);
         }
     }
     for (const member of input.members) {
-        const stored = (0, database_ts_1.recordStatement)(connection, "SELECT origin_run_id,attempt_id,action,core_payload,core_digest FROM ne18_members WHERE target_run_id=? AND slot_id=?").get(input.runId, member.slotId);
+        const stored = (0, database_ts_1.recordStatement)(connection, "SELECT origin_run_id,attempt_id,action,core_payload,core_digest FROM ne19_members WHERE target_run_id=? AND slot_id=?").get(input.runId, member.slotId);
         if (stored === undefined || optionalText(stored, "origin_run_id") !== member.originRunId || optionalText(stored, "attempt_id") !== member.attemptId ||
             text(stored, "action") !== member.action || text(stored, "core_digest") !== member.coreDigest || !bytesEqual(bytes(stored, "core_payload"), member.coreBytes)) {
             throw (0, errors_ts_1.sqliteError)("record-command-conflict", "finalize-run", `Member ${member.slotId} conflicts with committed finalization`);
@@ -718,7 +734,7 @@ function assertFinalInputStored(connection, input) {
     }
     for (const attachment of input.attachments) {
         const stored = (0, database_ts_1.recordStatement)(connection, `SELECT owner_kind,owner_run_id,owner_attempt_id,family,family_revision,logical_identity,canonical_payload,canonical_digest,logical_inventory,inventory_digest
-      FROM ne18_attachments WHERE attachment_id=? AND owner_run_id=?`).get(attachment.attachmentId, input.runId);
+      FROM ne19_attachments WHERE attachment_id=? AND owner_run_id=?`).get(attachment.attachmentId, input.runId);
         if (stored === undefined || text(stored, "owner_kind") !== attachment.ownerKind || text(stored, "owner_run_id") !== attachment.ownerRunId ||
             optionalText(stored, "owner_attempt_id") !== attachment.ownerAttemptId || text(stored, "family") !== attachment.family ||
             integer(stored, "family_revision") !== attachment.familyRevision ||
@@ -727,11 +743,11 @@ function assertFinalInputStored(connection, input) {
             !bytesEqual(bytes(stored, "logical_inventory"), attachment.logicalInventoryBytes)) {
             throw (0, errors_ts_1.sqliteError)("record-command-conflict", "finalize-run", `Attachment ${attachment.attachmentId} conflicts with committed finalization`);
         }
-        const count = (0, database_ts_1.recordStatement)(connection, "SELECT count(*) AS count FROM ne18_contents WHERE attachment_id=?").get(attachment.attachmentId);
+        const count = (0, database_ts_1.recordStatement)(connection, "SELECT count(*) AS count FROM ne19_contents WHERE attachment_id=?").get(attachment.attachmentId);
         if (integer(count, "count") !== attachment.contents.length)
             throw (0, errors_ts_1.sqliteError)("record-command-conflict", "finalize-run", `Attachment ${attachment.attachmentId} Content inventory differs`);
         for (const content of attachment.contents) {
-            const persisted = (0, database_ts_1.recordStatement)(connection, "SELECT logical_handle,byte_length,overall_digest,chunk_count FROM ne18_contents WHERE content_id=? AND attachment_id=?")
+            const persisted = (0, database_ts_1.recordStatement)(connection, "SELECT logical_handle,byte_length,overall_digest,chunk_count FROM ne19_contents WHERE content_id=? AND attachment_id=?")
                 .get(content.contentId, attachment.attachmentId);
             if (persisted === undefined || text(persisted, "logical_handle") !== content.logicalHandle || integer(persisted, "byte_length") !== content.byteLength ||
                 text(persisted, "overall_digest") !== content.digest || integer(persisted, "chunk_count") !== content.chunkCount) {
@@ -793,8 +809,8 @@ function stageSealEntries(connection, input) {
         if (integer(current, "candidate_seal_staged_count") !== stagedBefore) {
             throw (0, errors_ts_1.sqliteError)("record-command-conflict", "prepare-seal", "Seal staged prefix changed before batch transaction");
         }
-        const insert = (0, database_ts_1.recordStatement)(connection, "INSERT OR IGNORE INTO ne18_run_seal_entries(run_id,ordinal,entry_kind,logical_identity,digest) VALUES (?,?,?,?,?)");
-        const read = (0, database_ts_1.recordStatement)(connection, "SELECT entry_kind,logical_identity,digest FROM ne18_run_seal_entries WHERE run_id=? AND ordinal=?");
+        const insert = (0, database_ts_1.recordStatement)(connection, "INSERT OR IGNORE INTO ne19_run_seal_entries(run_id,ordinal,entry_kind,logical_identity,digest) VALUES (?,?,?,?,?)");
+        const read = (0, database_ts_1.recordStatement)(connection, "SELECT entry_kind,logical_identity,digest FROM ne19_run_seal_entries WHERE run_id=? AND ordinal=?");
         batch.forEach((entry, index) => {
             const ordinal = input.startOrdinal + index;
             insert.run(input.runId, ordinal, entry.kind, entry.logicalIdentity, entry.digest);
@@ -805,7 +821,7 @@ function stageSealEntries(connection, input) {
             }
         });
         const next = input.startOrdinal + batch.length;
-        const advanced = (0, database_ts_1.recordStatement)(connection, `UPDATE ne18_runs SET candidate_seal_staged_count=?
+        const advanced = (0, database_ts_1.recordStatement)(connection, `UPDATE ne19_runs SET candidate_seal_staged_count=?
       WHERE run_id=? AND status='sealing' AND candidate_seal_staged_count=?`).run(Math.max(stagedBefore, next), input.runId, stagedBefore);
         if (Number(advanced.changes) !== 1)
             throw (0, errors_ts_1.sqliteError)("record-command-conflict", "prepare-seal", "Seal staged prefix changed during batch transaction");
@@ -815,7 +831,7 @@ function stageSealEntries(connection, input) {
 }
 /** Reads the durable identity shared by every Run, including after a project move. */
 function readRecordCore(connection) {
-    const row = (0, database_ts_1.recordStatement)(connection, "SELECT record_payload,record_digest FROM ne18_record_metadata WHERE singleton=1").get();
+    const row = (0, database_ts_1.recordStatement)(connection, "SELECT record_payload,record_digest FROM ne19_record_metadata WHERE singleton=1").get();
     if (row === undefined || row.record_payload === null)
         return undefined;
     const payload = bytes(row, "record_payload");
@@ -828,14 +844,15 @@ function preserveRecordCore(connection, input) {
         throw (0, errors_ts_1.sqliteError)("record-command-conflict", "publish-record-core", "Existing Record identity cannot be replaced");
     }
     if (existing === undefined) {
-        (0, database_ts_1.recordStatement)(connection, "UPDATE ne18_record_metadata SET record_payload=?,record_digest=? WHERE singleton=1").run(input.recordCoreBytes, input.recordCoreDigest);
+        (0, database_ts_1.recordStatement)(connection, "UPDATE ne19_record_metadata SET record_payload=?,record_digest=? WHERE singleton=1").run(input.recordCoreBytes, input.recordCoreDigest);
     }
 }
 /** One bounded transaction that publishes final Core/metadata but not a Seal fence. */
 function stageRunFinalMetadata(connection, input) {
     validateFinalInput(input);
+    const experimentId = validatedRunExperimentId(input.runCoreBytes, input.runId);
     const header = runRow(connection, input.runId);
-    if (header === undefined || text(header, "writer_generation") !== input.writerGeneration || text(header, "started_at") !== input.startedAt) {
+    if (header === undefined || text(header, "experiment_id") !== experimentId || text(header, "writer_generation") !== input.writerGeneration || text(header, "started_at") !== input.startedAt) {
         throw (0, errors_ts_1.sqliteError)("record-command-conflict", "finalize-run", `Run ${input.runId} admission fence is missing or changed`);
     }
     if (text(header, "status") === "open") {
@@ -844,23 +861,23 @@ function stageRunFinalMetadata(connection, input) {
             if (text(current, "status") !== "open")
                 throw (0, errors_ts_1.sqliteError)("record-command-conflict", "stage-final-metadata", "Run final metadata fence changed");
             preserveRecordCore(connection, input);
-            (0, database_ts_1.recordStatement)(connection, "UPDATE ne18_runs SET core_payload=?,core_digest=? WHERE run_id=? AND status='open'").run(input.runCoreBytes, input.runCoreDigest, input.runId);
+            (0, database_ts_1.recordStatement)(connection, "UPDATE ne19_runs SET core_payload=?,core_digest=? WHERE run_id=? AND status='open'").run(input.runCoreBytes, input.runCoreDigest, input.runId);
             for (const slot of input.slots)
-                (0, database_ts_1.recordStatement)(connection, "INSERT OR IGNORE INTO ne18_slots(run_id,slot_id,ordinal,core_payload,core_digest) VALUES (?,?,?,?,?)").run(input.runId, slot.slotId, slot.ordinal, slot.coreBytes, slot.coreDigest);
+                (0, database_ts_1.recordStatement)(connection, "INSERT OR IGNORE INTO ne19_slots(run_id,slot_id,ordinal,core_payload,core_digest) VALUES (?,?,?,?,?)").run(input.runId, slot.slotId, slot.ordinal, slot.coreBytes, slot.coreDigest);
             for (const attempt of input.attempts)
-                (0, database_ts_1.recordStatement)(connection, "UPDATE ne18_attempts SET core_payload=?,core_digest=? WHERE origin_run_id=? AND attempt_id=?").run(attempt.coreBytes, attempt.coreDigest, input.runId, attempt.attemptId);
+                (0, database_ts_1.recordStatement)(connection, "UPDATE ne19_attempts SET core_payload=?,core_digest=? WHERE origin_run_id=? AND attempt_id=?").run(attempt.coreBytes, attempt.coreDigest, input.runId, attempt.attemptId);
             for (const member of input.members)
-                (0, database_ts_1.recordStatement)(connection, "INSERT OR REPLACE INTO ne18_members(target_run_id,slot_id,origin_run_id,attempt_id,action,core_payload,core_digest) VALUES (?,?,?,?,?,?,?)")
+                (0, database_ts_1.recordStatement)(connection, "INSERT OR REPLACE INTO ne19_members(target_run_id,slot_id,origin_run_id,attempt_id,action,core_payload,core_digest) VALUES (?,?,?,?,?,?,?)")
                     .run(input.runId, member.slotId, member.originRunId ?? null, member.attemptId ?? null, member.action, member.coreBytes, member.coreDigest);
             for (const attachment of input.attachments) {
-                (0, database_ts_1.recordStatement)(connection, `UPDATE ne18_attachments SET logical_identity=?,canonical_payload=?,canonical_digest=?,logical_inventory=?,inventory_digest=?
+                (0, database_ts_1.recordStatement)(connection, `UPDATE ne19_attachments SET logical_identity=?,canonical_payload=?,canonical_digest=?,logical_inventory=?,inventory_digest=?
           WHERE attachment_id=? AND owner_run_id=? AND NOT (owner_kind='attempt' AND EXISTS
-            (SELECT 1 FROM ne18_attempts WHERE origin_run_id=ne18_attachments.owner_run_id AND attempt_id=ne18_attachments.owner_attempt_id AND publication_state='published'))`).run(attachment.logicalIdentity, attachment.canonicalBytes, attachment.canonicalDigest, attachment.logicalInventoryBytes, attachment.inventoryDigest, attachment.attachmentId, input.runId);
+            (SELECT 1 FROM ne19_attempts WHERE origin_run_id=ne19_attachments.owner_run_id AND attempt_id=ne19_attachments.owner_attempt_id AND publication_state='published'))`).run(attachment.logicalIdentity, attachment.canonicalBytes, attachment.canonicalDigest, attachment.logicalInventoryBytes, attachment.inventoryDigest, attachment.attachmentId, input.runId);
                 for (const content of attachment.contents)
-                    (0, database_ts_1.recordStatement)(connection, `UPDATE ne18_contents SET byte_length=?,overall_digest=?,chunk_count=?
-          WHERE content_id=? AND attachment_id=? AND NOT EXISTS (SELECT 1 FROM ne18_attachments a JOIN ne18_attempts at
+                    (0, database_ts_1.recordStatement)(connection, `UPDATE ne19_contents SET byte_length=?,overall_digest=?,chunk_count=?
+          WHERE content_id=? AND attachment_id=? AND NOT EXISTS (SELECT 1 FROM ne19_attachments a JOIN ne19_attempts at
             ON at.origin_run_id=a.owner_run_id AND at.attempt_id=a.owner_attempt_id
-            WHERE a.attachment_id=ne18_contents.attachment_id AND a.owner_kind='attempt' AND at.publication_state='published')`)
+            WHERE a.attachment_id=ne19_contents.attachment_id AND a.owner_kind='attempt' AND at.publication_state='published')`)
                         .run(content.byteLength, content.digest, content.chunkCount, content.contentId, attachment.attachmentId);
             }
             bumpMutationSequence(connection, input.runId);
@@ -879,25 +896,25 @@ function stageRunPublicationMetadata(connection, input) {
     (0, transaction_ts_1.withImmediateTransaction)(connection, input.deadlineEpochMs, "publish-attempt-metadata", () => {
         assertRunFence(connection, input.runId, input.writerGeneration, "publish-attempt-metadata");
         preserveRecordCore(connection, input);
-        (0, database_ts_1.recordStatement)(connection, "UPDATE ne18_runs SET core_payload=?,core_digest=? WHERE run_id=? AND status='open'").run(input.runCoreBytes, input.runCoreDigest, input.runId);
+        (0, database_ts_1.recordStatement)(connection, "UPDATE ne19_runs SET core_payload=?,core_digest=? WHERE run_id=? AND status='open'").run(input.runCoreBytes, input.runCoreDigest, input.runId);
         for (const slot of input.slots)
-            (0, database_ts_1.recordStatement)(connection, "INSERT OR REPLACE INTO ne18_slots(run_id,slot_id,ordinal,core_payload,core_digest) VALUES (?,?,?,?,?)").run(input.runId, slot.slotId, slot.ordinal, slot.coreBytes, slot.coreDigest);
+            (0, database_ts_1.recordStatement)(connection, "INSERT OR REPLACE INTO ne19_slots(run_id,slot_id,ordinal,core_payload,core_digest) VALUES (?,?,?,?,?)").run(input.runId, slot.slotId, slot.ordinal, slot.coreBytes, slot.coreDigest);
         for (const attempt of input.attempts)
-            (0, database_ts_1.recordStatement)(connection, `UPDATE ne18_attempts SET core_payload=?,core_digest=?,
+            (0, database_ts_1.recordStatement)(connection, `UPDATE ne19_attempts SET core_payload=?,core_digest=?,
       publication_state=CASE WHEN publication_state='staging' THEN 'sealing' ELSE publication_state END
       WHERE origin_run_id=? AND attempt_id=?`).run(attempt.coreBytes, attempt.coreDigest, input.runId, attempt.attemptId);
         for (const member of input.members)
-            (0, database_ts_1.recordStatement)(connection, "INSERT OR REPLACE INTO ne18_members(target_run_id,slot_id,origin_run_id,attempt_id,action,core_payload,core_digest) VALUES (?,?,?,?,?,?,?)")
+            (0, database_ts_1.recordStatement)(connection, "INSERT OR REPLACE INTO ne19_members(target_run_id,slot_id,origin_run_id,attempt_id,action,core_payload,core_digest) VALUES (?,?,?,?,?,?,?)")
                 .run(input.runId, member.slotId, member.originRunId ?? null, member.attemptId ?? null, member.action, member.coreBytes, member.coreDigest);
         for (const attachment of input.attachments) {
-            (0, database_ts_1.recordStatement)(connection, `UPDATE ne18_attachments SET logical_identity=?,canonical_payload=?,canonical_digest=?,logical_inventory=?,inventory_digest=?
+            (0, database_ts_1.recordStatement)(connection, `UPDATE ne19_attachments SET logical_identity=?,canonical_payload=?,canonical_digest=?,logical_inventory=?,inventory_digest=?
         WHERE attachment_id=? AND owner_run_id=? AND NOT (owner_kind='attempt' AND EXISTS
-          (SELECT 1 FROM ne18_attempts WHERE origin_run_id=ne18_attachments.owner_run_id AND attempt_id=ne18_attachments.owner_attempt_id AND publication_state='published'))`).run(attachment.logicalIdentity, attachment.canonicalBytes, attachment.canonicalDigest, attachment.logicalInventoryBytes, attachment.inventoryDigest, attachment.attachmentId, input.runId);
+          (SELECT 1 FROM ne19_attempts WHERE origin_run_id=ne19_attachments.owner_run_id AND attempt_id=ne19_attachments.owner_attempt_id AND publication_state='published'))`).run(attachment.logicalIdentity, attachment.canonicalBytes, attachment.canonicalDigest, attachment.logicalInventoryBytes, attachment.inventoryDigest, attachment.attachmentId, input.runId);
             for (const content of attachment.contents)
-                (0, database_ts_1.recordStatement)(connection, `UPDATE ne18_contents SET byte_length=?,overall_digest=?,chunk_count=?
-        WHERE content_id=? AND attachment_id=? AND NOT EXISTS (SELECT 1 FROM ne18_attachments a JOIN ne18_attempts at
+                (0, database_ts_1.recordStatement)(connection, `UPDATE ne19_contents SET byte_length=?,overall_digest=?,chunk_count=?
+        WHERE content_id=? AND attachment_id=? AND NOT EXISTS (SELECT 1 FROM ne19_attachments a JOIN ne19_attempts at
           ON at.origin_run_id=a.owner_run_id AND at.attempt_id=a.owner_attempt_id
-          WHERE a.attachment_id=ne18_contents.attachment_id AND a.owner_kind='attempt' AND at.publication_state='published')`)
+          WHERE a.attachment_id=ne19_contents.attachment_id AND a.owner_kind='attempt' AND at.publication_state='published')`)
                     .run(content.byteLength, content.digest, content.chunkCount, content.contentId, attachment.attachmentId);
         }
         bumpMutationSequence(connection, input.runId);
@@ -953,7 +970,7 @@ function fenceRunFinalization(connection, input) {
     if (text(before, "status") === "open") {
         (0, transaction_ts_1.withImmediateTransaction)(connection, input.deadlineEpochMs, "fence-finalization", () => {
             assertRunFence(connection, input.runId, input.writerGeneration, "fence-finalization");
-            const changed = (0, database_ts_1.recordStatement)(connection, `UPDATE ne18_runs SET status='sealing',candidate_seal_identity=?,candidate_seal_entry_count=?
+            const changed = (0, database_ts_1.recordStatement)(connection, `UPDATE ne19_runs SET status='sealing',candidate_seal_identity=?,candidate_seal_entry_count=?
         WHERE run_id=? AND status='open' AND writer_generation=? AND mutation_sequence=?`).run(input.expectedLogicalSealIdentity, input.expectedSealEntryCount, input.runId, input.writerGeneration, input.mutationSequence);
             if (Number(changed.changes) !== 1)
                 throw (0, errors_ts_1.sqliteError)("record-command-conflict", "fence-finalization", "Run staging changed before finalization fence");
@@ -988,13 +1005,13 @@ function stageAttachmentReferences(connection, input) {
         assertAttachmentFence(connection, input.runId, input.attachmentId, "stage-references");
         let changed = false;
         for (const reference of input.references) {
-            const stored = (0, database_ts_1.recordStatement)(connection, `SELECT target_owner_kind,target_family,canonical_payload,reference_digest FROM ne18_attachment_references
+            const stored = (0, database_ts_1.recordStatement)(connection, `SELECT target_owner_kind,target_family,canonical_payload,reference_digest FROM ne19_attachment_references
         WHERE attachment_id=? AND ordinal=?`).get(input.attachmentId, reference.ordinal);
             if (stored === undefined) {
-                const count = (0, database_ts_1.recordStatement)(connection, "SELECT count(*) AS count FROM ne18_attachment_references WHERE attachment_id=?").get(input.attachmentId);
+                const count = (0, database_ts_1.recordStatement)(connection, "SELECT count(*) AS count FROM ne19_attachment_references WHERE attachment_id=?").get(input.attachmentId);
                 if (reference.ordinal !== integer(count, "count"))
                     throw (0, errors_ts_1.sqliteError)("record-command-conflict", "stage-references", "reference batch does not extend the committed prefix");
-                (0, database_ts_1.recordStatement)(connection, `INSERT INTO ne18_attachment_references(attachment_id,ordinal,target_owner_kind,target_family,canonical_payload,reference_digest)
+                (0, database_ts_1.recordStatement)(connection, `INSERT INTO ne19_attachment_references(attachment_id,ordinal,target_owner_kind,target_family,canonical_payload,reference_digest)
           VALUES (?,?,?,?,?,?)`).run(input.attachmentId, reference.ordinal, reference.owner, reference.family, reference.canonicalBytes, reference.referenceDigest);
                 changed = true;
             }
@@ -1020,15 +1037,19 @@ function stageCollectionItems(connection, input) {
         assertRunFence(connection, input.runId, input.writerGeneration, "stage-collection-items");
         assertAttachmentFence(connection, input.runId, input.attachmentId, "stage-collection-items");
         let changed = false;
+        // The immediate transaction owns this prefix until commit. Counting for
+        // every appended item rescans a growing collection quadratically.
+        const count = (0, database_ts_1.recordStatement)(connection, "SELECT count(*) AS count FROM ne19_collection_items WHERE attachment_id=?").get(input.attachmentId);
+        let nextOrdinal = integer(count, "count");
         for (const item of input.items) {
-            const stored = (0, database_ts_1.recordStatement)(connection, `SELECT logical_identity,canonical_payload,canonical_digest FROM ne18_collection_items
+            const stored = (0, database_ts_1.recordStatement)(connection, `SELECT logical_identity,canonical_payload,canonical_digest FROM ne19_collection_items
         WHERE attachment_id=? AND ordinal=?`).get(input.attachmentId, item.ordinal);
             if (stored === undefined) {
-                const count = (0, database_ts_1.recordStatement)(connection, "SELECT count(*) AS count FROM ne18_collection_items WHERE attachment_id=?").get(input.attachmentId);
-                if (item.ordinal !== integer(count, "count"))
+                if (item.ordinal !== nextOrdinal)
                     throw (0, errors_ts_1.sqliteError)("record-command-conflict", "stage-collection-items", "collection batch does not extend the committed prefix");
-                (0, database_ts_1.recordStatement)(connection, `INSERT INTO ne18_collection_items(attachment_id,ordinal,logical_identity,canonical_payload,canonical_digest)
+                (0, database_ts_1.recordStatement)(connection, `INSERT INTO ne19_collection_items(attachment_id,ordinal,logical_identity,canonical_payload,canonical_digest)
           VALUES (?,?,?,?,?)`).run(input.attachmentId, item.ordinal, item.logicalIdentity, item.canonicalBytes, item.canonicalDigest);
+                nextOrdinal += 1;
                 changed = true;
             }
             else if (text(stored, "logical_identity") !== item.logicalIdentity || text(stored, "canonical_digest") !== item.canonicalDigest ||
@@ -1095,13 +1116,13 @@ function assertSealedRetryExact(connection, input) {
     });
     for (const attachment of input.attachments) {
         const counts = (0, database_ts_1.recordStatement)(connection, `SELECT
-      (SELECT count(*) FROM ne18_attachment_references WHERE attachment_id=?) reference_count,
-      (SELECT count(*) FROM ne18_collection_items WHERE attachment_id=?) item_count`).get(attachment.attachmentId, attachment.attachmentId);
+      (SELECT count(*) FROM ne19_attachment_references WHERE attachment_id=?) reference_count,
+      (SELECT count(*) FROM ne19_collection_items WHERE attachment_id=?) item_count`).get(attachment.attachmentId, attachment.attachmentId);
         if (integer(counts, "reference_count") !== attachment.references.length || integer(counts, "item_count") !== attachment.collectionItems.length) {
             throw (0, errors_ts_1.sqliteError)("record-command-conflict", "persist-sealed-run", `Attachment ${attachment.attachmentId} retry inventory differs`);
         }
         for (const reference of attachment.references) {
-            const row = (0, database_ts_1.recordStatement)(connection, `SELECT target_owner_kind,target_family,canonical_payload,reference_digest FROM ne18_attachment_references
+            const row = (0, database_ts_1.recordStatement)(connection, `SELECT target_owner_kind,target_family,canonical_payload,reference_digest FROM ne19_attachment_references
         WHERE attachment_id=? AND ordinal=?`).get(attachment.attachmentId, reference.ordinal);
             if (row === undefined || ownerKind(row, "target_owner_kind") !== reference.owner || text(row, "target_family") !== reference.family ||
                 text(row, "reference_digest") !== reference.referenceDigest || !bytesEqual(bytes(row, "canonical_payload"), reference.canonicalBytes)) {
@@ -1109,7 +1130,7 @@ function assertSealedRetryExact(connection, input) {
             }
         }
         for (const item of attachment.collectionItems) {
-            const row = (0, database_ts_1.recordStatement)(connection, `SELECT logical_identity,canonical_payload,canonical_digest FROM ne18_collection_items
+            const row = (0, database_ts_1.recordStatement)(connection, `SELECT logical_identity,canonical_payload,canonical_digest FROM ne19_collection_items
         WHERE attachment_id=? AND ordinal=?`).get(attachment.attachmentId, item.ordinal);
             if (row === undefined || text(row, "logical_identity") !== item.logicalIdentity || text(row, "canonical_digest") !== item.canonicalDigest ||
                 !bytesEqual(bytes(row, "canonical_payload"), item.canonicalBytes)) {
@@ -1117,11 +1138,11 @@ function assertSealedRetryExact(connection, input) {
             }
         }
         for (const content of attachment.contents) {
-            const count = (0, database_ts_1.recordStatement)(connection, "SELECT count(*) AS count FROM ne18_content_chunks WHERE content_id=?").get(content.contentId);
+            const count = (0, database_ts_1.recordStatement)(connection, "SELECT count(*) AS count FROM ne19_content_chunks WHERE content_id=?").get(content.contentId);
             if (integer(count, "count") !== content.chunks.length)
                 throw (0, errors_ts_1.sqliteError)("record-command-conflict", "persist-sealed-run", `Content ${content.contentId} retry chunk count differs`);
             for (const chunk of content.chunks) {
-                const row = (0, database_ts_1.recordStatement)(connection, "SELECT bytes,chunk_digest FROM ne18_content_chunks WHERE content_id=? AND ordinal=?")
+                const row = (0, database_ts_1.recordStatement)(connection, "SELECT bytes,chunk_digest FROM ne19_content_chunks WHERE content_id=? AND ordinal=?")
                     .get(content.contentId, chunk.ordinal);
                 if (row === undefined || text(row, "chunk_digest") !== chunk.chunkDigest || !bytesEqual(bytes(row, "bytes"), chunk.bytes)) {
                     throw (0, errors_ts_1.sqliteError)("record-command-conflict", "persist-sealed-run", `Content chunk ${content.contentId}/${chunk.ordinal} retry differs`);
@@ -1146,7 +1167,7 @@ function persistSealedRun(connection, input) {
         verifyStoredSeal(connection, input.runId, expectedEntries, expectedIdentity);
         return readSealedRunSummary(connection, input.runId);
     }
-    beginRun(connection, input);
+    beginRun(connection, { ...input, experimentId: validatedRunExperimentId(input.runCoreBytes, input.runId) });
     for (const attempt of input.attempts)
         admitAttempt(connection, {
             runId: input.runId,
@@ -1264,7 +1285,7 @@ function publishRunSeal(connection, input) {
         throw (0, errors_ts_1.sqliteError)("record-seal-incomplete", "seal-run", "Seal candidate inventory is not completely staged");
     }
     (0, transaction_ts_1.withImmediateTransaction)(connection, input.deadlineEpochMs, "seal-run", () => {
-        const changed = (0, database_ts_1.recordStatement)(connection, `UPDATE ne18_runs SET status='sealed',logical_seal_identity=?
+        const changed = (0, database_ts_1.recordStatement)(connection, `UPDATE ne19_runs SET status='sealed',logical_seal_identity=?
       WHERE run_id=? AND status='sealing' AND writer_generation=? AND candidate_seal_identity=?
         AND candidate_seal_staged_count=candidate_seal_entry_count`).run(input.expectedLogicalSealIdentity, input.runId, input.writerGeneration, input.expectedLogicalSealIdentity);
         if (Number(changed.changes) !== 1)
@@ -1283,7 +1304,7 @@ function verifyStoredSealStreaming(connection, runId, identity, expectedCount) {
         if (actual.count !== expectedCount || actual.identity !== identity) {
             throw (0, errors_ts_1.sqliteError)("record-seal-incomplete", "verify-seal", `Run ${runId} exact Seal identity or count differs from its closure`);
         }
-        const statement = (0, database_ts_1.recordStatement)(connection, `SELECT entry_kind,logical_identity,digest FROM ne18_run_seal_entries
+        const statement = (0, database_ts_1.recordStatement)(connection, `SELECT entry_kind,logical_identity,digest FROM ne19_run_seal_entries
       WHERE run_id=? AND ordinal=?`);
         let ordinal = 0;
         for (const row of (0, database_ts_1.recordStatement)(connection, `SELECT ordinal,entry_kind,logical_identity,digest
@@ -1303,7 +1324,7 @@ function verifyStoredSealStreaming(connection, runId, identity, expectedCount) {
             }
             ordinal += 1;
         }
-        const storedCount = (0, database_ts_1.recordStatement)(connection, "SELECT count(*) AS count FROM ne18_run_seal_entries WHERE run_id=?").get(runId);
+        const storedCount = (0, database_ts_1.recordStatement)(connection, "SELECT count(*) AS count FROM ne19_run_seal_entries WHERE run_id=?").get(runId);
         if (ordinal !== expectedCount || integer(storedCount, "count") !== ordinal) {
             throw (0, errors_ts_1.sqliteError)("record-seal-incomplete", "verify-seal", `Run ${runId} exact Seal does not match its closure`);
         }
@@ -1327,10 +1348,10 @@ function verifyAllSealedRuns(connection, requireSealedOnly = false, deadlineEpoc
     };
     checkDeadline();
     const admission = (0, database_ts_1.recordStatement)(connection, `SELECT
-    (SELECT count(*) FROM ne18_runs) run_count,
-    (SELECT count(*) FROM ne18_runs)+(SELECT count(*) FROM ne18_slots)+(SELECT count(*) FROM ne18_attempts)+(SELECT count(*) FROM ne18_members)+
-      (SELECT count(*) FROM ne18_attachments)+(SELECT count(*) FROM ne18_attachment_references)+(SELECT count(*) FROM ne18_collection_items)+
-      (SELECT count(*) FROM ne18_contents)+(SELECT count(*) FROM ne18_content_chunks)+(SELECT count(*) FROM ne18_run_seal_entries) row_count`).get();
+    (SELECT count(*) FROM ne19_runs) run_count,
+    (SELECT count(*) FROM ne19_runs)+(SELECT count(*) FROM ne19_slots)+(SELECT count(*) FROM ne19_attempts)+(SELECT count(*) FROM ne19_members)+
+      (SELECT count(*) FROM ne19_attachments)+(SELECT count(*) FROM ne19_attachment_references)+(SELECT count(*) FROM ne19_collection_items)+
+      (SELECT count(*) FROM ne19_contents)+(SELECT count(*) FROM ne19_content_chunks)+(SELECT count(*) FROM ne19_run_seal_entries) row_count`).get();
     if (integer(admission, "run_count") > types_ts_1.RECORD_SQLITE_MAX_VALIDATION_RUNS || integer(admission, "row_count") > types_ts_1.RECORD_SQLITE_MAX_VALIDATION_ROWS) {
         throw (0, errors_ts_1.sqliteError)("record-resource-limit-exceeded", "verify-database", "Record validation inventory exceeds its hostile-input ceiling");
     }
@@ -1342,7 +1363,7 @@ function verifyAllSealedRuns(connection, requireSealedOnly = false, deadlineEpoc
     const foreignKeys = (0, database_ts_1.recordStatement)(connection, "PRAGMA foreign_key_check").all();
     if (foreignKeys.length !== 0)
         throw (0, errors_ts_1.sqliteError)("record-database-invalid", "verify-database", "foreign key check failed");
-    const runRows = (0, database_ts_1.recordStatement)(connection, "SELECT run_id,status,logical_seal_identity FROM ne18_runs ORDER BY run_id")
+    const runRows = (0, database_ts_1.recordStatement)(connection, "SELECT run_id,status,logical_seal_identity FROM ne19_runs ORDER BY run_id")
         .iterate();
     let sealed = 0;
     for (const row of runRows) {
@@ -1365,7 +1386,7 @@ function verifyAllSealedRuns(connection, requireSealedOnly = false, deadlineEpoc
     return sealed;
 }
 function verifyRunPayloadClosures(connection, runId, verifyPayloadBytes = true) {
-    const attempts = (0, database_ts_1.recordStatement)(connection, "SELECT attempt_id,attempt_locator FROM ne18_attempts WHERE origin_run_id=?")
+    const attempts = (0, database_ts_1.recordStatement)(connection, "SELECT attempt_id,attempt_locator FROM ne19_attempts WHERE origin_run_id=?")
         .iterate(runId);
     for (const attempt of attempts) {
         const attemptId = text(attempt, "attempt_id");
@@ -1378,7 +1399,7 @@ function verifyRunPayloadClosures(connection, runId, verifyPayloadBytes = true)
         }
     }
     const attachments = (0, database_ts_1.recordStatement)(connection, `SELECT attachment_id,owner_kind,owner_run_id,owner_attempt_id,family,family_revision,
-    logical_identity,canonical_digest,logical_inventory,inventory_digest FROM ne18_attachments WHERE owner_run_id=?`)
+    logical_identity,canonical_digest,logical_inventory,inventory_digest FROM ne19_attachments WHERE owner_run_id=?`)
         .iterate(runId);
     for (const attachment of attachments) {
         const attachmentId = text(attachment, "attachment_id");
@@ -1397,8 +1418,8 @@ function verifyRunPayloadClosures(connection, runId, verifyPayloadBytes = true)
             throw (0, errors_ts_1.sqliteError)("record-seal-incomplete", "verify-seal", `attachment ${attachmentId} logical identity is invalid`);
         }
         for (const [label, counts] of [
-            ["reference", (0, database_ts_1.recordStatement)(connection, "SELECT count(*) AS count,min(ordinal) AS minimum,max(ordinal) AS maximum FROM ne18_attachment_references WHERE attachment_id=?").get(attachmentId)],
-            ["collection item", (0, database_ts_1.recordStatement)(connection, "SELECT count(*) AS count,min(ordinal) AS minimum,max(ordinal) AS maximum FROM ne18_collection_items WHERE attachment_id=?").get(attachmentId)],
+            ["reference", (0, database_ts_1.recordStatement)(connection, "SELECT count(*) AS count,min(ordinal) AS minimum,max(ordinal) AS maximum FROM ne19_attachment_references WHERE attachment_id=?").get(attachmentId)],
+            ["collection item", (0, database_ts_1.recordStatement)(connection, "SELECT count(*) AS count,min(ordinal) AS minimum,max(ordinal) AS maximum FROM ne19_collection_items WHERE attachment_id=?").get(attachmentId)],
         ]) {
             const decoded = counts;
             const count = integer(decoded, "count");
@@ -1407,8 +1428,8 @@ function verifyRunPayloadClosures(connection, runId, verifyPayloadBytes = true)
             }
         }
     }
-    const items = (0, database_ts_1.recordStatement)(connection, `SELECT i.attachment_id,i.ordinal,i.logical_identity,i.canonical_digest FROM ne18_collection_items i
-    JOIN ne18_attachments a ON a.attachment_id=i.attachment_id WHERE a.owner_run_id=?`).iterate(runId);
+    const items = (0, database_ts_1.recordStatement)(connection, `SELECT i.attachment_id,i.ordinal,i.logical_identity,i.canonical_digest FROM ne19_collection_items i
+    JOIN ne19_attachments a ON a.attachment_id=i.attachment_id WHERE a.owner_run_id=?`).iterate(runId);
     for (const item of items) {
         const expected = (0, seal_ts_1.collectionItemLogicalIdentity)(integer(item, "ordinal"), text(item, "canonical_digest"));
         if (text(item, "logical_identity") !== expected) {
@@ -1416,16 +1437,16 @@ function verifyRunPayloadClosures(connection, runId, verifyPayloadBytes = true)
         }
     }
     const coverage = (0, database_ts_1.recordStatement)(connection, `SELECT
-    (SELECT count(*) FROM ne18_slots WHERE run_id=?) slot_count,
-    (SELECT count(*) FROM ne18_members WHERE target_run_id=?) member_count,
-    (SELECT count(*) FROM ne18_slots s LEFT JOIN ne18_members m ON m.target_run_id=s.run_id AND m.slot_id=s.slot_id
+    (SELECT count(*) FROM ne19_slots WHERE run_id=?) slot_count,
+    (SELECT count(*) FROM ne19_members WHERE target_run_id=?) member_count,
+    (SELECT count(*) FROM ne19_slots s LEFT JOIN ne19_members m ON m.target_run_id=s.run_id AND m.slot_id=s.slot_id
       WHERE s.run_id=? AND m.slot_id IS NULL) missing_count`).get(runId, runId, runId);
     if (integer(coverage, "slot_count") !== integer(coverage, "member_count") || integer(coverage, "missing_count") !== 0) {
         throw (0, errors_ts_1.sqliteError)("record-seal-incomplete", "verify-seal", `Run ${runId} does not have exactly one Member per Slot`);
     }
     const references = (0, database_ts_1.recordStatement)(connection, `SELECT r.attachment_id,r.ordinal,r.target_owner_kind,r.target_family,
-    a.owner_kind source_owner_kind,a.owner_run_id,a.owner_attempt_id FROM ne18_attachment_references r
-    JOIN ne18_attachments a ON a.attachment_id=r.attachment_id WHERE a.owner_run_id=?`).iterate(runId);
+    a.owner_kind source_owner_kind,a.owner_run_id,a.owner_attempt_id FROM ne19_attachment_references r
+    JOIN ne19_attachments a ON a.attachment_id=r.attachment_id WHERE a.owner_run_id=?`).iterate(runId);
     for (const reference of references) {
         const targetOwner = text(reference, "target_owner_kind");
         const sourceOwner = text(reference, "source_owner_kind");
@@ -1433,16 +1454,16 @@ function verifyRunPayloadClosures(connection, runId, verifyPayloadBytes = true)
             throw (0, errors_ts_1.sqliteError)("record-seal-incomplete", "verify-seal", `run-owned attachment ${text(reference, "attachment_id")} cannot resolve an attempt reference`);
         }
         const target = targetOwner === "run"
-            ? (0, database_ts_1.recordStatement)(connection, `SELECT count(*) AS count FROM ne18_attachments WHERE owner_kind='run' AND owner_run_id=? AND family=?`)
+            ? (0, database_ts_1.recordStatement)(connection, `SELECT count(*) AS count FROM ne19_attachments WHERE owner_kind='run' AND owner_run_id=? AND family=?`)
                 .get(text(reference, "owner_run_id"), text(reference, "target_family"))
-            : (0, database_ts_1.recordStatement)(connection, `SELECT count(*) AS count FROM ne18_attachments WHERE owner_kind='attempt' AND owner_run_id=? AND owner_attempt_id=? AND family=?`)
+            : (0, database_ts_1.recordStatement)(connection, `SELECT count(*) AS count FROM ne19_attachments WHERE owner_kind='attempt' AND owner_run_id=? AND owner_attempt_id=? AND family=?`)
                 .get(text(reference, "owner_run_id"), text(reference, "owner_attempt_id"), text(reference, "target_family"));
         if (integer(target, "count") !== 1) {
             throw (0, errors_ts_1.sqliteError)("record-seal-incomplete", "verify-seal", `reference ${text(reference, "attachment_id")}/${integer(reference, "ordinal")} target family is missing`);
         }
     }
-    const contents = (0, database_ts_1.recordStatement)(connection, `SELECT c.content_id,c.attachment_id,c.logical_handle,c.byte_length,c.overall_digest,c.chunk_count FROM ne18_contents c
-    JOIN ne18_attachments a ON a.attachment_id=c.attachment_id WHERE a.owner_run_id=?`).iterate(runId);
+    const contents = (0, database_ts_1.recordStatement)(connection, `SELECT c.content_id,c.attachment_id,c.logical_handle,c.byte_length,c.overall_digest,c.chunk_count FROM ne19_contents c
+    JOIN ne19_attachments a ON a.attachment_id=c.attachment_id WHERE a.owner_run_id=?`).iterate(runId);
     for (const content of contents) {
         const contentId = text(content, "content_id");
         const expectedContentId = (0, seal_ts_1.contentId)(text(content, "attachment_id"), text(content, "logical_handle"));
@@ -1452,7 +1473,7 @@ function verifyRunPayloadClosures(connection, runId, verifyPayloadBytes = true)
             const hash = (0, node_crypto_1.createHash)("sha256");
             let byteLength = 0;
             let ordinal = 0;
-            const chunks = (0, database_ts_1.recordStatement)(connection, "SELECT ordinal,bytes,chunk_digest FROM ne18_content_chunks WHERE content_id=? ORDER BY ordinal")
+            const chunks = (0, database_ts_1.recordStatement)(connection, "SELECT ordinal,bytes,chunk_digest FROM ne19_content_chunks WHERE content_id=? ORDER BY ordinal")
                 .iterate(contentId);
             for (const chunk of chunks) {
                 if (integer(chunk, "ordinal") !== ordinal)
@@ -1470,13 +1491,13 @@ function verifyRunPayloadClosures(connection, runId, verifyPayloadBytes = true)
         }
         else {
             const aggregate = (0, database_ts_1.recordStatement)(connection, `SELECT count(*) AS count,min(ordinal) AS minimum,max(ordinal) AS maximum,
-        coalesce(sum(length(bytes)),0) AS byte_length FROM ne18_content_chunks WHERE content_id=?`).get(contentId);
+        coalesce(sum(length(bytes)),0) AS byte_length FROM ne19_content_chunks WHERE content_id=?`).get(contentId);
             const chunkCount = integer(content, "chunk_count");
             if (integer(aggregate, "count") !== chunkCount || integer(aggregate, "byte_length") !== integer(content, "byte_length") ||
                 (chunkCount > 0 && (optionalInteger(aggregate, "minimum") !== 0 || optionalInteger(aggregate, "maximum") !== chunkCount - 1))) {
                 throw (0, errors_ts_1.sqliteError)("record-seal-incomplete", "verify-seal", `content ${contentId} durable chunk closure is invalid`);
             }
-            for (const chunk of (0, database_ts_1.recordStatement)(connection, "SELECT chunk_digest FROM ne18_content_chunks WHERE content_id=?").iterate(contentId)) {
+            for (const chunk of (0, database_ts_1.recordStatement)(connection, "SELECT chunk_digest FROM ne19_content_chunks WHERE content_id=?").iterate(contentId)) {
                 requireDigest(text(chunk, "chunk_digest"), `content ${contentId} chunk digest`);
             }
         }
@@ -1486,30 +1507,30 @@ function verifyRunPayloadClosures(connection, runId, verifyPayloadBytes = true)
 function readSealedRunSummary(connection, runId) {
     const row = (0, database_ts_1.recordStatement)(connection, `SELECT r.run_id,r.writer_generation,r.started_at,
     coalesce(r.logical_seal_identity,'published:' || (SELECT max(p.published_revision)
-      FROM ne18_attempt_publications p WHERE p.origin_run_id=r.run_id)) logical_seal_identity,
-    (SELECT count(*) FROM ne18_slots WHERE run_id=r.run_id) slot_count,
-    CASE WHEN EXISTS (SELECT 1 FROM ne18_run_resources WHERE run_id=r.run_id) THEN
-      (SELECT count(*) FROM ne18_run_slot_bindings WHERE target_run_id=r.run_id)+
-      (SELECT count(*) FROM ne18_run_slot_absences WHERE run_id=r.run_id)
-      ELSE (SELECT count(*) FROM ne18_members WHERE target_run_id=r.run_id) END member_count,
-    (SELECT count(*) FROM ne18_attempts a WHERE a.origin_run_id=r.run_id AND
-      (NOT EXISTS (SELECT 1 FROM ne18_run_resources WHERE run_id=r.run_id) OR EXISTS
-       (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=a.origin_run_id AND p.attempt_id=a.attempt_id))) attempt_count,
-    (SELECT count(*) FROM ne18_attachments a WHERE a.owner_run_id=r.run_id AND a.canonical_payload IS NOT NULL AND
-      (a.owner_kind='run' OR NOT EXISTS (SELECT 1 FROM ne18_run_resources WHERE run_id=r.run_id) OR EXISTS
-       (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=a.owner_run_id AND p.attempt_id=a.owner_attempt_id))) attachment_count,
-    (SELECT count(*) FROM ne18_contents c JOIN ne18_attachments a ON a.attachment_id=c.attachment_id
+      FROM ne19_attempt_publications p WHERE p.origin_run_id=r.run_id)) logical_seal_identity,
+    (SELECT count(*) FROM ne19_slots WHERE run_id=r.run_id) slot_count,
+    CASE WHEN EXISTS (SELECT 1 FROM ne19_run_resources WHERE run_id=r.run_id) THEN
+      (SELECT count(*) FROM ne19_run_slot_bindings WHERE target_run_id=r.run_id)+
+      (SELECT count(*) FROM ne19_run_slot_absences WHERE run_id=r.run_id)
+      ELSE (SELECT count(*) FROM ne19_members WHERE target_run_id=r.run_id) END member_count,
+    (SELECT count(*) FROM ne19_attempts a WHERE a.origin_run_id=r.run_id AND
+      (NOT EXISTS (SELECT 1 FROM ne19_run_resources WHERE run_id=r.run_id) OR EXISTS
+       (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=a.origin_run_id AND p.attempt_id=a.attempt_id))) attempt_count,
+    (SELECT count(*) FROM ne19_attachments a WHERE a.owner_run_id=r.run_id AND a.canonical_payload IS NOT NULL AND
+      (a.owner_kind='run' OR NOT EXISTS (SELECT 1 FROM ne19_run_resources WHERE run_id=r.run_id) OR EXISTS
+       (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=a.owner_run_id AND p.attempt_id=a.owner_attempt_id))) attachment_count,
+    (SELECT count(*) FROM ne19_contents c JOIN ne19_attachments a ON a.attachment_id=c.attachment_id
       WHERE a.owner_run_id=r.run_id AND a.canonical_payload IS NOT NULL AND
-      (a.owner_kind='run' OR NOT EXISTS (SELECT 1 FROM ne18_run_resources WHERE run_id=r.run_id) OR EXISTS
-       (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=a.owner_run_id AND p.attempt_id=a.owner_attempt_id))) content_count,
-    (SELECT coalesce(sum(c.byte_length),0) FROM ne18_contents c JOIN ne18_attachments a ON a.attachment_id=c.attachment_id
+      (a.owner_kind='run' OR NOT EXISTS (SELECT 1 FROM ne19_run_resources WHERE run_id=r.run_id) OR EXISTS
+       (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=a.owner_run_id AND p.attempt_id=a.owner_attempt_id))) content_count,
+    (SELECT coalesce(sum(c.byte_length),0) FROM ne19_contents c JOIN ne19_attachments a ON a.attachment_id=c.attachment_id
       WHERE a.owner_run_id=r.run_id AND a.canonical_payload IS NOT NULL AND
-      (a.owner_kind='run' OR NOT EXISTS (SELECT 1 FROM ne18_run_resources WHERE run_id=r.run_id) OR EXISTS
-       (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=a.owner_run_id AND p.attempt_id=a.owner_attempt_id))) content_bytes,
-    (SELECT count(*) FROM ne18_run_seal_entries WHERE run_id=r.run_id) seal_count
-    FROM ne18_runs r WHERE r.run_id=? AND NOT EXISTS
-      (SELECT 1 FROM ne18_run_deletion_tombstones d WHERE d.run_id=r.run_id)
-      AND (r.status='sealed' OR EXISTS (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=r.run_id))`).get(runId);
+      (a.owner_kind='run' OR NOT EXISTS (SELECT 1 FROM ne19_run_resources WHERE run_id=r.run_id) OR EXISTS
+       (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=a.owner_run_id AND p.attempt_id=a.owner_attempt_id))) content_bytes,
+    (SELECT count(*) FROM ne19_run_seal_entries WHERE run_id=r.run_id) seal_count
+    FROM ne19_runs r WHERE r.run_id=? AND NOT EXISTS
+      (SELECT 1 FROM ne19_run_deletion_tombstones d WHERE d.run_id=r.run_id)
+      AND (r.status='sealed' OR EXISTS (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=r.run_id))`).get(runId);
     if (row === undefined)
         return undefined;
     return Object.freeze({ runId: text(row, "run_id"), writerGeneration: text(row, "writer_generation"),
@@ -1520,19 +1541,65 @@ function readSealedRunSummary(connection, runId) {
 }
 /** Pinned publication identity, plus a metadata-only count; no Seal hashing. */
 function readSealedRunCutoff(connection, identity) {
-    const row = (0, database_ts_1.recordStatement)(connection, `SELECT count(*) count FROM ne18_runs r
-    WHERE NOT EXISTS (SELECT 1 FROM ne18_run_deletion_tombstones d WHERE d.run_id=r.run_id)
-      AND (status='sealed' OR EXISTS (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=r.run_id))`).get();
+    const row = (0, database_ts_1.recordStatement)(connection, `SELECT count(*) count FROM ne19_runs r
+    WHERE NOT EXISTS (SELECT 1 FROM ne19_run_deletion_tombstones d WHERE d.run_id=r.run_id)
+      AND (status='sealed' OR EXISTS (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=r.run_id))`).get();
     return Object.freeze({ identity, runCount: integer(row, "count") });
 }
 /** Filter lightweight Run metadata before loading any selected Core or payload. */
+function findSourceBarrierCandidate(connection, request, cutoffRevision) {
+    requireIdentity(request.experimentId, "experimentId");
+    requireIdentity(request.evalId, "evalId");
+    if (!Number.isSafeInteger(request.attemptOrdinal) || request.attemptOrdinal < 0) {
+        throw (0, errors_ts_1.sqliteError)("record-content-invalid", "find-source-barrier", "Attempt ordinal must be non-negative");
+    }
+    // Resource identity and expected membership, including empty active Runs,
+    // select the barrier before any Core or policy evidence is loaded.
+    const current = rows(connection, `SELECT r.run_id,r.created_revision
+    FROM ne19_run_resources r
+    WHERE r.experiment_id=? AND r.created_revision<=? AND r.run_id<>?
+      AND NOT EXISTS (SELECT 1 FROM ne19_run_deletion_tombstones d WHERE d.run_id=r.run_id)
+      AND EXISTS (SELECT 1 FROM ne19_run_expected_slots s
+        WHERE s.eval_id=? AND s.attempt_ordinal=? AND s.run_id=r.run_id)
+    ORDER BY r.created_revision DESC,r.run_id COLLATE BINARY DESC LIMIT 1`, request.experimentId, cutoffRevision, request.excludeRunId ?? "", request.evalId, request.attemptOrdinal)[0];
+    if (current !== undefined)
+        return Object.freeze({ runId: text(current, "run_id"), createdRevision: integer(current, "created_revision") });
+    // Legacy Runs deliberately have no fabricated resource/revision. Inspect
+    // only their indexed Experiment's expected rows, never unrelated Core.
+    // Malformed expected rows remain candidates so validation cannot fall back.
+    const legacy = rows(connection, `SELECT r.run_id FROM ne19_runs r
+    WHERE r.experiment_id=? AND r.status='sealed' AND r.run_id<>?
+      AND NOT EXISTS (SELECT 1 FROM ne19_run_resources rr WHERE rr.run_id=r.run_id)
+      AND NOT EXISTS (SELECT 1 FROM ne19_run_deletion_tombstones d WHERE d.run_id=r.run_id)
+      AND EXISTS (SELECT 1 FROM ne19_slots s WHERE s.run_id=r.run_id AND
+        CASE WHEN json_valid(CAST(s.core_payload AS TEXT)) THEN
+          CASE WHEN json_type(CAST(s.core_payload AS TEXT),'$.evalId') IS NOT 'text' OR
+            json_type(CAST(s.core_payload AS TEXT),'$.attemptOrdinal') IS NOT 'integer' THEN 1
+          ELSE (json_extract(CAST(s.core_payload AS TEXT),'$.evalId')=? AND
+           json_extract(CAST(s.core_payload AS TEXT),'$.attemptOrdinal')=?) END
+        ELSE 1 END)
+    ORDER BY r.run_id COLLATE BINARY DESC LIMIT 1`, request.experimentId, request.excludeRunId ?? "", request.evalId, request.attemptOrdinal)[0];
+    return legacy === undefined ? undefined : Object.freeze({ runId: text(legacy, "run_id"), createdRevision: 0 });
+}
+/** Locate adoption proofs for one exact Attempt without scanning Run Core. */
+function findAcceptedAttemptRunIds(connection, request, cutoffRevision) {
+    const selected = rows(connection, `SELECT b.target_run_id FROM ne19_run_slot_bindings b
+    JOIN ne19_run_resources r ON r.run_id=b.target_run_id
+    WHERE b.attempt_id=? AND b.origin_run_id=? AND b.action='accepted'
+      AND r.experiment_id=? AND b.binding_revision<=? AND b.binding_revision<=?
+      AND NOT EXISTS (SELECT 1 FROM ne19_run_deletion_tombstones d WHERE d.run_id=b.target_run_id)
+    ORDER BY b.target_run_id LIMIT ?`, request.attemptId, request.originRunId, request.experimentId, request.bindingRevision, cutoffRevision, types_ts_1.RECORD_SQLITE_MAX_VALIDATION_RUNS + 1);
+    if (selected.length > types_ts_1.RECORD_SQLITE_MAX_VALIDATION_RUNS) {
+        throw (0, errors_ts_1.sqliteError)("record-resource-limit-exceeded", "find-accepted-attempt-runs", "Attempt exceeds its adoption proof ceiling");
+    }
+    return Object.freeze(selected.map((row) => text(row, "target_run_id")));
+}
 function findExperimentRunIds(connection, experimentId) {
     requireIdentity(experimentId, "experimentId");
-    const selected = rows(connection, `SELECT r.run_id FROM ne18_runs r
-    LEFT JOIN ne18_run_resources resource ON resource.run_id=r.run_id
-    WHERE coalesce(resource.experiment_id,json_extract(r.core_payload,'$.experimentId'))=?
-      AND NOT EXISTS (SELECT 1 FROM ne18_run_deletion_tombstones d WHERE d.run_id=r.run_id)
-      AND (r.status='sealed' OR EXISTS (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=r.run_id))
+    const selected = rows(connection, `SELECT r.run_id FROM ne19_runs r
+    WHERE r.experiment_id=?
+      AND NOT EXISTS (SELECT 1 FROM ne19_run_deletion_tombstones d WHERE d.run_id=r.run_id)
+      AND (r.status='sealed' OR EXISTS (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=r.run_id))
     ORDER BY r.run_id LIMIT ?`, experimentId, types_ts_1.RECORD_SQLITE_MAX_VALIDATION_RUNS + 1);
     if (selected.length > types_ts_1.RECORD_SQLITE_MAX_VALIDATION_RUNS) {
         throw (0, errors_ts_1.sqliteError)("record-resource-limit-exceeded", "find-experiment-runs", "Experiment exceeds its Run ceiling");
@@ -1543,10 +1610,10 @@ function listSealedRunSummaries(connection, afterRunId = "", pageSize = 100) {
     if (!Number.isSafeInteger(pageSize) || pageSize < 1 || pageSize > 256) {
         throw (0, errors_ts_1.sqliteError)("record-resource-limit-exceeded", "list-sealed-runs", "page size must be between 1 and 256");
     }
-    const runIds = rows(connection, `SELECT run_id FROM ne18_runs WHERE run_id>?
-    AND NOT EXISTS (SELECT 1 FROM ne18_run_deletion_tombstones d WHERE d.run_id=ne18_runs.run_id)
+    const runIds = rows(connection, `SELECT run_id FROM ne19_runs WHERE run_id>?
+    AND NOT EXISTS (SELECT 1 FROM ne19_run_deletion_tombstones d WHERE d.run_id=ne19_runs.run_id)
     AND (status='sealed' OR EXISTS
-    (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=ne18_runs.run_id)) ORDER BY run_id LIMIT ?`, afterRunId, pageSize);
+    (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=ne19_runs.run_id)) ORDER BY run_id LIMIT ?`, afterRunId, pageSize);
     return Object.freeze(runIds.map((row) => {
         const summary = readSealedRunSummary(connection, text(row, "run_id"));
         if (summary === undefined)
@@ -1568,11 +1635,11 @@ function readSealedRunSummaryPage(connection, afterRunId = "", pageSize = 100, e
         cutoffHash.update("[");
         let runCount = 0;
         const inventory = (0, database_ts_1.recordStatement)(connection, `SELECT run_id,
-      coalesce(logical_seal_identity,'published:' || (SELECT max(p.published_revision) FROM ne18_attempt_publications p
-        WHERE p.origin_run_id=ne18_runs.run_id)) logical_seal_identity
-      FROM ne18_runs WHERE NOT EXISTS (SELECT 1 FROM ne18_run_deletion_tombstones d WHERE d.run_id=ne18_runs.run_id)
+      coalesce(logical_seal_identity,'published:' || (SELECT max(p.published_revision) FROM ne19_attempt_publications p
+        WHERE p.origin_run_id=ne19_runs.run_id)) logical_seal_identity
+      FROM ne19_runs WHERE NOT EXISTS (SELECT 1 FROM ne19_run_deletion_tombstones d WHERE d.run_id=ne19_runs.run_id)
         AND (status='sealed' OR EXISTS
-          (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=ne18_runs.run_id))
+          (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=ne19_runs.run_id))
       ORDER BY run_id`).iterate();
         for (const row of inventory) {
             if (runCount >= types_ts_1.RECORD_SQLITE_MAX_VALIDATION_RUNS) {
@@ -1594,10 +1661,10 @@ function readSealedRunSummaryPage(connection, afterRunId = "", pageSize = 100, e
     if (expectedCutoffIdentity !== undefined && expectedCutoffIdentity !== identity) {
         throw (0, errors_ts_1.sqliteError)("record-command-conflict", "page-sealed-runs", "sealed cutoff changed; restart pagination");
     }
-    const pageRows = rows(connection, `SELECT run_id FROM ne18_runs WHERE run_id>?
-    AND NOT EXISTS (SELECT 1 FROM ne18_run_deletion_tombstones d WHERE d.run_id=ne18_runs.run_id)
+    const pageRows = rows(connection, `SELECT run_id FROM ne19_runs WHERE run_id>?
+    AND NOT EXISTS (SELECT 1 FROM ne19_run_deletion_tombstones d WHERE d.run_id=ne19_runs.run_id)
     AND (status='sealed' OR EXISTS
-    (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=ne18_runs.run_id)) ORDER BY run_id LIMIT ?`, afterRunId, pageSize + 1);
+    (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=ne19_runs.run_id)) ORDER BY run_id LIMIT ?`, afterRunId, pageSize + 1);
     const selected = pageRows.slice(0, pageSize);
     const summaries = selected.map((row) => {
         const summary = readSealedRunSummary(connection, text(row, "run_id"));
@@ -1614,15 +1681,15 @@ function readSealedRunSummaryPage(connection, afterRunId = "", pageSize = 100, e
     });
 }
 /** Indexed, bounded locator projection. No Core or attachment payload is selected. */
-function findAttemptLocatorCandidates(connection, locator, maximumCandidateRuns) {
+function findAttemptLocatorCandidates(connection, locator, maximumCandidateRuns, includeTargets = true) {
     if (!(0, attempt_locator_ts_1.parseAttemptLocator)(locator).valid) {
         throw (0, errors_ts_1.sqliteError)("record-content-invalid", "find-attempt-locator", "Attempt locator is malformed");
     }
     if (!Number.isSafeInteger(maximumCandidateRuns) || maximumCandidateRuns < 1 || maximumCandidateRuns > 256) {
         throw (0, errors_ts_1.sqliteError)("record-resource-limit-exceeded", "find-attempt-locator", "candidate Run limit must be between 1 and 256");
     }
-    const matching = rows(connection, `SELECT a.origin_run_id,a.attempt_id FROM ne18_attempts a
-    JOIN ne18_runs origin ON origin.run_id=a.origin_run_id
+    const matching = rows(connection, `SELECT a.origin_run_id,a.attempt_id FROM ne19_attempts a
+    JOIN ne19_runs origin ON origin.run_id=a.origin_run_id
     WHERE a.attempt_locator=? ORDER BY a.origin_run_id,a.attempt_id LIMIT ?`, locator, maximumCandidateRuns + 1);
     const identities = new Set();
     const candidates = [];
@@ -1635,15 +1702,17 @@ function findAttemptLocatorCandidates(connection, locator, maximumCandidateRuns)
     for (const row of matching) {
         const originRunId = text(row, "origin_run_id");
         const attemptId = text(row, "attempt_id");
-        const published = (0, database_ts_1.recordStatement)(connection, `SELECT 1 FROM ne18_runs r WHERE r.run_id=? AND
-      ((r.status='sealed' AND NOT EXISTS (SELECT 1 FROM ne18_run_resources rr WHERE rr.run_id=r.run_id)) OR
-       EXISTS (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=r.run_id AND p.attempt_id=?))`).get(originRunId, attemptId);
+        const published = (0, database_ts_1.recordStatement)(connection, `SELECT 1 FROM ne19_runs r WHERE r.run_id=? AND
+      ((r.status='sealed' AND NOT EXISTS (SELECT 1 FROM ne19_run_resources rr WHERE rr.run_id=r.run_id)) OR
+       EXISTS (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=r.run_id AND p.attempt_id=?))`).get(originRunId, attemptId);
         if (published === undefined)
             continue;
         identities.add((0, seal_ts_1.hashCanonicalTuple)("niceeval.record.attempt-candidate/v1", [originRunId, attemptId]));
         add({ locator, originRunId, attemptId, relation: "origin", runId: originRunId });
-        const targets = rows(connection, `SELECT DISTINCT m.target_run_id FROM ne18_members m
-      JOIN ne18_runs target ON target.run_id=m.target_run_id AND target.status='sealed'
+        if (!includeTargets)
+            continue;
+        const targets = rows(connection, `SELECT DISTINCT m.target_run_id FROM ne19_members m
+      JOIN ne19_runs target ON target.run_id=m.target_run_id AND target.status='sealed'
       WHERE m.origin_run_id=? AND m.attempt_id=? ORDER BY m.target_run_id LIMIT ?`, originRunId, attemptId, maximumCandidateRuns - candidates.length + 1);
         for (const target of targets)
             add({ locator, originRunId, attemptId, relation: "target", runId: text(target, "target_run_id") });
@@ -1660,12 +1729,12 @@ function readCollectionItemPage(connection, attachmentId, afterOrdinal, pageSize
     let pageBytes = 0;
     let hasMore = false;
     const pageRows = (0, database_ts_1.recordStatement)(connection, `SELECT i.ordinal,i.logical_identity,i.canonical_payload,i.canonical_digest,
-      EXISTS(SELECT 1 FROM ne18_collection_items more WHERE more.attachment_id=i.attachment_id AND more.ordinal>i.ordinal) AS has_more
-      FROM ne18_collection_items i
-      JOIN ne18_attachments a ON a.attachment_id=i.attachment_id JOIN ne18_runs r ON r.run_id=a.owner_run_id
+      EXISTS(SELECT 1 FROM ne19_collection_items more WHERE more.attachment_id=i.attachment_id AND more.ordinal>i.ordinal) AS has_more
+      FROM ne19_collection_items i
+      JOIN ne19_attachments a ON a.attachment_id=i.attachment_id JOIN ne19_runs r ON r.run_id=a.owner_run_id
       WHERE i.attachment_id=? AND i.ordinal>? AND
-        ((r.status='sealed' AND (NOT EXISTS (SELECT 1 FROM ne18_run_resources rr WHERE rr.run_id=r.run_id) OR a.owner_kind='run')) OR
-         (a.owner_kind='attempt' AND EXISTS (SELECT 1 FROM ne18_attempt_publications p
+        ((r.status='sealed' AND (NOT EXISTS (SELECT 1 FROM ne19_run_resources rr WHERE rr.run_id=r.run_id) OR a.owner_kind='run')) OR
+         (a.owner_kind='attempt' AND EXISTS (SELECT 1 FROM ne19_attempt_publications p
            WHERE p.origin_run_id=a.owner_run_id AND p.attempt_id=a.owner_attempt_id)))
       ORDER BY i.ordinal LIMIT ?`)
         .iterate(attachmentId, afterOrdinal, pageSize);
@@ -1714,14 +1783,14 @@ function memoRecordRead(read, defer) {
 }
 function readPublishedSealedRun(connection, runId, defer) {
     const run = (0, database_ts_1.recordStatement)(connection, `SELECT run_id,writer_generation,started_at,status,
-    coalesce(logical_seal_identity,'published:' || (SELECT max(p.published_revision) FROM ne18_attempt_publications p
-      WHERE p.origin_run_id=ne18_runs.run_id)) logical_seal_identity,core_payload,core_digest,
-    (SELECT p.closure_payload FROM ne18_attempt_publications p WHERE p.origin_run_id=ne18_runs.run_id
+    coalesce(logical_seal_identity,'published:' || (SELECT max(p.published_revision) FROM ne19_attempt_publications p
+      WHERE p.origin_run_id=ne19_runs.run_id)) logical_seal_identity,core_payload,core_digest,
+    (SELECT p.closure_payload FROM ne19_attempt_publications p WHERE p.origin_run_id=ne19_runs.run_id
       ORDER BY p.published_revision DESC LIMIT 1) publication_closure
-    FROM ne18_runs WHERE run_id=?
-      AND NOT EXISTS (SELECT 1 FROM ne18_run_deletion_tombstones d WHERE d.run_id=ne18_runs.run_id)
+    FROM ne19_runs WHERE run_id=?
+      AND NOT EXISTS (SELECT 1 FROM ne19_run_deletion_tombstones d WHERE d.run_id=ne19_runs.run_id)
       AND (status='sealed' OR EXISTS
-      (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=ne18_runs.run_id))`).get(runId);
+      (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=ne19_runs.run_id))`).get(runId);
     if (run === undefined)
         return undefined;
     let runCoreBytes;
@@ -1746,30 +1815,30 @@ function readPublishedSealedRun(connection, runId, defer) {
         runCoreDigest = digestBytes(runCoreBytes);
     }
     const admission = (0, database_ts_1.recordStatement)(connection, `SELECT
-    1+(SELECT count(*) FROM ne18_slots WHERE run_id=?)+(SELECT count(*) FROM ne18_attempts WHERE origin_run_id=?)+
-      (SELECT count(*) FROM ne18_members WHERE target_run_id=?)+(SELECT count(*) FROM ne18_attachments WHERE owner_run_id=?)+
-      (SELECT count(*) FROM ne18_attachment_references rr JOIN ne18_attachments aa ON aa.attachment_id=rr.attachment_id WHERE aa.owner_run_id=?)+
-      (SELECT count(*) FROM ne18_contents cc JOIN ne18_attachments aa ON aa.attachment_id=cc.attachment_id WHERE aa.owner_run_id=?) row_count,
-    coalesce(length(r.core_payload),(SELECT max(length(p.closure_payload)) FROM ne18_attempt_publications p WHERE p.origin_run_id=r.run_id),0)+
-      (SELECT coalesce(sum(length(core_payload)),0) FROM ne18_slots WHERE run_id=?)+
-      (SELECT coalesce(sum(length(core_payload)),0) FROM ne18_attempts WHERE origin_run_id=?)+
-      (SELECT coalesce(sum(length(core_payload)),0) FROM ne18_members WHERE target_run_id=?)+
-      (SELECT coalesce(sum(length(canonical_payload)+length(logical_inventory)),0) FROM ne18_attachments WHERE owner_run_id=?)+
-      (SELECT coalesce(sum(length(rr.canonical_payload)),0) FROM ne18_attachment_references rr JOIN ne18_attachments aa ON aa.attachment_id=rr.attachment_id WHERE aa.owner_run_id=?) byte_count
-    FROM ne18_runs r WHERE r.run_id=? AND (r.status='sealed' OR EXISTS
-      (SELECT 1 FROM ne18_attempt_publications p WHERE p.origin_run_id=r.run_id))`).get(runId, runId, runId, runId, runId, runId, runId, runId, runId, runId, runId, runId);
+    1+(SELECT count(*) FROM ne19_slots WHERE run_id=?)+(SELECT count(*) FROM ne19_attempts WHERE origin_run_id=?)+
+      (SELECT count(*) FROM ne19_members WHERE target_run_id=?)+(SELECT count(*) FROM ne19_attachments WHERE owner_run_id=?)+
+      (SELECT count(*) FROM ne19_attachment_references rr JOIN ne19_attachments aa ON aa.attachment_id=rr.attachment_id WHERE aa.owner_run_id=?)+
+      (SELECT count(*) FROM ne19_contents cc JOIN ne19_attachments aa ON aa.attachment_id=cc.attachment_id WHERE aa.owner_run_id=?) row_count,
+    coalesce(length(r.core_payload),(SELECT max(length(p.closure_payload)) FROM ne19_attempt_publications p WHERE p.origin_run_id=r.run_id),0)+
+      (SELECT coalesce(sum(length(core_payload)),0) FROM ne19_slots WHERE run_id=?)+
+      (SELECT coalesce(sum(length(core_payload)),0) FROM ne19_attempts WHERE origin_run_id=?)+
+      (SELECT coalesce(sum(length(core_payload)),0) FROM ne19_members WHERE target_run_id=?)+
+      (SELECT coalesce(sum(length(canonical_payload)+length(logical_inventory)),0) FROM ne19_attachments WHERE owner_run_id=?)+
+      (SELECT coalesce(sum(length(rr.canonical_payload)),0) FROM ne19_attachment_references rr JOIN ne19_attachments aa ON aa.attachment_id=rr.attachment_id WHERE aa.owner_run_id=?) byte_count
+    FROM ne19_runs r WHERE r.run_id=? AND (r.status='sealed' OR EXISTS
+      (SELECT 1 FROM ne19_attempt_publications p WHERE p.origin_run_id=r.run_id))`).get(runId, runId, runId, runId, runId, runId, runId, runId, runId, runId, runId, runId);
     assertBoundedBatch("read-sealed-run-core", integer(admission, "row_count"), integer(admission, "byte_count"));
-    const record = (0, database_ts_1.recordStatement)(connection, "SELECT record_payload,record_digest FROM ne18_record_metadata WHERE singleton=1").get();
-    const slots = rows(connection, "SELECT slot_id,ordinal,core_payload,core_digest FROM ne18_slots WHERE run_id=? ORDER BY ordinal", runId)
+    const record = (0, database_ts_1.recordStatement)(connection, "SELECT record_payload,record_digest FROM ne19_record_metadata WHERE singleton=1").get();
+    const slots = rows(connection, "SELECT slot_id,ordinal,core_payload,core_digest FROM ne19_slots WHERE run_id=? ORDER BY ordinal", runId)
         .map((row) => Object.freeze({ slotId: text(row, "slot_id"), ordinal: integer(row, "ordinal"), coreBytes: transferableBytes(bytes(row, "core_payload")), coreDigest: text(row, "core_digest") }));
-    const publicationResource = (0, database_ts_1.recordStatement)(connection, "SELECT created_revision FROM ne18_run_resources WHERE run_id=?").get(runId);
+    const publicationResource = (0, database_ts_1.recordStatement)(connection, "SELECT created_revision FROM ne19_run_resources WHERE run_id=?").get(runId);
     const publicationManaged = publicationResource !== undefined;
     const attempts = rows(connection, publicationManaged
-        ? `SELECT a.attempt_id,a.attempt_locator,a.core_payload,a.core_digest,p.published_revision FROM ne18_attempts a
-      JOIN ne18_attempt_publications p ON p.origin_run_id=a.origin_run_id AND p.attempt_id=a.attempt_id
-      WHERE a.origin_run_id=? AND EXISTS (SELECT 1 FROM ne18_attempt_publications p
+        ? `SELECT a.attempt_id,a.attempt_locator,a.core_payload,a.core_digest,p.published_revision FROM ne19_attempts a
+      JOIN ne19_attempt_publications p ON p.origin_run_id=a.origin_run_id AND p.attempt_id=a.attempt_id
+      WHERE a.origin_run_id=? AND EXISTS (SELECT 1 FROM ne19_attempt_publications p
         WHERE p.origin_run_id=a.origin_run_id AND p.attempt_id=a.attempt_id) ORDER BY a.attempt_id`
-        : "SELECT attempt_id,attempt_locator,core_payload,core_digest FROM ne18_attempts WHERE origin_run_id=? ORDER BY attempt_id", runId)
+        : "SELECT attempt_id,attempt_locator,core_payload,core_digest FROM ne19_attempts WHERE origin_run_id=? ORDER BY attempt_id", runId)
         .map((row) => {
         if (!(row.core_payload instanceof Uint8Array))
             throw (0, errors_ts_1.sqliteError)("record-database-invalid", "read-published-run-core", `Attempt ${text(row, "attempt_id")} Core is not published`);
@@ -1782,21 +1851,22 @@ function readPublishedSealedRun(connection, runId, defer) {
             ...rows(connection, `SELECT 'binding' publication_kind,b.slot_id,b.origin_run_id,b.attempt_id,b.action,b.attempt_publication_revision,b.binding_revision,
       m.origin_run_id member_origin_run_id,m.attempt_id member_attempt_id,m.action member_action,
       m.core_payload,m.core_digest,p.published_revision
-      FROM ne18_run_slot_bindings b
-      LEFT JOIN ne18_members m ON m.target_run_id=b.target_run_id AND m.slot_id=b.slot_id
-      LEFT JOIN ne18_attempt_publications p ON p.attempt_id=b.attempt_id AND p.origin_run_id=b.origin_run_id
+      FROM ne19_run_slot_bindings b
+      LEFT JOIN ne19_members m ON m.target_run_id=b.target_run_id AND m.slot_id=b.slot_id
+      LEFT JOIN ne19_attempt_publications p ON p.attempt_id=b.attempt_id AND p.origin_run_id=b.origin_run_id
         AND p.published_revision=b.attempt_publication_revision
       WHERE b.target_run_id=?`, runId),
             ...rows(connection, `SELECT 'absence' publication_kind,a.slot_id,NULL origin_run_id,NULL attempt_id,
         NULL action,NULL attempt_publication_revision,NULL member_origin_run_id,NULL member_attempt_id,
         NULL member_action,NULL core_payload,NULL core_digest,NULL published_revision,a.reason absence_reason
-        FROM ne18_run_slot_absences a
+        FROM ne19_run_slot_absences a
         WHERE a.run_id=?`, runId),
         ].sort((left, right) => text(left, "slot_id").localeCompare(text(right, "slot_id")))
-        : rows(connection, "SELECT slot_id,origin_run_id,attempt_id,action,core_payload,core_digest FROM ne18_members WHERE target_run_id=? ORDER BY slot_id", runId);
+        : rows(connection, "SELECT slot_id,origin_run_id,attempt_id,action,core_payload,core_digest FROM ne19_members WHERE target_run_id=? ORDER BY slot_id", runId);
     const members = memberRows
         .map((row) => {
         const attemptId = optionalText(row, "attempt_id");
+        let referenceCore;
         if (publicationManaged) {
             const kind = text(row, "publication_kind");
             if (kind === "absence") {
@@ -1811,14 +1881,28 @@ function readPublishedSealedRun(connection, runId, defer) {
                     coreDigest: projected.coreDigest,
                 });
             }
+            const projectReference = (row.action === "carried" || row.action === "accepted") && row.core_payload == null;
             const bindingInvalid = kind === "binding" && (attemptId === undefined
                 || optionalInteger(row, "published_revision") !== optionalInteger(row, "attempt_publication_revision")
-                || optionalText(row, "member_origin_run_id") !== optionalText(row, "origin_run_id")
-                || optionalText(row, "member_attempt_id") !== attemptId
-                || optionalText(row, "member_action") !== optionalText(row, "action"));
+                || !projectReference && (optionalText(row, "member_origin_run_id") !== optionalText(row, "origin_run_id")
+                    || optionalText(row, "member_attempt_id") !== attemptId
+                    || optionalText(row, "member_action") !== optionalText(row, "action")));
             if (bindingInvalid) {
                 throw (0, errors_ts_1.sqliteError)("record-database-invalid", "read-published-run", `Published Slot ${text(row, "slot_id")} does not close over one matching Member`);
             }
+            if (projectReference) {
+                const decoded = (0, core_ts_1.decodeMemberDocument)({
+                    slotId: text(row, "slot_id"), action: text(row, "action"),
+                    attempt: { originRunId: text(row, "origin_run_id"), attemptId },
+                });
+                if (effect_1.Result.isFailure(decoded))
+                    throw (0, errors_ts_1.sqliteError)("record-database-invalid", "read-published-run", "Reference binding cannot project a Member");
+                const encoded = (0, core_ts_1.encodeMemberDocument)(decoded.success);
+                if (effect_1.Result.isFailure(encoded))
+                    throw (0, errors_ts_1.sqliteError)("record-database-invalid", "read-published-run", "Reference Member cannot be encoded");
+                const projectedBytes = (0, limits_ts_1.encodeRecordJsonUtf8)(encoded.success);
+                referenceCore = { bytes: projectedBytes, digest: digestBytes(projectedBytes) };
+            }
         }
         return Object.freeze({ slotId: text(row, "slot_id"),
             ...(publicationManaged && attemptId !== undefined ? { bindingRevision: integer(row, "binding_revision") } : {}), ...(optionalText(row, "origin_run_id") === undefined ? {} : { originRunId: optionalText(row, "origin_run_id") }),
@@ -1826,34 +1910,34 @@ function readPublishedSealedRun(connection, runId, defer) {
             ...(publicationManaged && attemptId !== undefined
                 ? { publicationIdentity: Object.freeze({ originRunId: text(row, "origin_run_id"), attemptId, revision: integer(row, "published_revision") }) }
                 : {}),
-            coreBytes: transferableBytes(bytes(row, "core_payload")), coreDigest: text(row, "core_digest") });
+            coreBytes: transferableBytes(referenceCore?.bytes ?? bytes(row, "core_payload")), coreDigest: referenceCore?.digest ?? text(row, "core_digest") });
     });
     const attachmentRows = rows(connection, `SELECT attachment_id,owner_kind,owner_run_id,owner_attempt_id,family,family_revision,
     logical_identity,canonical_digest,inventory_digest
-    FROM ne18_attachments a WHERE owner_run_id=?${publicationManaged ? ` AND canonical_payload IS NOT NULL AND
-      (owner_kind='run' OR EXISTS (SELECT 1 FROM ne18_attempt_publications p
+    FROM ne19_attachments a WHERE owner_run_id=?${publicationManaged ? ` AND canonical_payload IS NOT NULL AND
+      (owner_kind='run' OR EXISTS (SELECT 1 FROM ne19_attempt_publications p
         WHERE p.origin_run_id=a.owner_run_id AND p.attempt_id=a.owner_attempt_id))` : ""} ORDER BY attachment_id`, runId);
     const attachments = attachmentRows.map((row) => {
         const attachmentId = text(row, "attachment_id");
         const payload = memoRecordRead(() => {
-            const stored = (0, database_ts_1.recordStatement)(connection, `SELECT canonical_payload,logical_inventory FROM ne18_attachments WHERE attachment_id=?`)
+            const stored = (0, database_ts_1.recordStatement)(connection, `SELECT canonical_payload,logical_inventory FROM ne19_attachments WHERE attachment_id=?`)
                 .get(attachmentId);
             return { canonicalBytes: transferableBytes(bytes(stored, "canonical_payload")),
                 logicalInventoryBytes: transferableBytes(bytes(stored, "logical_inventory")) };
         }, defer);
         const references = memoRecordRead(() => Object.freeze(rows(connection, `SELECT ordinal,target_owner_kind,target_family,canonical_payload,reference_digest
-      FROM ne18_attachment_references WHERE attachment_id=? ORDER BY ordinal`, attachmentId).map((reference) => Object.freeze({
+      FROM ne19_attachment_references WHERE attachment_id=? ORDER BY ordinal`, attachmentId).map((reference) => Object.freeze({
             ordinal: integer(reference, "ordinal"), owner: ownerKind(reference, "target_owner_kind"), family: text(reference, "target_family"),
             canonicalBytes: transferableBytes(bytes(reference, "canonical_payload")), referenceDigest: text(reference, "reference_digest"),
         }))), defer);
         const contents = memoRecordRead(() => Object.freeze(rows(connection, `SELECT content_id,logical_handle,byte_length,overall_digest,chunk_count
-      FROM ne18_contents WHERE attachment_id=? ORDER BY content_id`, attachmentId).map((content) => Object.freeze({
+      FROM ne19_contents WHERE attachment_id=? ORDER BY content_id`, attachmentId).map((content) => Object.freeze({
             contentId: text(content, "content_id"), logicalHandle: text(content, "logical_handle"), byteLength: integer(content, "byte_length"),
             digest: text(content, "overall_digest"), chunkCount: integer(content, "chunk_count"),
         }))), defer);
         const collection = memoRecordRead(() => {
             const aggregate = (0, database_ts_1.recordStatement)(connection, `SELECT count(*) item_count,coalesce(sum(length(canonical_payload)),0) item_bytes
-        FROM ne18_collection_items WHERE attachment_id=?`).get(attachmentId);
+        FROM ne19_collection_items WHERE attachment_id=?`).get(attachmentId);
             return { count: integer(aggregate, "item_count"), byteLength: integer(aggregate, "item_bytes") };
         }, defer);
         return Object.freeze({ attachmentId, ownerKind: ownerKind(row, "owner_kind"), ownerRunId: text(row, "owner_run_id"),
@@ -1877,19 +1961,19 @@ function readSealedRunCore(connection, runId, defer) {
 /** Fixed, decoded projection sufficient to rebuild sealed Core and attachment metadata. */
 function readSealedRunDocument(connection, runId) {
     const run = (0, database_ts_1.recordStatement)(connection, `SELECT run_id,writer_generation,started_at,logical_seal_identity,core_payload,core_digest
-    FROM ne18_runs WHERE run_id=? AND status='sealed'`).get(runId);
+    FROM ne19_runs WHERE run_id=? AND status='sealed'`).get(runId);
     if (run === undefined)
         return undefined;
     const whole = (0, database_ts_1.recordStatement)(connection, `SELECT count(*) row_count,coalesce(sum(length(i.canonical_payload)),0) byte_count
-    FROM ne18_collection_items i JOIN ne18_attachments a ON a.attachment_id=i.attachment_id WHERE a.owner_run_id=?`).get(runId);
+    FROM ne19_collection_items i JOIN ne19_attachments a ON a.attachment_id=i.attachment_id WHERE a.owner_run_id=?`).get(runId);
     assertBoundedBatch("read-sealed-run-document", integer(whole, "row_count"), integer(whole, "byte_count"));
-    const record = (0, database_ts_1.recordStatement)(connection, "SELECT record_payload,record_digest FROM ne18_record_metadata WHERE singleton=1")
+    const record = (0, database_ts_1.recordStatement)(connection, "SELECT record_payload,record_digest FROM ne19_record_metadata WHERE singleton=1")
         .get();
-    const slots = rows(connection, "SELECT slot_id,ordinal,core_payload,core_digest FROM ne18_slots WHERE run_id=? ORDER BY ordinal", runId)
+    const slots = rows(connection, "SELECT slot_id,ordinal,core_payload,core_digest FROM ne19_slots WHERE run_id=? ORDER BY ordinal", runId)
         .map((row) => Object.freeze({ slotId: text(row, "slot_id"), ordinal: integer(row, "ordinal"), coreBytes: transferableBytes(bytes(row, "core_payload")), coreDigest: text(row, "core_digest") }));
-    const attempts = rows(connection, "SELECT attempt_id,attempt_locator,core_payload,core_digest FROM ne18_attempts WHERE origin_run_id=? ORDER BY attempt_id", runId)
+    const attempts = rows(connection, "SELECT attempt_id,attempt_locator,core_payload,core_digest FROM ne19_attempts WHERE origin_run_id=? ORDER BY attempt_id", runId)
         .map((row) => Object.freeze({ attemptId: text(row, "attempt_id"), attemptLocator: text(row, "attempt_locator"), coreBytes: transferableBytes(bytes(row, "core_payload")), coreDigest: text(row, "core_digest") }));
-    const members = rows(connection, `SELECT slot_id,origin_run_id,attempt_id,action,core_payload,core_digest FROM ne18_members
+    const members = rows(connection, `SELECT slot_id,origin_run_id,attempt_id,action,core_payload,core_digest FROM ne19_members
     WHERE target_run_id=? ORDER BY slot_id`, runId).map((row) => Object.freeze({
         slotId: text(row, "slot_id"),
         ...(optionalText(row, "origin_run_id") === undefined ? {} : { originRunId: optionalText(row, "origin_run_id") }),
@@ -1899,12 +1983,12 @@ function readSealedRunDocument(connection, runId) {
         coreDigest: text(row, "core_digest"),
     }));
     const attachmentRows = rows(connection, `SELECT attachment_id,owner_kind,owner_run_id,owner_attempt_id,family,family_revision,
-    logical_identity,canonical_payload,canonical_digest,logical_inventory,inventory_digest FROM ne18_attachments
+    logical_identity,canonical_payload,canonical_digest,logical_inventory,inventory_digest FROM ne19_attachments
     WHERE owner_run_id=? ORDER BY attachment_id`, runId);
     const attachments = attachmentRows.map((row) => {
         const attachmentId = text(row, "attachment_id");
         const references = rows(connection, `SELECT ordinal,target_owner_kind,target_family,
-      canonical_payload,reference_digest FROM ne18_attachment_references WHERE attachment_id=? ORDER BY ordinal`, attachmentId)
+      canonical_payload,reference_digest FROM ne19_attachment_references WHERE attachment_id=? ORDER BY ordinal`, attachmentId)
             .map((reference) => Object.freeze({
             ordinal: integer(reference, "ordinal"),
             owner: ownerKind(reference, "target_owner_kind"),
@@ -1913,14 +1997,14 @@ function readSealedRunDocument(connection, runId) {
             referenceDigest: text(reference, "reference_digest"),
         }));
         const collectionItems = rows(connection, `SELECT ordinal,logical_identity,canonical_payload,canonical_digest
-      FROM ne18_collection_items WHERE attachment_id=? ORDER BY ordinal`, attachmentId).map((item) => Object.freeze({
+      FROM ne19_collection_items WHERE attachment_id=? ORDER BY ordinal`, attachmentId).map((item) => Object.freeze({
             ordinal: integer(item, "ordinal"),
             logicalIdentity: text(item, "logical_identity"),
             canonicalBytes: transferableBytes(bytes(item, "canonical_payload")),
             canonicalDigest: text(item, "canonical_digest"),
         }));
         const contents = rows(connection, `SELECT content_id,logical_handle,byte_length,overall_digest,chunk_count
-      FROM ne18_contents WHERE attachment_id=? ORDER BY content_id`, attachmentId).map((content) => Object.freeze({
+      FROM ne19_contents WHERE attachment_id=? ORDER BY content_id`, attachmentId).map((content) => Object.freeze({
             contentId: text(content, "content_id"),
             logicalHandle: text(content, "logical_handle"),
             byteLength: integer(content, "byte_length"),
@@ -1975,9 +2059,9 @@ function appendContentChunks(connection, input) {
     }
     (0, transaction_ts_1.withImmediateTransaction)(connection, input.deadlineEpochMs, "append-content-chunks", () => {
         assertRunFence(connection, input.runId, input.writerGeneration, "append-content-chunks");
-        const metadata = (0, database_ts_1.recordStatement)(connection, `SELECT a.owner_run_id,a.owner_kind,r.status,at.publication_state FROM ne18_contents c
-      JOIN ne18_attachments a ON a.attachment_id=c.attachment_id JOIN ne18_runs r ON r.run_id=a.owner_run_id
-      LEFT JOIN ne18_attempts at ON at.origin_run_id=a.owner_run_id AND at.attempt_id=a.owner_attempt_id
+        const metadata = (0, database_ts_1.recordStatement)(connection, `SELECT a.owner_run_id,a.owner_kind,r.status,at.publication_state FROM ne19_contents c
+      JOIN ne19_attachments a ON a.attachment_id=c.attachment_id JOIN ne19_runs r ON r.run_id=a.owner_run_id
+      LEFT JOIN ne19_attempts at ON at.origin_run_id=a.owner_run_id AND at.attempt_id=a.owner_attempt_id
       WHERE c.content_id=?`).get(input.contentId);
         if (metadata === undefined || text(metadata, "owner_run_id") !== input.runId || text(metadata, "status") !== "open" ||
             (text(metadata, "owner_kind") === "attempt" && optionalText(metadata, "publication_state") === "published")) {
@@ -1985,13 +2069,13 @@ function appendContentChunks(connection, input) {
         }
         let changed = false;
         for (const chunk of input.chunks) {
-            const stored = (0, database_ts_1.recordStatement)(connection, "SELECT bytes,chunk_digest FROM ne18_content_chunks WHERE content_id=? AND ordinal=?")
+            const stored = (0, database_ts_1.recordStatement)(connection, "SELECT bytes,chunk_digest FROM ne19_content_chunks WHERE content_id=? AND ordinal=?")
                 .get(input.contentId, chunk.ordinal);
             if (stored === undefined) {
-                const count = (0, database_ts_1.recordStatement)(connection, "SELECT count(*) AS count FROM ne18_content_chunks WHERE content_id=?").get(input.contentId);
+                const count = (0, database_ts_1.recordStatement)(connection, "SELECT count(*) AS count FROM ne19_content_chunks WHERE content_id=?").get(input.contentId);
                 if (chunk.ordinal !== integer(count, "count"))
                     throw (0, errors_ts_1.sqliteError)("record-command-conflict", "append-content-chunks", "Content batch does not extend the committed prefix");
-                (0, database_ts_1.recordStatement)(connection, "INSERT INTO ne18_content_chunks(content_id,ordinal,bytes,chunk_digest) VALUES (?,?,?,?)")
+                (0, database_ts_1.recordStatement)(connection, "INSERT INTO ne19_content_chunks(content_id,ordinal,bytes,chunk_digest) VALUES (?,?,?,?)")
                     .run(input.contentId, chunk.ordinal, chunk.bytes, chunk.chunkDigest);
                 changed = true;
             }
@@ -2013,12 +2097,12 @@ function readContentChunkPage(connection, contentId, afterOrdinal, pageSize) {
     let pageBytes = 0;
     let hasMore = false;
     const pageRows = (0, database_ts_1.recordStatement)(connection, `SELECT c.ordinal,c.bytes,c.chunk_digest,
-      EXISTS(SELECT 1 FROM ne18_content_chunks more WHERE more.content_id=c.content_id AND more.ordinal>c.ordinal) AS has_more
-      FROM ne18_content_chunks c
-      JOIN ne18_contents n ON n.content_id=c.content_id JOIN ne18_attachments a ON a.attachment_id=n.attachment_id
-      JOIN ne18_runs r ON r.run_id=a.owner_run_id WHERE c.content_id=? AND c.ordinal>? AND
-        ((r.status='sealed' AND (NOT EXISTS (SELECT 1 FROM ne18_run_resources rr WHERE rr.run_id=r.run_id) OR a.owner_kind='run')) OR
-         (a.owner_kind='attempt' AND EXISTS (SELECT 1 FROM ne18_attempt_publications p
+      EXISTS(SELECT 1 FROM ne19_content_chunks more WHERE more.content_id=c.content_id AND more.ordinal>c.ordinal) AS has_more
+      FROM ne19_content_chunks c
+      JOIN ne19_contents n ON n.content_id=c.content_id JOIN ne19_attachments a ON a.attachment_id=n.attachment_id
+      JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE c.content_id=? AND c.ordinal>? AND
+        ((r.status='sealed' AND (NOT EXISTS (SELECT 1 FROM ne19_run_resources rr WHERE rr.run_id=r.run_id) OR a.owner_kind='run')) OR
+         (a.owner_kind='attempt' AND EXISTS (SELECT 1 FROM ne19_attempt_publications p
            WHERE p.origin_run_id=a.owner_run_id AND p.attempt_id=a.owner_attempt_id)))
       ORDER BY c.ordinal LIMIT ?`).iterate(contentId, afterOrdinal, pageSize);
     for (const row of pageRows) {