niceeval 0.16.3-canary.99 → 0.17.1

package/dist/record/sqlite/current-schema.cjs

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RECORD_SQLITE_BASELINE_SQL = void 0;
 /**
- * Exact current ProjectDatabase 0.18 schema, independent of frozen historical
+ * Exact current ProjectDatabase 0.19 schema, independent of frozen historical
  * baselines. Keep these bytes stable within this format: they own its fingerprint.
- * The disjoint namespace fences writers prepared against the 0.17 tables.
+ * The disjoint namespace fences writers prepared against the 0.18 tables.
  */
 exports.RECORD_SQLITE_BASELINE_SQL = `
-CREATE TABLE ne18_record_metadata (
+CREATE TABLE ne19_record_metadata (
   singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
   format TEXT NOT NULL,
   storage_revision INTEGER NOT NULL CHECK (storage_revision > 0),
@@ -26,7 +26,7 @@ CREATE TABLE ne18_record_metadata (
   CHECK ((barrier_state = 'portable') = (portable_revision IS NOT NULL)),
   CHECK ((barrier_state = 'open') = (portable_gate_id IS NULL))
 ) STRICT;
-CREATE TABLE ne18_coordination_state (
+CREATE TABLE ne19_coordination_state (
   singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
   revision INTEGER NOT NULL CHECK (revision >= 0),
   operational_generation TEXT NOT NULL,
@@ -78,7 +78,7 @@ CREATE TABLE ne18_coordination_state (
     (barrier_status = 'active' AND barrier_active_at IS NOT NULL)
   )
 ) STRICT;
-CREATE TABLE ne18_coordination_tickets (
+CREATE TABLE ne19_coordination_tickets (
   ticket_id TEXT PRIMARY KEY,
   sequence INTEGER NOT NULL UNIQUE CHECK (sequence > 0),
   host TEXT NOT NULL,
@@ -88,8 +88,9 @@ CREATE TABLE ne18_coordination_tickets (
   deadline INTEGER NOT NULL CHECK (deadline > 0),
   enqueued_at INTEGER NOT NULL CHECK (enqueued_at > 0)
 ) STRICT;
-CREATE TABLE ne18_runs (
+CREATE TABLE ne19_runs (
   run_id TEXT PRIMARY KEY,
+  experiment_id TEXT NOT NULL,
   status TEXT NOT NULL CHECK (status IN ('open','sealing','sealed')),
   writer_generation TEXT NOT NULL,
   started_at TEXT NOT NULL,
@@ -108,8 +109,8 @@ CREATE TABLE ne18_runs (
   CHECK ((status = 'sealed') = (logical_seal_identity IS NOT NULL)),
   CHECK (status = 'open' OR core_payload IS NOT NULL)
 ) STRICT;
-CREATE TABLE ne18_slots (
-  run_id TEXT NOT NULL REFERENCES ne18_runs(run_id) ON DELETE CASCADE,
+CREATE TABLE ne19_slots (
+  run_id TEXT NOT NULL REFERENCES ne19_runs(run_id) ON DELETE CASCADE,
   slot_id TEXT NOT NULL,
   ordinal INTEGER NOT NULL CHECK (ordinal >= 0),
   core_payload BLOB NOT NULL,
@@ -117,8 +118,8 @@ CREATE TABLE ne18_slots (
   PRIMARY KEY (run_id, slot_id),
   UNIQUE (run_id, ordinal)
 ) STRICT;
-CREATE TABLE ne18_attempts (
-  origin_run_id TEXT NOT NULL REFERENCES ne18_runs(run_id) ON DELETE CASCADE,
+CREATE TABLE ne19_attempts (
+  origin_run_id TEXT NOT NULL REFERENCES ne19_runs(run_id) ON DELETE CASCADE,
   attempt_id TEXT NOT NULL,
   attempt_locator TEXT NOT NULL CHECK (length(attempt_locator) = 14 AND substr(attempt_locator,1,2) = '@1'),
   publication_state TEXT NOT NULL DEFAULT 'staging' CHECK (publication_state IN ('staging','sealing','published')),
@@ -127,7 +128,7 @@ CREATE TABLE ne18_attempts (
   CHECK ((core_payload IS NULL) = (core_digest IS NULL)),
   PRIMARY KEY (origin_run_id, attempt_id)
 ) STRICT;
-CREATE TABLE ne18_members (
+CREATE TABLE ne19_members (
   target_run_id TEXT NOT NULL,
   slot_id TEXT NOT NULL,
   origin_run_id TEXT,
@@ -140,12 +141,12 @@ CREATE TABLE ne18_members (
     (action IN ('executed','carried','accepted') AND origin_run_id IS NOT NULL AND attempt_id IS NOT NULL) OR
     (action IN ('not-dispatched','interrupted') AND origin_run_id IS NULL AND attempt_id IS NULL)
   ),
-  FOREIGN KEY (target_run_id, slot_id) REFERENCES ne18_slots(run_id, slot_id) ON DELETE CASCADE
+  FOREIGN KEY (target_run_id, slot_id) REFERENCES ne19_slots(run_id, slot_id) ON DELETE CASCADE
 ) STRICT;
-CREATE TABLE ne18_attachments (
+CREATE TABLE ne19_attachments (
   attachment_id TEXT PRIMARY KEY,
   owner_kind TEXT NOT NULL CHECK (owner_kind IN ('run','attempt')),
-  owner_run_id TEXT NOT NULL REFERENCES ne18_runs(run_id) ON DELETE CASCADE,
+  owner_run_id TEXT NOT NULL REFERENCES ne19_runs(run_id) ON DELETE CASCADE,
   owner_attempt_id TEXT,
   family TEXT NOT NULL,
   family_revision INTEGER NOT NULL CHECK (family_revision > 0),
@@ -158,10 +159,10 @@ CREATE TABLE ne18_attachments (
   CHECK ((logical_inventory IS NULL) = (inventory_digest IS NULL)),
   CHECK ((owner_kind = 'run' AND owner_attempt_id IS NULL) OR (owner_kind = 'attempt' AND owner_attempt_id IS NOT NULL)),
   UNIQUE (owner_kind, owner_run_id, owner_attempt_id, family),
-  FOREIGN KEY (owner_run_id, owner_attempt_id) REFERENCES ne18_attempts(origin_run_id, attempt_id) ON DELETE CASCADE
+  FOREIGN KEY (owner_run_id, owner_attempt_id) REFERENCES ne19_attempts(origin_run_id, attempt_id) ON DELETE CASCADE
 ) STRICT;
-CREATE TABLE ne18_attachment_references (
-  attachment_id TEXT NOT NULL REFERENCES ne18_attachments(attachment_id) ON DELETE CASCADE,
+CREATE TABLE ne19_attachment_references (
+  attachment_id TEXT NOT NULL REFERENCES ne19_attachments(attachment_id) ON DELETE CASCADE,
   ordinal INTEGER NOT NULL CHECK (ordinal >= 0),
   target_owner_kind TEXT NOT NULL CHECK (target_owner_kind IN ('run','attempt')),
   target_family TEXT NOT NULL,
@@ -169,8 +170,8 @@ CREATE TABLE ne18_attachment_references (
   reference_digest TEXT NOT NULL CHECK (length(reference_digest) = 64),
   PRIMARY KEY (attachment_id, ordinal)
 ) STRICT;
-CREATE TABLE ne18_collection_items (
-  attachment_id TEXT NOT NULL REFERENCES ne18_attachments(attachment_id) ON DELETE CASCADE,
+CREATE TABLE ne19_collection_items (
+  attachment_id TEXT NOT NULL REFERENCES ne19_attachments(attachment_id) ON DELETE CASCADE,
   ordinal INTEGER NOT NULL CHECK (ordinal >= 0),
   logical_identity TEXT NOT NULL,
   canonical_payload BLOB NOT NULL,
@@ -178,9 +179,9 @@ CREATE TABLE ne18_collection_items (
   PRIMARY KEY (attachment_id, ordinal),
   UNIQUE (attachment_id, logical_identity)
 ) STRICT;
-CREATE TABLE ne18_contents (
+CREATE TABLE ne19_contents (
   content_id TEXT PRIMARY KEY,
-  attachment_id TEXT NOT NULL REFERENCES ne18_attachments(attachment_id) ON DELETE CASCADE,
+  attachment_id TEXT NOT NULL REFERENCES ne19_attachments(attachment_id) ON DELETE CASCADE,
   logical_handle TEXT NOT NULL,
   byte_length INTEGER CHECK (byte_length IS NULL OR byte_length >= 0),
   overall_digest TEXT CHECK (overall_digest IS NULL OR length(overall_digest) = 64),
@@ -188,15 +189,15 @@ CREATE TABLE ne18_contents (
   CHECK ((byte_length IS NULL) = (overall_digest IS NULL) AND (overall_digest IS NULL) = (chunk_count IS NULL)),
   UNIQUE (attachment_id, logical_handle)
 ) STRICT;
-CREATE TABLE ne18_content_chunks (
-  content_id TEXT NOT NULL REFERENCES ne18_contents(content_id) ON DELETE CASCADE,
+CREATE TABLE ne19_content_chunks (
+  content_id TEXT NOT NULL REFERENCES ne19_contents(content_id) ON DELETE CASCADE,
   ordinal INTEGER NOT NULL CHECK (ordinal >= 0),
   bytes BLOB NOT NULL CHECK (length(bytes) <= 262144),
   chunk_digest TEXT NOT NULL CHECK (length(chunk_digest) = 64),
   PRIMARY KEY (content_id, ordinal)
 ) STRICT;
-CREATE TABLE ne18_run_seal_entries (
-  run_id TEXT NOT NULL REFERENCES ne18_runs(run_id) ON DELETE CASCADE,
+CREATE TABLE ne19_run_seal_entries (
+  run_id TEXT NOT NULL REFERENCES ne19_runs(run_id) ON DELETE CASCADE,
   ordinal INTEGER NOT NULL CHECK (ordinal >= 0),
   entry_kind TEXT NOT NULL CHECK (entry_kind IN ('record','run','slot','member','attempt','attachment','attachment-reference','collection-item','content','content-chunk')),
   logical_identity TEXT NOT NULL,
@@ -204,54 +205,54 @@ CREATE TABLE ne18_run_seal_entries (
   PRIMARY KEY (run_id, ordinal),
   UNIQUE (run_id, entry_kind, logical_identity)
 ) STRICT;
-CREATE INDEX ne18_attachments_owner_family ON ne18_attachments(owner_kind, owner_run_id, owner_attempt_id, family);
-CREATE UNIQUE INDEX ne18_attachments_owner_family_unique ON ne18_attachments(owner_kind, owner_run_id, coalesce(owner_attempt_id,''), family);
-CREATE INDEX ne18_members_origin_attempt ON ne18_members(origin_run_id, attempt_id, target_run_id);
-CREATE INDEX ne18_attempts_locator ON ne18_attempts(attempt_locator, origin_run_id, attempt_id);
-CREATE INDEX ne18_references_target_family ON ne18_attachment_references(target_owner_kind, target_family);
-CREATE INDEX ne18_content_chunks_page ON ne18_content_chunks(content_id, ordinal);
-CREATE INDEX ne18_coordination_tickets_fifo ON ne18_coordination_tickets(sequence);
-CREATE TRIGGER ne18_coordination_ticket_barrier_insert BEFORE INSERT ON ne18_coordination_tickets WHEN (SELECT barrier_state FROM ne18_record_metadata WHERE singleton=1)!='open' BEGIN SELECT RAISE(ABORT, 'ProjectDatabase writer barrier is not open'); END;
-CREATE TRIGGER ne18_coordination_writer_barrier_update BEFORE UPDATE ON ne18_coordination_state WHEN NEW.writer_ticket_id IS NOT NULL AND (SELECT barrier_state FROM ne18_record_metadata WHERE singleton=1)!='open' BEGIN SELECT RAISE(ABORT, 'ProjectDatabase writer barrier is not open'); END;
-CREATE TRIGGER ne18_runs_sealed_update BEFORE UPDATE ON ne18_runs WHEN OLD.status = 'sealed' BEGIN SELECT RAISE(ABORT, 'sealed run is immutable'); END;
-CREATE TRIGGER ne18_runs_sealed_delete BEFORE DELETE ON ne18_runs WHEN OLD.status = 'sealed' BEGIN SELECT RAISE(ABORT, 'sealed run is immutable'); END;
-CREATE TRIGGER ne18_slots_sealed_insert BEFORE INSERT ON ne18_slots WHEN (SELECT status FROM ne18_runs WHERE run_id = NEW.run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_slots_sealed_update BEFORE UPDATE ON ne18_slots WHEN (SELECT status FROM ne18_runs WHERE run_id = OLD.run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_slots_sealed_delete BEFORE DELETE ON ne18_slots WHEN (SELECT status FROM ne18_runs WHERE run_id = OLD.run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_attempts_sealed_insert BEFORE INSERT ON ne18_attempts WHEN (SELECT status FROM ne18_runs WHERE run_id = NEW.origin_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_attempts_sealed_update BEFORE UPDATE ON ne18_attempts WHEN (SELECT status FROM ne18_runs WHERE run_id = OLD.origin_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_attempts_sealed_delete BEFORE DELETE ON ne18_attempts WHEN (SELECT status FROM ne18_runs WHERE run_id = OLD.origin_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_members_sealed_insert BEFORE INSERT ON ne18_members WHEN (SELECT status FROM ne18_runs WHERE run_id = NEW.target_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_members_sealed_update BEFORE UPDATE ON ne18_members WHEN (SELECT status FROM ne18_runs WHERE run_id = OLD.target_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_members_sealed_delete BEFORE DELETE ON ne18_members WHEN (SELECT status FROM ne18_runs WHERE run_id = OLD.target_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_attachments_sealed_insert BEFORE INSERT ON ne18_attachments WHEN (SELECT status FROM ne18_runs WHERE run_id = NEW.owner_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_attachments_attempt_published_insert BEFORE INSERT ON ne18_attachments WHEN NEW.owner_kind='attempt' AND (SELECT publication_state FROM ne18_attempts WHERE origin_run_id=NEW.owner_run_id AND attempt_id=NEW.owner_attempt_id)='published' BEGIN SELECT RAISE(ABORT, 'published attempt is immutable'); END;
-CREATE TRIGGER ne18_attachments_sealed_update BEFORE UPDATE ON ne18_attachments WHEN (SELECT status FROM ne18_runs WHERE run_id = OLD.owner_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_attachments_attempt_published_update BEFORE UPDATE ON ne18_attachments WHEN OLD.owner_kind='attempt' AND (SELECT publication_state FROM ne18_attempts WHERE origin_run_id=OLD.owner_run_id AND attempt_id=OLD.owner_attempt_id)='published' BEGIN SELECT RAISE(ABORT, 'published attempt is immutable'); END;
-CREATE TRIGGER ne18_attachments_sealed_delete BEFORE DELETE ON ne18_attachments WHEN (SELECT status FROM ne18_runs WHERE run_id = OLD.owner_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_attachments_attempt_published_delete BEFORE DELETE ON ne18_attachments WHEN OLD.owner_kind='attempt' AND (SELECT publication_state FROM ne18_attempts WHERE origin_run_id=OLD.owner_run_id AND attempt_id=OLD.owner_attempt_id)='published' BEGIN SELECT RAISE(ABORT, 'published attempt is immutable'); END;
-CREATE TRIGGER ne18_references_sealed_insert BEFORE INSERT ON ne18_attachment_references WHEN (SELECT r.status FROM ne18_attachments a JOIN ne18_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=NEW.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_references_sealed_update BEFORE UPDATE ON ne18_attachment_references WHEN (SELECT r.status FROM ne18_attachments a JOIN ne18_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_references_sealed_delete BEFORE DELETE ON ne18_attachment_references WHEN (SELECT r.status FROM ne18_attachments a JOIN ne18_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_items_sealed_insert BEFORE INSERT ON ne18_collection_items WHEN (SELECT r.status FROM ne18_attachments a JOIN ne18_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=NEW.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_items_sealed_update BEFORE UPDATE ON ne18_collection_items WHEN (SELECT r.status FROM ne18_attachments a JOIN ne18_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_items_sealed_delete BEFORE DELETE ON ne18_collection_items WHEN (SELECT r.status FROM ne18_attachments a JOIN ne18_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_contents_sealed_insert BEFORE INSERT ON ne18_contents WHEN (SELECT r.status FROM ne18_attachments a JOIN ne18_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=NEW.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_contents_sealed_update BEFORE UPDATE ON ne18_contents WHEN (SELECT r.status FROM ne18_attachments a JOIN ne18_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_contents_sealed_delete BEFORE DELETE ON ne18_contents WHEN (SELECT r.status FROM ne18_attachments a JOIN ne18_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_chunks_sealed_insert BEFORE INSERT ON ne18_content_chunks WHEN (SELECT r.status 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 WHERE c.content_id=NEW.content_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_chunks_sealed_update BEFORE UPDATE ON ne18_content_chunks WHEN (SELECT r.status 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 WHERE c.content_id=OLD.content_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_chunks_sealed_delete BEFORE DELETE ON ne18_content_chunks WHEN (SELECT r.status 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 WHERE c.content_id=OLD.content_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
-CREATE TRIGGER ne18_seal_entries_sealed_insert BEFORE INSERT ON ne18_run_seal_entries WHEN (SELECT status FROM ne18_runs WHERE run_id = NEW.run_id) != 'sealing' BEGIN SELECT RAISE(ABORT, 'Seal candidates require sealing state'); END;
-CREATE TRIGGER ne18_seal_entries_sealed_update BEFORE UPDATE ON ne18_run_seal_entries BEGIN SELECT RAISE(ABORT, 'Seal entries are immutable'); END;
-CREATE TRIGGER ne18_seal_entries_sealed_delete BEFORE DELETE ON ne18_run_seal_entries WHEN (SELECT status FROM ne18_runs WHERE run_id = OLD.run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'Seal entries are immutable'); END;
+CREATE INDEX ne19_attachments_owner_family ON ne19_attachments(owner_kind, owner_run_id, owner_attempt_id, family);
+CREATE UNIQUE INDEX ne19_attachments_owner_family_unique ON ne19_attachments(owner_kind, owner_run_id, coalesce(owner_attempt_id,''), family);
+CREATE INDEX ne19_members_origin_attempt ON ne19_members(origin_run_id, attempt_id, target_run_id);
+CREATE INDEX ne19_attempts_locator ON ne19_attempts(attempt_locator, origin_run_id, attempt_id);
+CREATE INDEX ne19_references_target_family ON ne19_attachment_references(target_owner_kind, target_family);
+CREATE INDEX ne19_content_chunks_page ON ne19_content_chunks(content_id, ordinal);
+CREATE INDEX ne19_coordination_tickets_fifo ON ne19_coordination_tickets(sequence);
+CREATE TRIGGER ne19_coordination_ticket_barrier_insert BEFORE INSERT ON ne19_coordination_tickets WHEN (SELECT barrier_state FROM ne19_record_metadata WHERE singleton=1)!='open' BEGIN SELECT RAISE(ABORT, 'ProjectDatabase writer barrier is not open'); END;
+CREATE TRIGGER ne19_coordination_writer_barrier_update BEFORE UPDATE ON ne19_coordination_state WHEN NEW.writer_ticket_id IS NOT NULL AND (SELECT barrier_state FROM ne19_record_metadata WHERE singleton=1)!='open' BEGIN SELECT RAISE(ABORT, 'ProjectDatabase writer barrier is not open'); END;
+CREATE TRIGGER ne19_runs_sealed_update BEFORE UPDATE ON ne19_runs WHEN OLD.status = 'sealed' BEGIN SELECT RAISE(ABORT, 'sealed run is immutable'); END;
+CREATE TRIGGER ne19_runs_sealed_delete BEFORE DELETE ON ne19_runs WHEN OLD.status = 'sealed' BEGIN SELECT RAISE(ABORT, 'sealed run is immutable'); END;
+CREATE TRIGGER ne19_slots_sealed_insert BEFORE INSERT ON ne19_slots WHEN (SELECT status FROM ne19_runs WHERE run_id = NEW.run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_slots_sealed_update BEFORE UPDATE ON ne19_slots WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_slots_sealed_delete BEFORE DELETE ON ne19_slots WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_attempts_sealed_insert BEFORE INSERT ON ne19_attempts WHEN (SELECT status FROM ne19_runs WHERE run_id = NEW.origin_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_attempts_sealed_update BEFORE UPDATE ON ne19_attempts WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.origin_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_attempts_sealed_delete BEFORE DELETE ON ne19_attempts WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.origin_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_members_sealed_insert BEFORE INSERT ON ne19_members WHEN (SELECT status FROM ne19_runs WHERE run_id = NEW.target_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_members_sealed_update BEFORE UPDATE ON ne19_members WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.target_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_members_sealed_delete BEFORE DELETE ON ne19_members WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.target_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_attachments_sealed_insert BEFORE INSERT ON ne19_attachments WHEN (SELECT status FROM ne19_runs WHERE run_id = NEW.owner_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_attachments_attempt_published_insert BEFORE INSERT ON ne19_attachments WHEN NEW.owner_kind='attempt' AND (SELECT publication_state FROM ne19_attempts WHERE origin_run_id=NEW.owner_run_id AND attempt_id=NEW.owner_attempt_id)='published' BEGIN SELECT RAISE(ABORT, 'published attempt is immutable'); END;
+CREATE TRIGGER ne19_attachments_sealed_update BEFORE UPDATE ON ne19_attachments WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.owner_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_attachments_attempt_published_update BEFORE UPDATE ON ne19_attachments WHEN OLD.owner_kind='attempt' AND (SELECT publication_state FROM ne19_attempts WHERE origin_run_id=OLD.owner_run_id AND attempt_id=OLD.owner_attempt_id)='published' BEGIN SELECT RAISE(ABORT, 'published attempt is immutable'); END;
+CREATE TRIGGER ne19_attachments_sealed_delete BEFORE DELETE ON ne19_attachments WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.owner_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_attachments_attempt_published_delete BEFORE DELETE ON ne19_attachments WHEN OLD.owner_kind='attempt' AND (SELECT publication_state FROM ne19_attempts WHERE origin_run_id=OLD.owner_run_id AND attempt_id=OLD.owner_attempt_id)='published' BEGIN SELECT RAISE(ABORT, 'published attempt is immutable'); END;
+CREATE TRIGGER ne19_references_sealed_insert BEFORE INSERT ON ne19_attachment_references WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=NEW.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_references_sealed_update BEFORE UPDATE ON ne19_attachment_references WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_references_sealed_delete BEFORE DELETE ON ne19_attachment_references WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_items_sealed_insert BEFORE INSERT ON ne19_collection_items WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=NEW.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_items_sealed_update BEFORE UPDATE ON ne19_collection_items WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_items_sealed_delete BEFORE DELETE ON ne19_collection_items WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_contents_sealed_insert BEFORE INSERT ON ne19_contents WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=NEW.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_contents_sealed_update BEFORE UPDATE ON ne19_contents WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_contents_sealed_delete BEFORE DELETE ON ne19_contents WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_chunks_sealed_insert BEFORE INSERT ON ne19_content_chunks WHEN (SELECT r.status 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 WHERE c.content_id=NEW.content_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_chunks_sealed_update BEFORE UPDATE ON ne19_content_chunks WHEN (SELECT r.status 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 WHERE c.content_id=OLD.content_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_chunks_sealed_delete BEFORE DELETE ON ne19_content_chunks WHEN (SELECT r.status 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 WHERE c.content_id=OLD.content_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;
+CREATE TRIGGER ne19_seal_entries_sealed_insert BEFORE INSERT ON ne19_run_seal_entries WHEN (SELECT status FROM ne19_runs WHERE run_id = NEW.run_id) != 'sealing' BEGIN SELECT RAISE(ABORT, 'Seal candidates require sealing state'); END;
+CREATE TRIGGER ne19_seal_entries_sealed_update BEFORE UPDATE ON ne19_run_seal_entries BEGIN SELECT RAISE(ABORT, 'Seal entries are immutable'); END;
+CREATE TRIGGER ne19_seal_entries_sealed_delete BEFORE DELETE ON ne19_run_seal_entries WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'Seal entries are immutable'); END;
 
 
-CREATE TABLE ne18_run_publication_clock (
+CREATE TABLE ne19_run_publication_clock (
   singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
   revision INTEGER NOT NULL CHECK (revision >= 0)
 ) STRICT;
-CREATE TABLE ne18_run_resources (
+CREATE TABLE ne19_run_resources (
   run_id TEXT PRIMARY KEY,
   invocation_id TEXT NOT NULL,
   experiment_id TEXT NOT NULL,
@@ -265,8 +266,8 @@ CREATE TABLE ne18_run_resources (
   CHECK ((terminal_state IS NULL) = (completed_at IS NULL)),
   CHECK ((terminal_state IS NULL) = (close_revision IS NULL))
 ) STRICT;
-CREATE TABLE ne18_run_expected_slots (
-  run_id TEXT NOT NULL REFERENCES ne18_run_resources(run_id) ON DELETE RESTRICT,
+CREATE TABLE ne19_run_expected_slots (
+  run_id TEXT NOT NULL REFERENCES ne19_run_resources(run_id) ON DELETE RESTRICT,
   slot_id TEXT NOT NULL,
   ordinal INTEGER NOT NULL CHECK (ordinal >= 0),
   eval_id TEXT NOT NULL,
@@ -275,7 +276,7 @@ CREATE TABLE ne18_run_expected_slots (
   PRIMARY KEY (run_id, slot_id),
   UNIQUE (run_id, ordinal)
 ) STRICT;
-CREATE TABLE ne18_attempt_publications (
+CREATE TABLE ne19_attempt_publications (
   attempt_id TEXT PRIMARY KEY,
   attempt_locator TEXT NOT NULL CHECK (length(attempt_locator) = 14 AND substr(attempt_locator,1,2) = '@1'),
   origin_run_id TEXT NOT NULL,
@@ -283,31 +284,31 @@ CREATE TABLE ne18_attempt_publications (
   closure_payload BLOB NOT NULL,
   closure_digest TEXT NOT NULL CHECK (length(closure_digest) = 64),
   published_revision INTEGER NOT NULL UNIQUE CHECK (published_revision > 0),
-  FOREIGN KEY (origin_run_id, origin_slot_id) REFERENCES ne18_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT
+  FOREIGN KEY (origin_run_id, origin_slot_id) REFERENCES ne19_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT
 ) STRICT;
-CREATE TABLE ne18_run_slot_bindings (
+CREATE TABLE ne19_run_slot_bindings (
   target_run_id TEXT NOT NULL,
   slot_id TEXT NOT NULL,
-  attempt_id TEXT NOT NULL REFERENCES ne18_attempt_publications(attempt_id) ON DELETE RESTRICT,
+  attempt_id TEXT NOT NULL REFERENCES ne19_attempt_publications(attempt_id) ON DELETE RESTRICT,
   origin_run_id TEXT NOT NULL,
   origin_slot_id TEXT NOT NULL,
   attempt_publication_revision INTEGER NOT NULL CHECK (attempt_publication_revision > 0),
   action TEXT NOT NULL CHECK (action IN ('executed','carried','accepted')),
   binding_revision INTEGER NOT NULL UNIQUE CHECK (binding_revision > 0),
   PRIMARY KEY (target_run_id, slot_id),
-  FOREIGN KEY (target_run_id, slot_id) REFERENCES ne18_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT,
-  FOREIGN KEY (origin_run_id, origin_slot_id) REFERENCES ne18_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT
+  FOREIGN KEY (target_run_id, slot_id) REFERENCES ne19_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT,
+  FOREIGN KEY (origin_run_id, origin_slot_id) REFERENCES ne19_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT
 ) STRICT;
-CREATE TABLE ne18_run_slot_absences (
+CREATE TABLE ne19_run_slot_absences (
   run_id TEXT NOT NULL,
   slot_id TEXT NOT NULL,
   reason TEXT NOT NULL CHECK (reason IN ('early-exit-satisfied','budget-exhausted','stopped-by-failure','interrupted-before-publication','dispatch-failed')),
   absence_revision INTEGER NOT NULL CHECK (absence_revision > 0),
   PRIMARY KEY (run_id, slot_id),
-  FOREIGN KEY (run_id, slot_id) REFERENCES ne18_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT
+  FOREIGN KEY (run_id, slot_id) REFERENCES ne19_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT
 ) STRICT;
-CREATE TABLE ne18_run_recoveries (
-  run_id TEXT PRIMARY KEY REFERENCES ne18_run_resources(run_id) ON DELETE RESTRICT,
+CREATE TABLE ne19_run_recoveries (
+  run_id TEXT PRIMARY KEY REFERENCES ne19_run_resources(run_id) ON DELETE RESTRICT,
   previous_writer_generation TEXT NOT NULL,
   recovery_writer_generation TEXT NOT NULL,
   evidence_kind TEXT NOT NULL,
@@ -315,22 +316,25 @@ CREATE TABLE ne18_run_recoveries (
   evidence_observed_at TEXT NOT NULL,
   recovery_revision INTEGER NOT NULL UNIQUE CHECK (recovery_revision > 0)
 ) STRICT;
-CREATE TABLE ne18_run_deletion_tombstones (
-  run_id TEXT PRIMARY KEY REFERENCES ne18_run_resources(run_id) ON DELETE RESTRICT,
+CREATE TABLE ne19_run_deletion_tombstones (
+  run_id TEXT PRIMARY KEY REFERENCES ne19_run_resources(run_id) ON DELETE RESTRICT,
   terminal_state TEXT NOT NULL CHECK (terminal_state IN ('completed','interrupted','failed')),
   deleted_at TEXT NOT NULL,
   deletion_revision INTEGER NOT NULL UNIQUE CHECK (deletion_revision > 0)
 ) STRICT;
-CREATE INDEX ne18_run_resources_list ON ne18_run_resources(created_revision, run_id);
-CREATE INDEX ne18_run_resources_invocation ON ne18_run_resources(invocation_id, created_revision, run_id);
-CREATE INDEX ne18_attempt_publications_origin ON ne18_attempt_publications(origin_run_id, origin_slot_id);
-CREATE INDEX ne18_attempt_publications_locator ON ne18_attempt_publications(attempt_locator, origin_run_id, attempt_id);
-CREATE INDEX ne18_run_slot_bindings_attempt ON ne18_run_slot_bindings(attempt_id, target_run_id, slot_id);
-CREATE INDEX ne18_run_deletion_revision ON ne18_run_deletion_tombstones(deletion_revision, run_id);
-INSERT INTO ne18_run_publication_clock(singleton,revision) VALUES (1,0);
+CREATE INDEX ne19_runs_experiment ON ne19_runs(experiment_id,run_id);
+CREATE INDEX ne19_run_resources_experiment ON ne19_run_resources(experiment_id,created_revision,run_id);
+CREATE INDEX ne19_run_expected_slots_position ON ne19_run_expected_slots(eval_id,attempt_ordinal,run_id);
+CREATE INDEX ne19_run_resources_list ON ne19_run_resources(created_revision, run_id);
+CREATE INDEX ne19_run_resources_invocation ON ne19_run_resources(invocation_id, created_revision, run_id);
+CREATE INDEX ne19_attempt_publications_origin ON ne19_attempt_publications(origin_run_id, origin_slot_id);
+CREATE INDEX ne19_attempt_publications_locator ON ne19_attempt_publications(attempt_locator, origin_run_id, attempt_id);
+CREATE INDEX ne19_run_slot_bindings_attempt ON ne19_run_slot_bindings(attempt_id, target_run_id, slot_id);
+CREATE INDEX ne19_run_deletion_revision ON ne19_run_deletion_tombstones(deletion_revision, run_id);
+INSERT INTO ne19_run_publication_clock(singleton,revision) VALUES (1,0);
 
 
-CREATE TABLE ne18_invocation_sessions (
+CREATE TABLE ne19_invocation_sessions (
   invocation_id TEXT PRIMARY KEY,
   state TEXT NOT NULL CHECK (state IN ('active','recovering','completed','interrupted','failed')),
   owner_id TEXT NOT NULL,
@@ -350,25 +354,25 @@ CREATE TABLE ne18_invocation_sessions (
   CHECK (state IN ('active','recovering') OR active_projection IS NULL),
   CHECK ((state = 'recovering') = (recovering_at IS NOT NULL))
 ) STRICT;
-CREATE TABLE ne18_invocation_session_experiments (
-  invocation_id TEXT NOT NULL REFERENCES ne18_invocation_sessions(invocation_id) ON DELETE RESTRICT,
+CREATE TABLE ne19_invocation_session_experiments (
+  invocation_id TEXT NOT NULL REFERENCES ne19_invocation_sessions(invocation_id) ON DELETE RESTRICT,
   experiment_id TEXT NOT NULL,
-  run_id TEXT NOT NULL UNIQUE REFERENCES ne18_run_resources(run_id) ON DELETE RESTRICT,
+  run_id TEXT NOT NULL UNIQUE REFERENCES ne19_run_resources(run_id) ON DELETE RESTRICT,
   ordinal INTEGER NOT NULL CHECK (ordinal >= 0),
   PRIMARY KEY (invocation_id, experiment_id),
   UNIQUE (invocation_id, ordinal)
 ) STRICT;
-CREATE TABLE ne18_invocation_session_queued_attempts (
-  invocation_id TEXT NOT NULL REFERENCES ne18_invocation_sessions(invocation_id) ON DELETE RESTRICT,
+CREATE TABLE ne19_invocation_session_queued_attempts (
+  invocation_id TEXT NOT NULL REFERENCES ne19_invocation_sessions(invocation_id) ON DELETE RESTRICT,
   attempt_id TEXT NOT NULL,
-  run_id TEXT NOT NULL REFERENCES ne18_run_resources(run_id) ON DELETE RESTRICT,
+  run_id TEXT NOT NULL REFERENCES ne19_run_resources(run_id) ON DELETE RESTRICT,
   slot_id TEXT NOT NULL,
   ordinal INTEGER NOT NULL CHECK (ordinal >= 0),
   PRIMARY KEY (invocation_id, attempt_id),
   UNIQUE (invocation_id, ordinal),
-  FOREIGN KEY (run_id, slot_id) REFERENCES ne18_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT
+  FOREIGN KEY (run_id, slot_id) REFERENCES ne19_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT
 ) STRICT;
-CREATE TABLE ne18_case_locks (
+CREATE TABLE ne19_case_locks (
   case_id TEXT PRIMARY KEY,
   owner_id TEXT NOT NULL,
   owner_generation INTEGER NOT NULL CHECK (owner_generation > 0),
@@ -379,11 +383,11 @@ CREATE TABLE ne18_case_locks (
   acquired_at TEXT NOT NULL,
   heartbeat_at TEXT NOT NULL
 ) STRICT;
-CREATE INDEX ne18_invocation_sessions_state ON ne18_invocation_sessions(state, started_at, invocation_id);
-CREATE INDEX ne18_invocation_session_experiments_invocation ON ne18_invocation_session_experiments(invocation_id, ordinal);
-CREATE INDEX ne18_invocation_session_queued_attempts_run ON ne18_invocation_session_queued_attempts(run_id, slot_id);
-CREATE INDEX ne18_case_locks_owner ON ne18_case_locks(owner_id, owner_generation);
-CREATE TABLE ne18_teardown_obligations (
+CREATE INDEX ne19_invocation_sessions_state ON ne19_invocation_sessions(state, started_at, invocation_id);
+CREATE INDEX ne19_invocation_session_experiments_invocation ON ne19_invocation_session_experiments(invocation_id, ordinal);
+CREATE INDEX ne19_invocation_session_queued_attempts_run ON ne19_invocation_session_queued_attempts(run_id, slot_id);
+CREATE INDEX ne19_case_locks_owner ON ne19_case_locks(owner_id, owner_generation);
+CREATE TABLE ne19_teardown_obligations (
   obligation_id TEXT PRIMARY KEY,
   experiment_id TEXT NOT NULL,
   owner_pid INTEGER NOT NULL CHECK (owner_pid > 0),
@@ -392,7 +396,7 @@ CREATE TABLE ne18_teardown_obligations (
   payload BLOB NOT NULL,
   UNIQUE (experiment_id, owner_pid)
 ) STRICT;
-CREATE TABLE ne18_shared_state_generations (
+CREATE TABLE ne19_shared_state_generations (
   state_key TEXT NOT NULL,
   generation INTEGER NOT NULL CHECK (generation > 0),
   parent_generation INTEGER NOT NULL CHECK (parent_generation >= 0),
@@ -406,7 +410,7 @@ CREATE TABLE ne18_shared_state_generations (
   PRIMARY KEY (state_key, generation),
   CHECK (parent_generation = generation - 1)
 ) STRICT;
-CREATE TABLE ne18_kept_sandboxes (
+CREATE TABLE ne19_kept_sandboxes (
   entry_id TEXT PRIMARY KEY,
   provider TEXT NOT NULL,
   sandbox_id TEXT NOT NULL,
@@ -415,8 +419,8 @@ CREATE TABLE ne18_kept_sandboxes (
   payload BLOB NOT NULL,
   UNIQUE (provider, sandbox_id)
 ) STRICT;
-CREATE TABLE ne18_kept_sandbox_operation_leases (
-  entry_id TEXT PRIMARY KEY REFERENCES ne18_kept_sandboxes(entry_id) ON DELETE CASCADE,
+CREATE TABLE ne19_kept_sandbox_operation_leases (
+  entry_id TEXT PRIMARY KEY REFERENCES ne19_kept_sandboxes(entry_id) ON DELETE CASCADE,
   generation INTEGER NOT NULL CHECK (generation > 0),
   token TEXT NOT NULL,
   holder TEXT NOT NULL,
@@ -427,12 +431,12 @@ CREATE TABLE ne18_kept_sandbox_operation_leases (
   acquired_at TEXT NOT NULL,
   ttl_ms INTEGER NOT NULL CHECK (ttl_ms > 0)
 ) STRICT;
-CREATE INDEX ne18_teardown_obligations_experiment ON ne18_teardown_obligations(experiment_id, owner_pid);
-CREATE INDEX ne18_shared_state_generations_head ON ne18_shared_state_generations(state_key, generation DESC);
-CREATE INDEX ne18_kept_sandboxes_kept_at ON ne18_kept_sandboxes(kept_at, entry_id);
+CREATE INDEX ne19_teardown_obligations_experiment ON ne19_teardown_obligations(experiment_id, owner_pid);
+CREATE INDEX ne19_shared_state_generations_head ON ne19_shared_state_generations(state_key, generation DESC);
+CREATE INDEX ne19_kept_sandboxes_kept_at ON ne19_kept_sandboxes(kept_at, entry_id);
 
 
-CREATE TABLE ne18_migration_state (
+CREATE TABLE ne19_migration_state (
   singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
   state TEXT NOT NULL CHECK (state IN ('committed','ready')),
   source_format TEXT,

package/dist/record/sqlite/current-schema.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"current-schema.js","sourceRoot":"","sources":["current-schema.ts"],"names":[],"mappings":";;;AAAA;;;;GAIG;AACU,QAAA,0BAA0B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAibhC,CAAC","sourcesContent":["/**\n * Exact current ProjectDatabase 0.18 schema, independent of frozen historical\n * baselines. Keep these bytes stable within this format: they own its fingerprint.\n * The disjoint namespace fences writers prepared against the 0.17 tables.\n */\nexport const RECORD_SQLITE_BASELINE_SQL = `\nCREATE TABLE ne18_record_metadata (\n  singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n  format TEXT NOT NULL,\n  storage_revision INTEGER NOT NULL CHECK (storage_revision > 0),\n  storage_generation TEXT NOT NULL,\n  schema_fingerprint TEXT NOT NULL CHECK (length(schema_fingerprint) = 64),\n  created_at TEXT NOT NULL,\n  barrier_state TEXT NOT NULL CHECK (barrier_state IN ('open','draining','portable')),\n  portable_generation TEXT,\n  portable_revision INTEGER CHECK (portable_revision IS NULL OR portable_revision >= 0),\n  portable_gate_id TEXT,\n  record_payload BLOB,\n  record_digest TEXT,\n  CHECK ((record_payload IS NULL) = (record_digest IS NULL)),\n  CHECK (record_digest IS NULL OR length(record_digest) = 64),\n  CHECK ((barrier_state = 'portable') = (portable_generation IS NOT NULL)),\n  CHECK ((barrier_state = 'portable') = (portable_revision IS NOT NULL)),\n  CHECK ((barrier_state = 'open') = (portable_gate_id IS NULL))\n) STRICT;\nCREATE TABLE ne18_coordination_state (\n  singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n  revision INTEGER NOT NULL CHECK (revision >= 0),\n  operational_generation TEXT NOT NULL,\n  next_writer_sequence INTEGER NOT NULL CHECK (next_writer_sequence > 0),\n  writer_ticket_id TEXT,\n  writer_sequence INTEGER CHECK (writer_sequence IS NULL OR writer_sequence > 0),\n  writer_host TEXT,\n  writer_pid INTEGER CHECK (writer_pid IS NULL OR writer_pid > 0),\n  writer_boot_id TEXT,\n  writer_process_start TEXT,\n  writer_deadline INTEGER CHECK (writer_deadline IS NULL OR writer_deadline > 0),\n  writer_enqueued_at INTEGER CHECK (writer_enqueued_at IS NULL OR writer_enqueued_at > 0),\n  writer_nonce TEXT,\n  writer_admitted_at INTEGER CHECK (writer_admitted_at IS NULL OR writer_admitted_at > 0),\n  writer_lease_expires_at INTEGER CHECK (writer_lease_expires_at IS NULL OR writer_lease_expires_at > 0),\n  barrier_id TEXT,\n  barrier_nonce TEXT,\n  barrier_host TEXT,\n  barrier_pid INTEGER CHECK (barrier_pid IS NULL OR barrier_pid > 0),\n  barrier_boot_id TEXT,\n  barrier_process_start TEXT,\n  barrier_deadline INTEGER CHECK (barrier_deadline IS NULL OR barrier_deadline > 0),\n  barrier_requested_at INTEGER CHECK (barrier_requested_at IS NULL OR barrier_requested_at > 0),\n  barrier_lease_expires_at INTEGER CHECK (barrier_lease_expires_at IS NULL OR barrier_lease_expires_at > 0),\n  barrier_status TEXT CHECK (barrier_status IS NULL OR barrier_status IN ('requested','active')),\n  barrier_active_at INTEGER CHECK (barrier_active_at IS NULL OR barrier_active_at > 0),\n  CHECK ((writer_ticket_id IS NULL) = (writer_sequence IS NULL)),\n  CHECK ((writer_ticket_id IS NULL) = (writer_host IS NULL)),\n  CHECK ((writer_ticket_id IS NULL) = (writer_pid IS NULL)),\n  CHECK ((writer_ticket_id IS NULL) = (writer_boot_id IS NULL)),\n  CHECK ((writer_ticket_id IS NULL) = (writer_process_start IS NULL)),\n  CHECK ((writer_ticket_id IS NULL) = (writer_deadline IS NULL)),\n  CHECK ((writer_ticket_id IS NULL) = (writer_enqueued_at IS NULL)),\n  CHECK ((writer_ticket_id IS NULL) = (writer_nonce IS NULL)),\n  CHECK ((writer_ticket_id IS NULL) = (writer_admitted_at IS NULL)),\n  CHECK ((writer_ticket_id IS NULL) = (writer_lease_expires_at IS NULL)),\n  CHECK ((barrier_id IS NULL) = (barrier_nonce IS NULL)),\n  CHECK ((barrier_id IS NULL) = (barrier_host IS NULL)),\n  CHECK ((barrier_id IS NULL) = (barrier_pid IS NULL)),\n  CHECK ((barrier_id IS NULL) = (barrier_boot_id IS NULL)),\n  CHECK ((barrier_id IS NULL) = (barrier_process_start IS NULL)),\n  CHECK ((barrier_id IS NULL) = (barrier_deadline IS NULL)),\n  CHECK ((barrier_id IS NULL) = (barrier_requested_at IS NULL)),\n  CHECK ((barrier_id IS NULL) = (barrier_lease_expires_at IS NULL)),\n  CHECK ((barrier_id IS NULL) = (barrier_status IS NULL)),\n  CHECK (\n    (barrier_status IS NULL AND barrier_active_at IS NULL) OR\n    (barrier_status = 'requested' AND barrier_active_at IS NULL) OR\n    (barrier_status = 'active' AND barrier_active_at IS NOT NULL)\n  )\n) STRICT;\nCREATE TABLE ne18_coordination_tickets (\n  ticket_id TEXT PRIMARY KEY,\n  sequence INTEGER NOT NULL UNIQUE CHECK (sequence > 0),\n  host TEXT NOT NULL,\n  pid INTEGER NOT NULL CHECK (pid > 0),\n  boot_id TEXT NOT NULL,\n  process_start TEXT NOT NULL,\n  deadline INTEGER NOT NULL CHECK (deadline > 0),\n  enqueued_at INTEGER NOT NULL CHECK (enqueued_at > 0)\n) STRICT;\nCREATE TABLE ne18_runs (\n  run_id TEXT PRIMARY KEY,\n  status TEXT NOT NULL CHECK (status IN ('open','sealing','sealed')),\n  writer_generation TEXT NOT NULL,\n  started_at TEXT NOT NULL,\n  core_payload BLOB,\n  core_digest TEXT CHECK (core_digest IS NULL OR length(core_digest) = 64),\n  mutation_sequence INTEGER NOT NULL DEFAULT 0 CHECK (mutation_sequence >= 0),\n  candidate_seal_identity TEXT CHECK (candidate_seal_identity IS NULL OR length(candidate_seal_identity) = 64),\n  candidate_seal_entry_count INTEGER CHECK (candidate_seal_entry_count IS NULL OR candidate_seal_entry_count >= 0),\n  candidate_seal_staged_count INTEGER NOT NULL DEFAULT 0 CHECK (candidate_seal_staged_count >= 0),\n  logical_seal_identity TEXT,\n  CHECK ((core_payload IS NULL) = (core_digest IS NULL)),\n  CHECK ((candidate_seal_identity IS NULL) = (candidate_seal_entry_count IS NULL)),\n  CHECK ((status = 'open') = (candidate_seal_identity IS NULL)),\n  CHECK (candidate_seal_entry_count IS NULL OR candidate_seal_staged_count <= candidate_seal_entry_count),\n  CHECK (status != 'open' OR candidate_seal_staged_count = 0),\n  CHECK ((status = 'sealed') = (logical_seal_identity IS NOT NULL)),\n  CHECK (status = 'open' OR core_payload IS NOT NULL)\n) STRICT;\nCREATE TABLE ne18_slots (\n  run_id TEXT NOT NULL REFERENCES ne18_runs(run_id) ON DELETE CASCADE,\n  slot_id TEXT NOT NULL,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  core_payload BLOB NOT NULL,\n  core_digest TEXT NOT NULL CHECK (length(core_digest) = 64),\n  PRIMARY KEY (run_id, slot_id),\n  UNIQUE (run_id, ordinal)\n) STRICT;\nCREATE TABLE ne18_attempts (\n  origin_run_id TEXT NOT NULL REFERENCES ne18_runs(run_id) ON DELETE CASCADE,\n  attempt_id TEXT NOT NULL,\n  attempt_locator TEXT NOT NULL CHECK (length(attempt_locator) = 14 AND substr(attempt_locator,1,2) = '@1'),\n  publication_state TEXT NOT NULL DEFAULT 'staging' CHECK (publication_state IN ('staging','sealing','published')),\n  core_payload BLOB,\n  core_digest TEXT CHECK (core_digest IS NULL OR length(core_digest) = 64),\n  CHECK ((core_payload IS NULL) = (core_digest IS NULL)),\n  PRIMARY KEY (origin_run_id, attempt_id)\n) STRICT;\nCREATE TABLE ne18_members (\n  target_run_id TEXT NOT NULL,\n  slot_id TEXT NOT NULL,\n  origin_run_id TEXT,\n  attempt_id TEXT,\n  action TEXT NOT NULL CHECK (action IN ('executed','carried','accepted','not-dispatched','interrupted')),\n  core_payload BLOB NOT NULL,\n  core_digest TEXT NOT NULL CHECK (length(core_digest) = 64),\n  PRIMARY KEY (target_run_id, slot_id),\n  CHECK (\n    (action IN ('executed','carried','accepted') AND origin_run_id IS NOT NULL AND attempt_id IS NOT NULL) OR\n    (action IN ('not-dispatched','interrupted') AND origin_run_id IS NULL AND attempt_id IS NULL)\n  ),\n  FOREIGN KEY (target_run_id, slot_id) REFERENCES ne18_slots(run_id, slot_id) ON DELETE CASCADE\n) STRICT;\nCREATE TABLE ne18_attachments (\n  attachment_id TEXT PRIMARY KEY,\n  owner_kind TEXT NOT NULL CHECK (owner_kind IN ('run','attempt')),\n  owner_run_id TEXT NOT NULL REFERENCES ne18_runs(run_id) ON DELETE CASCADE,\n  owner_attempt_id TEXT,\n  family TEXT NOT NULL,\n  family_revision INTEGER NOT NULL CHECK (family_revision > 0),\n  logical_identity TEXT,\n  canonical_payload BLOB,\n  canonical_digest TEXT CHECK (canonical_digest IS NULL OR length(canonical_digest) = 64),\n  logical_inventory BLOB,\n  inventory_digest TEXT CHECK (inventory_digest IS NULL OR length(inventory_digest) = 64),\n  CHECK ((canonical_payload IS NULL) = (canonical_digest IS NULL)),\n  CHECK ((logical_inventory IS NULL) = (inventory_digest IS NULL)),\n  CHECK ((owner_kind = 'run' AND owner_attempt_id IS NULL) OR (owner_kind = 'attempt' AND owner_attempt_id IS NOT NULL)),\n  UNIQUE (owner_kind, owner_run_id, owner_attempt_id, family),\n  FOREIGN KEY (owner_run_id, owner_attempt_id) REFERENCES ne18_attempts(origin_run_id, attempt_id) ON DELETE CASCADE\n) STRICT;\nCREATE TABLE ne18_attachment_references (\n  attachment_id TEXT NOT NULL REFERENCES ne18_attachments(attachment_id) ON DELETE CASCADE,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  target_owner_kind TEXT NOT NULL CHECK (target_owner_kind IN ('run','attempt')),\n  target_family TEXT NOT NULL,\n  canonical_payload BLOB NOT NULL,\n  reference_digest TEXT NOT NULL CHECK (length(reference_digest) = 64),\n  PRIMARY KEY (attachment_id, ordinal)\n) STRICT;\nCREATE TABLE ne18_collection_items (\n  attachment_id TEXT NOT NULL REFERENCES ne18_attachments(attachment_id) ON DELETE CASCADE,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  logical_identity TEXT NOT NULL,\n  canonical_payload BLOB NOT NULL,\n  canonical_digest TEXT NOT NULL CHECK (length(canonical_digest) = 64),\n  PRIMARY KEY (attachment_id, ordinal),\n  UNIQUE (attachment_id, logical_identity)\n) STRICT;\nCREATE TABLE ne18_contents (\n  content_id TEXT PRIMARY KEY,\n  attachment_id TEXT NOT NULL REFERENCES ne18_attachments(attachment_id) ON DELETE CASCADE,\n  logical_handle TEXT NOT NULL,\n  byte_length INTEGER CHECK (byte_length IS NULL OR byte_length >= 0),\n  overall_digest TEXT CHECK (overall_digest IS NULL OR length(overall_digest) = 64),\n  chunk_count INTEGER CHECK (chunk_count IS NULL OR chunk_count >= 0),\n  CHECK ((byte_length IS NULL) = (overall_digest IS NULL) AND (overall_digest IS NULL) = (chunk_count IS NULL)),\n  UNIQUE (attachment_id, logical_handle)\n) STRICT;\nCREATE TABLE ne18_content_chunks (\n  content_id TEXT NOT NULL REFERENCES ne18_contents(content_id) ON DELETE CASCADE,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  bytes BLOB NOT NULL CHECK (length(bytes) <= 262144),\n  chunk_digest TEXT NOT NULL CHECK (length(chunk_digest) = 64),\n  PRIMARY KEY (content_id, ordinal)\n) STRICT;\nCREATE TABLE ne18_run_seal_entries (\n  run_id TEXT NOT NULL REFERENCES ne18_runs(run_id) ON DELETE CASCADE,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  entry_kind TEXT NOT NULL CHECK (entry_kind IN ('record','run','slot','member','attempt','attachment','attachment-reference','collection-item','content','content-chunk')),\n  logical_identity TEXT NOT NULL,\n  digest TEXT NOT NULL CHECK (length(digest) = 64),\n  PRIMARY KEY (run_id, ordinal),\n  UNIQUE (run_id, entry_kind, logical_identity)\n) STRICT;\nCREATE INDEX ne18_attachments_owner_family ON ne18_attachments(owner_kind, owner_run_id, owner_attempt_id, family);\nCREATE UNIQUE INDEX ne18_attachments_owner_family_unique ON ne18_attachments(owner_kind, owner_run_id, coalesce(owner_attempt_id,''), family);\nCREATE INDEX ne18_members_origin_attempt ON ne18_members(origin_run_id, attempt_id, target_run_id);\nCREATE INDEX ne18_attempts_locator ON ne18_attempts(attempt_locator, origin_run_id, attempt_id);\nCREATE INDEX ne18_references_target_family ON ne18_attachment_references(target_owner_kind, target_family);\nCREATE INDEX ne18_content_chunks_page ON ne18_content_chunks(content_id, ordinal);\nCREATE INDEX ne18_coordination_tickets_fifo ON ne18_coordination_tickets(sequence);\nCREATE TRIGGER ne18_coordination_ticket_barrier_insert BEFORE INSERT ON ne18_coordination_tickets WHEN (SELECT barrier_state FROM ne18_record_metadata WHERE singleton=1)!='open' BEGIN SELECT RAISE(ABORT, 'ProjectDatabase writer barrier is not open'); END;\nCREATE TRIGGER ne18_coordination_writer_barrier_update BEFORE UPDATE ON ne18_coordination_state WHEN NEW.writer_ticket_id IS NOT NULL AND (SELECT barrier_state FROM ne18_record_metadata WHERE singleton=1)!='open' BEGIN SELECT RAISE(ABORT, 'ProjectDatabase writer barrier is not open'); END;\nCREATE TRIGGER ne18_runs_sealed_update BEFORE UPDATE ON ne18_runs WHEN OLD.status = 'sealed' BEGIN SELECT RAISE(ABORT, 'sealed run is immutable'); END;\nCREATE TRIGGER ne18_runs_sealed_delete BEFORE DELETE ON ne18_runs WHEN OLD.status = 'sealed' BEGIN SELECT RAISE(ABORT, 'sealed run is immutable'); END;\nCREATE TRIGGER ne18_slots_sealed_insert BEFORE INSERT ON ne18_slots WHEN (SELECT status FROM ne18_runs WHERE run_id = NEW.run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_slots_sealed_update BEFORE UPDATE ON ne18_slots WHEN (SELECT status FROM ne18_runs WHERE run_id = OLD.run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_slots_sealed_delete BEFORE DELETE ON ne18_slots WHEN (SELECT status FROM ne18_runs WHERE run_id = OLD.run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_attempts_sealed_insert BEFORE INSERT ON ne18_attempts WHEN (SELECT status FROM ne18_runs WHERE run_id = NEW.origin_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_attempts_sealed_update BEFORE UPDATE ON ne18_attempts WHEN (SELECT status FROM ne18_runs WHERE run_id = OLD.origin_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_attempts_sealed_delete BEFORE DELETE ON ne18_attempts WHEN (SELECT status FROM ne18_runs WHERE run_id = OLD.origin_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_members_sealed_insert BEFORE INSERT ON ne18_members WHEN (SELECT status FROM ne18_runs WHERE run_id = NEW.target_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_members_sealed_update BEFORE UPDATE ON ne18_members WHEN (SELECT status FROM ne18_runs WHERE run_id = OLD.target_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_members_sealed_delete BEFORE DELETE ON ne18_members WHEN (SELECT status FROM ne18_runs WHERE run_id = OLD.target_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_attachments_sealed_insert BEFORE INSERT ON ne18_attachments WHEN (SELECT status FROM ne18_runs WHERE run_id = NEW.owner_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_attachments_attempt_published_insert BEFORE INSERT ON ne18_attachments WHEN NEW.owner_kind='attempt' AND (SELECT publication_state FROM ne18_attempts WHERE origin_run_id=NEW.owner_run_id AND attempt_id=NEW.owner_attempt_id)='published' BEGIN SELECT RAISE(ABORT, 'published attempt is immutable'); END;\nCREATE TRIGGER ne18_attachments_sealed_update BEFORE UPDATE ON ne18_attachments WHEN (SELECT status FROM ne18_runs WHERE run_id = OLD.owner_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_attachments_attempt_published_update BEFORE UPDATE ON ne18_attachments WHEN OLD.owner_kind='attempt' AND (SELECT publication_state FROM ne18_attempts WHERE origin_run_id=OLD.owner_run_id AND attempt_id=OLD.owner_attempt_id)='published' BEGIN SELECT RAISE(ABORT, 'published attempt is immutable'); END;\nCREATE TRIGGER ne18_attachments_sealed_delete BEFORE DELETE ON ne18_attachments WHEN (SELECT status FROM ne18_runs WHERE run_id = OLD.owner_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_attachments_attempt_published_delete BEFORE DELETE ON ne18_attachments WHEN OLD.owner_kind='attempt' AND (SELECT publication_state FROM ne18_attempts WHERE origin_run_id=OLD.owner_run_id AND attempt_id=OLD.owner_attempt_id)='published' BEGIN SELECT RAISE(ABORT, 'published attempt is immutable'); END;\nCREATE TRIGGER ne18_references_sealed_insert BEFORE INSERT ON ne18_attachment_references WHEN (SELECT r.status FROM ne18_attachments a JOIN ne18_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=NEW.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_references_sealed_update BEFORE UPDATE ON ne18_attachment_references WHEN (SELECT r.status FROM ne18_attachments a JOIN ne18_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_references_sealed_delete BEFORE DELETE ON ne18_attachment_references WHEN (SELECT r.status FROM ne18_attachments a JOIN ne18_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_items_sealed_insert BEFORE INSERT ON ne18_collection_items WHEN (SELECT r.status FROM ne18_attachments a JOIN ne18_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=NEW.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_items_sealed_update BEFORE UPDATE ON ne18_collection_items WHEN (SELECT r.status FROM ne18_attachments a JOIN ne18_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_items_sealed_delete BEFORE DELETE ON ne18_collection_items WHEN (SELECT r.status FROM ne18_attachments a JOIN ne18_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_contents_sealed_insert BEFORE INSERT ON ne18_contents WHEN (SELECT r.status FROM ne18_attachments a JOIN ne18_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=NEW.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_contents_sealed_update BEFORE UPDATE ON ne18_contents WHEN (SELECT r.status FROM ne18_attachments a JOIN ne18_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_contents_sealed_delete BEFORE DELETE ON ne18_contents WHEN (SELECT r.status FROM ne18_attachments a JOIN ne18_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_chunks_sealed_insert BEFORE INSERT ON ne18_content_chunks WHEN (SELECT r.status 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 WHERE c.content_id=NEW.content_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_chunks_sealed_update BEFORE UPDATE ON ne18_content_chunks WHEN (SELECT r.status 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 WHERE c.content_id=OLD.content_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_chunks_sealed_delete BEFORE DELETE ON ne18_content_chunks WHEN (SELECT r.status 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 WHERE c.content_id=OLD.content_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne18_seal_entries_sealed_insert BEFORE INSERT ON ne18_run_seal_entries WHEN (SELECT status FROM ne18_runs WHERE run_id = NEW.run_id) != 'sealing' BEGIN SELECT RAISE(ABORT, 'Seal candidates require sealing state'); END;\nCREATE TRIGGER ne18_seal_entries_sealed_update BEFORE UPDATE ON ne18_run_seal_entries BEGIN SELECT RAISE(ABORT, 'Seal entries are immutable'); END;\nCREATE TRIGGER ne18_seal_entries_sealed_delete BEFORE DELETE ON ne18_run_seal_entries WHEN (SELECT status FROM ne18_runs WHERE run_id = OLD.run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'Seal entries are immutable'); END;\n\n\nCREATE TABLE ne18_run_publication_clock (\n  singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n  revision INTEGER NOT NULL CHECK (revision >= 0)\n) STRICT;\nCREATE TABLE ne18_run_resources (\n  run_id TEXT PRIMARY KEY,\n  invocation_id TEXT NOT NULL,\n  experiment_id TEXT NOT NULL,\n  started_at TEXT NOT NULL,\n  initial_writer_generation TEXT NOT NULL,\n  current_writer_generation TEXT NOT NULL,\n  terminal_state TEXT CHECK (terminal_state IS NULL OR terminal_state IN ('completed','interrupted','failed')),\n  completed_at TEXT,\n  created_revision INTEGER NOT NULL UNIQUE CHECK (created_revision > 0),\n  close_revision INTEGER UNIQUE CHECK (close_revision IS NULL OR close_revision > created_revision),\n  CHECK ((terminal_state IS NULL) = (completed_at IS NULL)),\n  CHECK ((terminal_state IS NULL) = (close_revision IS NULL))\n) STRICT;\nCREATE TABLE ne18_run_expected_slots (\n  run_id TEXT NOT NULL REFERENCES ne18_run_resources(run_id) ON DELETE RESTRICT,\n  slot_id TEXT NOT NULL,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  eval_id TEXT NOT NULL,\n  attempt_ordinal INTEGER NOT NULL CHECK (attempt_ordinal >= 0),\n  execution_identity_digest TEXT NOT NULL CHECK (length(execution_identity_digest) = 64),\n  PRIMARY KEY (run_id, slot_id),\n  UNIQUE (run_id, ordinal)\n) STRICT;\nCREATE TABLE ne18_attempt_publications (\n  attempt_id TEXT PRIMARY KEY,\n  attempt_locator TEXT NOT NULL CHECK (length(attempt_locator) = 14 AND substr(attempt_locator,1,2) = '@1'),\n  origin_run_id TEXT NOT NULL,\n  origin_slot_id TEXT NOT NULL,\n  closure_payload BLOB NOT NULL,\n  closure_digest TEXT NOT NULL CHECK (length(closure_digest) = 64),\n  published_revision INTEGER NOT NULL UNIQUE CHECK (published_revision > 0),\n  FOREIGN KEY (origin_run_id, origin_slot_id) REFERENCES ne18_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT\n) STRICT;\nCREATE TABLE ne18_run_slot_bindings (\n  target_run_id TEXT NOT NULL,\n  slot_id TEXT NOT NULL,\n  attempt_id TEXT NOT NULL REFERENCES ne18_attempt_publications(attempt_id) ON DELETE RESTRICT,\n  origin_run_id TEXT NOT NULL,\n  origin_slot_id TEXT NOT NULL,\n  attempt_publication_revision INTEGER NOT NULL CHECK (attempt_publication_revision > 0),\n  action TEXT NOT NULL CHECK (action IN ('executed','carried','accepted')),\n  binding_revision INTEGER NOT NULL UNIQUE CHECK (binding_revision > 0),\n  PRIMARY KEY (target_run_id, slot_id),\n  FOREIGN KEY (target_run_id, slot_id) REFERENCES ne18_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT,\n  FOREIGN KEY (origin_run_id, origin_slot_id) REFERENCES ne18_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT\n) STRICT;\nCREATE TABLE ne18_run_slot_absences (\n  run_id TEXT NOT NULL,\n  slot_id TEXT NOT NULL,\n  reason TEXT NOT NULL CHECK (reason IN ('early-exit-satisfied','budget-exhausted','stopped-by-failure','interrupted-before-publication','dispatch-failed')),\n  absence_revision INTEGER NOT NULL CHECK (absence_revision > 0),\n  PRIMARY KEY (run_id, slot_id),\n  FOREIGN KEY (run_id, slot_id) REFERENCES ne18_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT\n) STRICT;\nCREATE TABLE ne18_run_recoveries (\n  run_id TEXT PRIMARY KEY REFERENCES ne18_run_resources(run_id) ON DELETE RESTRICT,\n  previous_writer_generation TEXT NOT NULL,\n  recovery_writer_generation TEXT NOT NULL,\n  evidence_kind TEXT NOT NULL,\n  evidence_identity TEXT NOT NULL,\n  evidence_observed_at TEXT NOT NULL,\n  recovery_revision INTEGER NOT NULL UNIQUE CHECK (recovery_revision > 0)\n) STRICT;\nCREATE TABLE ne18_run_deletion_tombstones (\n  run_id TEXT PRIMARY KEY REFERENCES ne18_run_resources(run_id) ON DELETE RESTRICT,\n  terminal_state TEXT NOT NULL CHECK (terminal_state IN ('completed','interrupted','failed')),\n  deleted_at TEXT NOT NULL,\n  deletion_revision INTEGER NOT NULL UNIQUE CHECK (deletion_revision > 0)\n) STRICT;\nCREATE INDEX ne18_run_resources_list ON ne18_run_resources(created_revision, run_id);\nCREATE INDEX ne18_run_resources_invocation ON ne18_run_resources(invocation_id, created_revision, run_id);\nCREATE INDEX ne18_attempt_publications_origin ON ne18_attempt_publications(origin_run_id, origin_slot_id);\nCREATE INDEX ne18_attempt_publications_locator ON ne18_attempt_publications(attempt_locator, origin_run_id, attempt_id);\nCREATE INDEX ne18_run_slot_bindings_attempt ON ne18_run_slot_bindings(attempt_id, target_run_id, slot_id);\nCREATE INDEX ne18_run_deletion_revision ON ne18_run_deletion_tombstones(deletion_revision, run_id);\nINSERT INTO ne18_run_publication_clock(singleton,revision) VALUES (1,0);\n\n\nCREATE TABLE ne18_invocation_sessions (\n  invocation_id TEXT PRIMARY KEY,\n  state TEXT NOT NULL CHECK (state IN ('active','recovering','completed','interrupted','failed')),\n  owner_id TEXT NOT NULL,\n  owner_generation INTEGER NOT NULL CHECK (owner_generation > 0),\n  owner_host TEXT NOT NULL,\n  owner_pid INTEGER NOT NULL CHECK (owner_pid > 0),\n  owner_boot_id TEXT NOT NULL,\n  owner_process_start TEXT NOT NULL,\n  started_at TEXT NOT NULL,\n  heartbeat_at TEXT NOT NULL,\n  active_projection BLOB,\n  recovering_at TEXT,\n  closed_at TEXT,\n  terminal_projection BLOB,\n  CHECK ((state IN ('completed','interrupted','failed')) = (closed_at IS NOT NULL)),\n  CHECK ((state IN ('completed','interrupted','failed')) = (terminal_projection IS NOT NULL)),\n  CHECK (state IN ('active','recovering') OR active_projection IS NULL),\n  CHECK ((state = 'recovering') = (recovering_at IS NOT NULL))\n) STRICT;\nCREATE TABLE ne18_invocation_session_experiments (\n  invocation_id TEXT NOT NULL REFERENCES ne18_invocation_sessions(invocation_id) ON DELETE RESTRICT,\n  experiment_id TEXT NOT NULL,\n  run_id TEXT NOT NULL UNIQUE REFERENCES ne18_run_resources(run_id) ON DELETE RESTRICT,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  PRIMARY KEY (invocation_id, experiment_id),\n  UNIQUE (invocation_id, ordinal)\n) STRICT;\nCREATE TABLE ne18_invocation_session_queued_attempts (\n  invocation_id TEXT NOT NULL REFERENCES ne18_invocation_sessions(invocation_id) ON DELETE RESTRICT,\n  attempt_id TEXT NOT NULL,\n  run_id TEXT NOT NULL REFERENCES ne18_run_resources(run_id) ON DELETE RESTRICT,\n  slot_id TEXT NOT NULL,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  PRIMARY KEY (invocation_id, attempt_id),\n  UNIQUE (invocation_id, ordinal),\n  FOREIGN KEY (run_id, slot_id) REFERENCES ne18_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT\n) STRICT;\nCREATE TABLE ne18_case_locks (\n  case_id TEXT PRIMARY KEY,\n  owner_id TEXT NOT NULL,\n  owner_generation INTEGER NOT NULL CHECK (owner_generation > 0),\n  owner_host TEXT NOT NULL,\n  owner_pid INTEGER NOT NULL CHECK (owner_pid > 0),\n  owner_boot_id TEXT NOT NULL,\n  owner_process_start TEXT NOT NULL,\n  acquired_at TEXT NOT NULL,\n  heartbeat_at TEXT NOT NULL\n) STRICT;\nCREATE INDEX ne18_invocation_sessions_state ON ne18_invocation_sessions(state, started_at, invocation_id);\nCREATE INDEX ne18_invocation_session_experiments_invocation ON ne18_invocation_session_experiments(invocation_id, ordinal);\nCREATE INDEX ne18_invocation_session_queued_attempts_run ON ne18_invocation_session_queued_attempts(run_id, slot_id);\nCREATE INDEX ne18_case_locks_owner ON ne18_case_locks(owner_id, owner_generation);\nCREATE TABLE ne18_teardown_obligations (\n  obligation_id TEXT PRIMARY KEY,\n  experiment_id TEXT NOT NULL,\n  owner_pid INTEGER NOT NULL CHECK (owner_pid > 0),\n  owner_host TEXT NOT NULL,\n  generation INTEGER NOT NULL DEFAULT 1 CHECK (generation > 0),\n  payload BLOB NOT NULL,\n  UNIQUE (experiment_id, owner_pid)\n) STRICT;\nCREATE TABLE ne18_shared_state_generations (\n  state_key TEXT NOT NULL,\n  generation INTEGER NOT NULL CHECK (generation > 0),\n  parent_generation INTEGER NOT NULL CHECK (parent_generation >= 0),\n  state_kind TEXT NOT NULL CHECK (state_kind IN ('active','recovering','free')),\n  owner_token TEXT NOT NULL,\n  owner_pid INTEGER NOT NULL CHECK (owner_pid > 0),\n  owner_host TEXT NOT NULL,\n  owner_process_identity TEXT NOT NULL,\n  heartbeat_at TEXT NOT NULL,\n  payload BLOB NOT NULL,\n  PRIMARY KEY (state_key, generation),\n  CHECK (parent_generation = generation - 1)\n) STRICT;\nCREATE TABLE ne18_kept_sandboxes (\n  entry_id TEXT PRIMARY KEY,\n  provider TEXT NOT NULL,\n  sandbox_id TEXT NOT NULL,\n  kept_at TEXT NOT NULL,\n  operation_generation INTEGER NOT NULL DEFAULT 0 CHECK (operation_generation >= 0),\n  payload BLOB NOT NULL,\n  UNIQUE (provider, sandbox_id)\n) STRICT;\nCREATE TABLE ne18_kept_sandbox_operation_leases (\n  entry_id TEXT PRIMARY KEY REFERENCES ne18_kept_sandboxes(entry_id) ON DELETE CASCADE,\n  generation INTEGER NOT NULL CHECK (generation > 0),\n  token TEXT NOT NULL,\n  holder TEXT NOT NULL,\n  owner_pid INTEGER NOT NULL CHECK (owner_pid > 0),\n  owner_host TEXT NOT NULL,\n  owner_process_identity TEXT NOT NULL,\n  operation TEXT NOT NULL,\n  acquired_at TEXT NOT NULL,\n  ttl_ms INTEGER NOT NULL CHECK (ttl_ms > 0)\n) STRICT;\nCREATE INDEX ne18_teardown_obligations_experiment ON ne18_teardown_obligations(experiment_id, owner_pid);\nCREATE INDEX ne18_shared_state_generations_head ON ne18_shared_state_generations(state_key, generation DESC);\nCREATE INDEX ne18_kept_sandboxes_kept_at ON ne18_kept_sandboxes(kept_at, entry_id);\n\n\nCREATE TABLE ne18_migration_state (\n  singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n  state TEXT NOT NULL CHECK (state IN ('committed','ready')),\n  source_format TEXT,\n  source_digest TEXT CHECK (source_digest IS NULL OR length(source_digest) = 64),\n  CHECK ((source_format IS NULL) = (source_digest IS NULL)),\n  CHECK (state != 'committed' OR source_format IS NOT NULL)\n) STRICT;`;\n"]}
+{"version":3,"file":"current-schema.js","sourceRoot":"","sources":["current-schema.ts"],"names":[],"mappings":";;;AAAA;;;;GAIG;AACU,QAAA,0BAA0B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAqbhC,CAAC","sourcesContent":["/**\n * Exact current ProjectDatabase 0.19 schema, independent of frozen historical\n * baselines. Keep these bytes stable within this format: they own its fingerprint.\n * The disjoint namespace fences writers prepared against the 0.18 tables.\n */\nexport const RECORD_SQLITE_BASELINE_SQL = `\nCREATE TABLE ne19_record_metadata (\n  singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n  format TEXT NOT NULL,\n  storage_revision INTEGER NOT NULL CHECK (storage_revision > 0),\n  storage_generation TEXT NOT NULL,\n  schema_fingerprint TEXT NOT NULL CHECK (length(schema_fingerprint) = 64),\n  created_at TEXT NOT NULL,\n  barrier_state TEXT NOT NULL CHECK (barrier_state IN ('open','draining','portable')),\n  portable_generation TEXT,\n  portable_revision INTEGER CHECK (portable_revision IS NULL OR portable_revision >= 0),\n  portable_gate_id TEXT,\n  record_payload BLOB,\n  record_digest TEXT,\n  CHECK ((record_payload IS NULL) = (record_digest IS NULL)),\n  CHECK (record_digest IS NULL OR length(record_digest) = 64),\n  CHECK ((barrier_state = 'portable') = (portable_generation IS NOT NULL)),\n  CHECK ((barrier_state = 'portable') = (portable_revision IS NOT NULL)),\n  CHECK ((barrier_state = 'open') = (portable_gate_id IS NULL))\n) STRICT;\nCREATE TABLE ne19_coordination_state (\n  singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n  revision INTEGER NOT NULL CHECK (revision >= 0),\n  operational_generation TEXT NOT NULL,\n  next_writer_sequence INTEGER NOT NULL CHECK (next_writer_sequence > 0),\n  writer_ticket_id TEXT,\n  writer_sequence INTEGER CHECK (writer_sequence IS NULL OR writer_sequence > 0),\n  writer_host TEXT,\n  writer_pid INTEGER CHECK (writer_pid IS NULL OR writer_pid > 0),\n  writer_boot_id TEXT,\n  writer_process_start TEXT,\n  writer_deadline INTEGER CHECK (writer_deadline IS NULL OR writer_deadline > 0),\n  writer_enqueued_at INTEGER CHECK (writer_enqueued_at IS NULL OR writer_enqueued_at > 0),\n  writer_nonce TEXT,\n  writer_admitted_at INTEGER CHECK (writer_admitted_at IS NULL OR writer_admitted_at > 0),\n  writer_lease_expires_at INTEGER CHECK (writer_lease_expires_at IS NULL OR writer_lease_expires_at > 0),\n  barrier_id TEXT,\n  barrier_nonce TEXT,\n  barrier_host TEXT,\n  barrier_pid INTEGER CHECK (barrier_pid IS NULL OR barrier_pid > 0),\n  barrier_boot_id TEXT,\n  barrier_process_start TEXT,\n  barrier_deadline INTEGER CHECK (barrier_deadline IS NULL OR barrier_deadline > 0),\n  barrier_requested_at INTEGER CHECK (barrier_requested_at IS NULL OR barrier_requested_at > 0),\n  barrier_lease_expires_at INTEGER CHECK (barrier_lease_expires_at IS NULL OR barrier_lease_expires_at > 0),\n  barrier_status TEXT CHECK (barrier_status IS NULL OR barrier_status IN ('requested','active')),\n  barrier_active_at INTEGER CHECK (barrier_active_at IS NULL OR barrier_active_at > 0),\n  CHECK ((writer_ticket_id IS NULL) = (writer_sequence IS NULL)),\n  CHECK ((writer_ticket_id IS NULL) = (writer_host IS NULL)),\n  CHECK ((writer_ticket_id IS NULL) = (writer_pid IS NULL)),\n  CHECK ((writer_ticket_id IS NULL) = (writer_boot_id IS NULL)),\n  CHECK ((writer_ticket_id IS NULL) = (writer_process_start IS NULL)),\n  CHECK ((writer_ticket_id IS NULL) = (writer_deadline IS NULL)),\n  CHECK ((writer_ticket_id IS NULL) = (writer_enqueued_at IS NULL)),\n  CHECK ((writer_ticket_id IS NULL) = (writer_nonce IS NULL)),\n  CHECK ((writer_ticket_id IS NULL) = (writer_admitted_at IS NULL)),\n  CHECK ((writer_ticket_id IS NULL) = (writer_lease_expires_at IS NULL)),\n  CHECK ((barrier_id IS NULL) = (barrier_nonce IS NULL)),\n  CHECK ((barrier_id IS NULL) = (barrier_host IS NULL)),\n  CHECK ((barrier_id IS NULL) = (barrier_pid IS NULL)),\n  CHECK ((barrier_id IS NULL) = (barrier_boot_id IS NULL)),\n  CHECK ((barrier_id IS NULL) = (barrier_process_start IS NULL)),\n  CHECK ((barrier_id IS NULL) = (barrier_deadline IS NULL)),\n  CHECK ((barrier_id IS NULL) = (barrier_requested_at IS NULL)),\n  CHECK ((barrier_id IS NULL) = (barrier_lease_expires_at IS NULL)),\n  CHECK ((barrier_id IS NULL) = (barrier_status IS NULL)),\n  CHECK (\n    (barrier_status IS NULL AND barrier_active_at IS NULL) OR\n    (barrier_status = 'requested' AND barrier_active_at IS NULL) OR\n    (barrier_status = 'active' AND barrier_active_at IS NOT NULL)\n  )\n) STRICT;\nCREATE TABLE ne19_coordination_tickets (\n  ticket_id TEXT PRIMARY KEY,\n  sequence INTEGER NOT NULL UNIQUE CHECK (sequence > 0),\n  host TEXT NOT NULL,\n  pid INTEGER NOT NULL CHECK (pid > 0),\n  boot_id TEXT NOT NULL,\n  process_start TEXT NOT NULL,\n  deadline INTEGER NOT NULL CHECK (deadline > 0),\n  enqueued_at INTEGER NOT NULL CHECK (enqueued_at > 0)\n) STRICT;\nCREATE TABLE ne19_runs (\n  run_id TEXT PRIMARY KEY,\n  experiment_id TEXT NOT NULL,\n  status TEXT NOT NULL CHECK (status IN ('open','sealing','sealed')),\n  writer_generation TEXT NOT NULL,\n  started_at TEXT NOT NULL,\n  core_payload BLOB,\n  core_digest TEXT CHECK (core_digest IS NULL OR length(core_digest) = 64),\n  mutation_sequence INTEGER NOT NULL DEFAULT 0 CHECK (mutation_sequence >= 0),\n  candidate_seal_identity TEXT CHECK (candidate_seal_identity IS NULL OR length(candidate_seal_identity) = 64),\n  candidate_seal_entry_count INTEGER CHECK (candidate_seal_entry_count IS NULL OR candidate_seal_entry_count >= 0),\n  candidate_seal_staged_count INTEGER NOT NULL DEFAULT 0 CHECK (candidate_seal_staged_count >= 0),\n  logical_seal_identity TEXT,\n  CHECK ((core_payload IS NULL) = (core_digest IS NULL)),\n  CHECK ((candidate_seal_identity IS NULL) = (candidate_seal_entry_count IS NULL)),\n  CHECK ((status = 'open') = (candidate_seal_identity IS NULL)),\n  CHECK (candidate_seal_entry_count IS NULL OR candidate_seal_staged_count <= candidate_seal_entry_count),\n  CHECK (status != 'open' OR candidate_seal_staged_count = 0),\n  CHECK ((status = 'sealed') = (logical_seal_identity IS NOT NULL)),\n  CHECK (status = 'open' OR core_payload IS NOT NULL)\n) STRICT;\nCREATE TABLE ne19_slots (\n  run_id TEXT NOT NULL REFERENCES ne19_runs(run_id) ON DELETE CASCADE,\n  slot_id TEXT NOT NULL,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  core_payload BLOB NOT NULL,\n  core_digest TEXT NOT NULL CHECK (length(core_digest) = 64),\n  PRIMARY KEY (run_id, slot_id),\n  UNIQUE (run_id, ordinal)\n) STRICT;\nCREATE TABLE ne19_attempts (\n  origin_run_id TEXT NOT NULL REFERENCES ne19_runs(run_id) ON DELETE CASCADE,\n  attempt_id TEXT NOT NULL,\n  attempt_locator TEXT NOT NULL CHECK (length(attempt_locator) = 14 AND substr(attempt_locator,1,2) = '@1'),\n  publication_state TEXT NOT NULL DEFAULT 'staging' CHECK (publication_state IN ('staging','sealing','published')),\n  core_payload BLOB,\n  core_digest TEXT CHECK (core_digest IS NULL OR length(core_digest) = 64),\n  CHECK ((core_payload IS NULL) = (core_digest IS NULL)),\n  PRIMARY KEY (origin_run_id, attempt_id)\n) STRICT;\nCREATE TABLE ne19_members (\n  target_run_id TEXT NOT NULL,\n  slot_id TEXT NOT NULL,\n  origin_run_id TEXT,\n  attempt_id TEXT,\n  action TEXT NOT NULL CHECK (action IN ('executed','carried','accepted','not-dispatched','interrupted')),\n  core_payload BLOB NOT NULL,\n  core_digest TEXT NOT NULL CHECK (length(core_digest) = 64),\n  PRIMARY KEY (target_run_id, slot_id),\n  CHECK (\n    (action IN ('executed','carried','accepted') AND origin_run_id IS NOT NULL AND attempt_id IS NOT NULL) OR\n    (action IN ('not-dispatched','interrupted') AND origin_run_id IS NULL AND attempt_id IS NULL)\n  ),\n  FOREIGN KEY (target_run_id, slot_id) REFERENCES ne19_slots(run_id, slot_id) ON DELETE CASCADE\n) STRICT;\nCREATE TABLE ne19_attachments (\n  attachment_id TEXT PRIMARY KEY,\n  owner_kind TEXT NOT NULL CHECK (owner_kind IN ('run','attempt')),\n  owner_run_id TEXT NOT NULL REFERENCES ne19_runs(run_id) ON DELETE CASCADE,\n  owner_attempt_id TEXT,\n  family TEXT NOT NULL,\n  family_revision INTEGER NOT NULL CHECK (family_revision > 0),\n  logical_identity TEXT,\n  canonical_payload BLOB,\n  canonical_digest TEXT CHECK (canonical_digest IS NULL OR length(canonical_digest) = 64),\n  logical_inventory BLOB,\n  inventory_digest TEXT CHECK (inventory_digest IS NULL OR length(inventory_digest) = 64),\n  CHECK ((canonical_payload IS NULL) = (canonical_digest IS NULL)),\n  CHECK ((logical_inventory IS NULL) = (inventory_digest IS NULL)),\n  CHECK ((owner_kind = 'run' AND owner_attempt_id IS NULL) OR (owner_kind = 'attempt' AND owner_attempt_id IS NOT NULL)),\n  UNIQUE (owner_kind, owner_run_id, owner_attempt_id, family),\n  FOREIGN KEY (owner_run_id, owner_attempt_id) REFERENCES ne19_attempts(origin_run_id, attempt_id) ON DELETE CASCADE\n) STRICT;\nCREATE TABLE ne19_attachment_references (\n  attachment_id TEXT NOT NULL REFERENCES ne19_attachments(attachment_id) ON DELETE CASCADE,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  target_owner_kind TEXT NOT NULL CHECK (target_owner_kind IN ('run','attempt')),\n  target_family TEXT NOT NULL,\n  canonical_payload BLOB NOT NULL,\n  reference_digest TEXT NOT NULL CHECK (length(reference_digest) = 64),\n  PRIMARY KEY (attachment_id, ordinal)\n) STRICT;\nCREATE TABLE ne19_collection_items (\n  attachment_id TEXT NOT NULL REFERENCES ne19_attachments(attachment_id) ON DELETE CASCADE,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  logical_identity TEXT NOT NULL,\n  canonical_payload BLOB NOT NULL,\n  canonical_digest TEXT NOT NULL CHECK (length(canonical_digest) = 64),\n  PRIMARY KEY (attachment_id, ordinal),\n  UNIQUE (attachment_id, logical_identity)\n) STRICT;\nCREATE TABLE ne19_contents (\n  content_id TEXT PRIMARY KEY,\n  attachment_id TEXT NOT NULL REFERENCES ne19_attachments(attachment_id) ON DELETE CASCADE,\n  logical_handle TEXT NOT NULL,\n  byte_length INTEGER CHECK (byte_length IS NULL OR byte_length >= 0),\n  overall_digest TEXT CHECK (overall_digest IS NULL OR length(overall_digest) = 64),\n  chunk_count INTEGER CHECK (chunk_count IS NULL OR chunk_count >= 0),\n  CHECK ((byte_length IS NULL) = (overall_digest IS NULL) AND (overall_digest IS NULL) = (chunk_count IS NULL)),\n  UNIQUE (attachment_id, logical_handle)\n) STRICT;\nCREATE TABLE ne19_content_chunks (\n  content_id TEXT NOT NULL REFERENCES ne19_contents(content_id) ON DELETE CASCADE,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  bytes BLOB NOT NULL CHECK (length(bytes) <= 262144),\n  chunk_digest TEXT NOT NULL CHECK (length(chunk_digest) = 64),\n  PRIMARY KEY (content_id, ordinal)\n) STRICT;\nCREATE TABLE ne19_run_seal_entries (\n  run_id TEXT NOT NULL REFERENCES ne19_runs(run_id) ON DELETE CASCADE,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  entry_kind TEXT NOT NULL CHECK (entry_kind IN ('record','run','slot','member','attempt','attachment','attachment-reference','collection-item','content','content-chunk')),\n  logical_identity TEXT NOT NULL,\n  digest TEXT NOT NULL CHECK (length(digest) = 64),\n  PRIMARY KEY (run_id, ordinal),\n  UNIQUE (run_id, entry_kind, logical_identity)\n) STRICT;\nCREATE INDEX ne19_attachments_owner_family ON ne19_attachments(owner_kind, owner_run_id, owner_attempt_id, family);\nCREATE UNIQUE INDEX ne19_attachments_owner_family_unique ON ne19_attachments(owner_kind, owner_run_id, coalesce(owner_attempt_id,''), family);\nCREATE INDEX ne19_members_origin_attempt ON ne19_members(origin_run_id, attempt_id, target_run_id);\nCREATE INDEX ne19_attempts_locator ON ne19_attempts(attempt_locator, origin_run_id, attempt_id);\nCREATE INDEX ne19_references_target_family ON ne19_attachment_references(target_owner_kind, target_family);\nCREATE INDEX ne19_content_chunks_page ON ne19_content_chunks(content_id, ordinal);\nCREATE INDEX ne19_coordination_tickets_fifo ON ne19_coordination_tickets(sequence);\nCREATE TRIGGER ne19_coordination_ticket_barrier_insert BEFORE INSERT ON ne19_coordination_tickets WHEN (SELECT barrier_state FROM ne19_record_metadata WHERE singleton=1)!='open' BEGIN SELECT RAISE(ABORT, 'ProjectDatabase writer barrier is not open'); END;\nCREATE TRIGGER ne19_coordination_writer_barrier_update BEFORE UPDATE ON ne19_coordination_state WHEN NEW.writer_ticket_id IS NOT NULL AND (SELECT barrier_state FROM ne19_record_metadata WHERE singleton=1)!='open' BEGIN SELECT RAISE(ABORT, 'ProjectDatabase writer barrier is not open'); END;\nCREATE TRIGGER ne19_runs_sealed_update BEFORE UPDATE ON ne19_runs WHEN OLD.status = 'sealed' BEGIN SELECT RAISE(ABORT, 'sealed run is immutable'); END;\nCREATE TRIGGER ne19_runs_sealed_delete BEFORE DELETE ON ne19_runs WHEN OLD.status = 'sealed' BEGIN SELECT RAISE(ABORT, 'sealed run is immutable'); END;\nCREATE TRIGGER ne19_slots_sealed_insert BEFORE INSERT ON ne19_slots WHEN (SELECT status FROM ne19_runs WHERE run_id = NEW.run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_slots_sealed_update BEFORE UPDATE ON ne19_slots WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_slots_sealed_delete BEFORE DELETE ON ne19_slots WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_attempts_sealed_insert BEFORE INSERT ON ne19_attempts WHEN (SELECT status FROM ne19_runs WHERE run_id = NEW.origin_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_attempts_sealed_update BEFORE UPDATE ON ne19_attempts WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.origin_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_attempts_sealed_delete BEFORE DELETE ON ne19_attempts WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.origin_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_members_sealed_insert BEFORE INSERT ON ne19_members WHEN (SELECT status FROM ne19_runs WHERE run_id = NEW.target_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_members_sealed_update BEFORE UPDATE ON ne19_members WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.target_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_members_sealed_delete BEFORE DELETE ON ne19_members WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.target_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_attachments_sealed_insert BEFORE INSERT ON ne19_attachments WHEN (SELECT status FROM ne19_runs WHERE run_id = NEW.owner_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_attachments_attempt_published_insert BEFORE INSERT ON ne19_attachments WHEN NEW.owner_kind='attempt' AND (SELECT publication_state FROM ne19_attempts WHERE origin_run_id=NEW.owner_run_id AND attempt_id=NEW.owner_attempt_id)='published' BEGIN SELECT RAISE(ABORT, 'published attempt is immutable'); END;\nCREATE TRIGGER ne19_attachments_sealed_update BEFORE UPDATE ON ne19_attachments WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.owner_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_attachments_attempt_published_update BEFORE UPDATE ON ne19_attachments WHEN OLD.owner_kind='attempt' AND (SELECT publication_state FROM ne19_attempts WHERE origin_run_id=OLD.owner_run_id AND attempt_id=OLD.owner_attempt_id)='published' BEGIN SELECT RAISE(ABORT, 'published attempt is immutable'); END;\nCREATE TRIGGER ne19_attachments_sealed_delete BEFORE DELETE ON ne19_attachments WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.owner_run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_attachments_attempt_published_delete BEFORE DELETE ON ne19_attachments WHEN OLD.owner_kind='attempt' AND (SELECT publication_state FROM ne19_attempts WHERE origin_run_id=OLD.owner_run_id AND attempt_id=OLD.owner_attempt_id)='published' BEGIN SELECT RAISE(ABORT, 'published attempt is immutable'); END;\nCREATE TRIGGER ne19_references_sealed_insert BEFORE INSERT ON ne19_attachment_references WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=NEW.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_references_sealed_update BEFORE UPDATE ON ne19_attachment_references WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_references_sealed_delete BEFORE DELETE ON ne19_attachment_references WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_items_sealed_insert BEFORE INSERT ON ne19_collection_items WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=NEW.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_items_sealed_update BEFORE UPDATE ON ne19_collection_items WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_items_sealed_delete BEFORE DELETE ON ne19_collection_items WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_contents_sealed_insert BEFORE INSERT ON ne19_contents WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=NEW.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_contents_sealed_update BEFORE UPDATE ON ne19_contents WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_contents_sealed_delete BEFORE DELETE ON ne19_contents WHEN (SELECT r.status FROM ne19_attachments a JOIN ne19_runs r ON r.run_id=a.owner_run_id WHERE a.attachment_id=OLD.attachment_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_chunks_sealed_insert BEFORE INSERT ON ne19_content_chunks WHEN (SELECT r.status 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 WHERE c.content_id=NEW.content_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_chunks_sealed_update BEFORE UPDATE ON ne19_content_chunks WHEN (SELECT r.status 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 WHERE c.content_id=OLD.content_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_chunks_sealed_delete BEFORE DELETE ON ne19_content_chunks WHEN (SELECT r.status 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 WHERE c.content_id=OLD.content_id) != 'open' BEGIN SELECT RAISE(ABORT, 'run closure is immutable'); END;\nCREATE TRIGGER ne19_seal_entries_sealed_insert BEFORE INSERT ON ne19_run_seal_entries WHEN (SELECT status FROM ne19_runs WHERE run_id = NEW.run_id) != 'sealing' BEGIN SELECT RAISE(ABORT, 'Seal candidates require sealing state'); END;\nCREATE TRIGGER ne19_seal_entries_sealed_update BEFORE UPDATE ON ne19_run_seal_entries BEGIN SELECT RAISE(ABORT, 'Seal entries are immutable'); END;\nCREATE TRIGGER ne19_seal_entries_sealed_delete BEFORE DELETE ON ne19_run_seal_entries WHEN (SELECT status FROM ne19_runs WHERE run_id = OLD.run_id) != 'open' BEGIN SELECT RAISE(ABORT, 'Seal entries are immutable'); END;\n\n\nCREATE TABLE ne19_run_publication_clock (\n  singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n  revision INTEGER NOT NULL CHECK (revision >= 0)\n) STRICT;\nCREATE TABLE ne19_run_resources (\n  run_id TEXT PRIMARY KEY,\n  invocation_id TEXT NOT NULL,\n  experiment_id TEXT NOT NULL,\n  started_at TEXT NOT NULL,\n  initial_writer_generation TEXT NOT NULL,\n  current_writer_generation TEXT NOT NULL,\n  terminal_state TEXT CHECK (terminal_state IS NULL OR terminal_state IN ('completed','interrupted','failed')),\n  completed_at TEXT,\n  created_revision INTEGER NOT NULL UNIQUE CHECK (created_revision > 0),\n  close_revision INTEGER UNIQUE CHECK (close_revision IS NULL OR close_revision > created_revision),\n  CHECK ((terminal_state IS NULL) = (completed_at IS NULL)),\n  CHECK ((terminal_state IS NULL) = (close_revision IS NULL))\n) STRICT;\nCREATE TABLE ne19_run_expected_slots (\n  run_id TEXT NOT NULL REFERENCES ne19_run_resources(run_id) ON DELETE RESTRICT,\n  slot_id TEXT NOT NULL,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  eval_id TEXT NOT NULL,\n  attempt_ordinal INTEGER NOT NULL CHECK (attempt_ordinal >= 0),\n  execution_identity_digest TEXT NOT NULL CHECK (length(execution_identity_digest) = 64),\n  PRIMARY KEY (run_id, slot_id),\n  UNIQUE (run_id, ordinal)\n) STRICT;\nCREATE TABLE ne19_attempt_publications (\n  attempt_id TEXT PRIMARY KEY,\n  attempt_locator TEXT NOT NULL CHECK (length(attempt_locator) = 14 AND substr(attempt_locator,1,2) = '@1'),\n  origin_run_id TEXT NOT NULL,\n  origin_slot_id TEXT NOT NULL,\n  closure_payload BLOB NOT NULL,\n  closure_digest TEXT NOT NULL CHECK (length(closure_digest) = 64),\n  published_revision INTEGER NOT NULL UNIQUE CHECK (published_revision > 0),\n  FOREIGN KEY (origin_run_id, origin_slot_id) REFERENCES ne19_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT\n) STRICT;\nCREATE TABLE ne19_run_slot_bindings (\n  target_run_id TEXT NOT NULL,\n  slot_id TEXT NOT NULL,\n  attempt_id TEXT NOT NULL REFERENCES ne19_attempt_publications(attempt_id) ON DELETE RESTRICT,\n  origin_run_id TEXT NOT NULL,\n  origin_slot_id TEXT NOT NULL,\n  attempt_publication_revision INTEGER NOT NULL CHECK (attempt_publication_revision > 0),\n  action TEXT NOT NULL CHECK (action IN ('executed','carried','accepted')),\n  binding_revision INTEGER NOT NULL UNIQUE CHECK (binding_revision > 0),\n  PRIMARY KEY (target_run_id, slot_id),\n  FOREIGN KEY (target_run_id, slot_id) REFERENCES ne19_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT,\n  FOREIGN KEY (origin_run_id, origin_slot_id) REFERENCES ne19_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT\n) STRICT;\nCREATE TABLE ne19_run_slot_absences (\n  run_id TEXT NOT NULL,\n  slot_id TEXT NOT NULL,\n  reason TEXT NOT NULL CHECK (reason IN ('early-exit-satisfied','budget-exhausted','stopped-by-failure','interrupted-before-publication','dispatch-failed')),\n  absence_revision INTEGER NOT NULL CHECK (absence_revision > 0),\n  PRIMARY KEY (run_id, slot_id),\n  FOREIGN KEY (run_id, slot_id) REFERENCES ne19_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT\n) STRICT;\nCREATE TABLE ne19_run_recoveries (\n  run_id TEXT PRIMARY KEY REFERENCES ne19_run_resources(run_id) ON DELETE RESTRICT,\n  previous_writer_generation TEXT NOT NULL,\n  recovery_writer_generation TEXT NOT NULL,\n  evidence_kind TEXT NOT NULL,\n  evidence_identity TEXT NOT NULL,\n  evidence_observed_at TEXT NOT NULL,\n  recovery_revision INTEGER NOT NULL UNIQUE CHECK (recovery_revision > 0)\n) STRICT;\nCREATE TABLE ne19_run_deletion_tombstones (\n  run_id TEXT PRIMARY KEY REFERENCES ne19_run_resources(run_id) ON DELETE RESTRICT,\n  terminal_state TEXT NOT NULL CHECK (terminal_state IN ('completed','interrupted','failed')),\n  deleted_at TEXT NOT NULL,\n  deletion_revision INTEGER NOT NULL UNIQUE CHECK (deletion_revision > 0)\n) STRICT;\nCREATE INDEX ne19_runs_experiment ON ne19_runs(experiment_id,run_id);\nCREATE INDEX ne19_run_resources_experiment ON ne19_run_resources(experiment_id,created_revision,run_id);\nCREATE INDEX ne19_run_expected_slots_position ON ne19_run_expected_slots(eval_id,attempt_ordinal,run_id);\nCREATE INDEX ne19_run_resources_list ON ne19_run_resources(created_revision, run_id);\nCREATE INDEX ne19_run_resources_invocation ON ne19_run_resources(invocation_id, created_revision, run_id);\nCREATE INDEX ne19_attempt_publications_origin ON ne19_attempt_publications(origin_run_id, origin_slot_id);\nCREATE INDEX ne19_attempt_publications_locator ON ne19_attempt_publications(attempt_locator, origin_run_id, attempt_id);\nCREATE INDEX ne19_run_slot_bindings_attempt ON ne19_run_slot_bindings(attempt_id, target_run_id, slot_id);\nCREATE INDEX ne19_run_deletion_revision ON ne19_run_deletion_tombstones(deletion_revision, run_id);\nINSERT INTO ne19_run_publication_clock(singleton,revision) VALUES (1,0);\n\n\nCREATE TABLE ne19_invocation_sessions (\n  invocation_id TEXT PRIMARY KEY,\n  state TEXT NOT NULL CHECK (state IN ('active','recovering','completed','interrupted','failed')),\n  owner_id TEXT NOT NULL,\n  owner_generation INTEGER NOT NULL CHECK (owner_generation > 0),\n  owner_host TEXT NOT NULL,\n  owner_pid INTEGER NOT NULL CHECK (owner_pid > 0),\n  owner_boot_id TEXT NOT NULL,\n  owner_process_start TEXT NOT NULL,\n  started_at TEXT NOT NULL,\n  heartbeat_at TEXT NOT NULL,\n  active_projection BLOB,\n  recovering_at TEXT,\n  closed_at TEXT,\n  terminal_projection BLOB,\n  CHECK ((state IN ('completed','interrupted','failed')) = (closed_at IS NOT NULL)),\n  CHECK ((state IN ('completed','interrupted','failed')) = (terminal_projection IS NOT NULL)),\n  CHECK (state IN ('active','recovering') OR active_projection IS NULL),\n  CHECK ((state = 'recovering') = (recovering_at IS NOT NULL))\n) STRICT;\nCREATE TABLE ne19_invocation_session_experiments (\n  invocation_id TEXT NOT NULL REFERENCES ne19_invocation_sessions(invocation_id) ON DELETE RESTRICT,\n  experiment_id TEXT NOT NULL,\n  run_id TEXT NOT NULL UNIQUE REFERENCES ne19_run_resources(run_id) ON DELETE RESTRICT,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  PRIMARY KEY (invocation_id, experiment_id),\n  UNIQUE (invocation_id, ordinal)\n) STRICT;\nCREATE TABLE ne19_invocation_session_queued_attempts (\n  invocation_id TEXT NOT NULL REFERENCES ne19_invocation_sessions(invocation_id) ON DELETE RESTRICT,\n  attempt_id TEXT NOT NULL,\n  run_id TEXT NOT NULL REFERENCES ne19_run_resources(run_id) ON DELETE RESTRICT,\n  slot_id TEXT NOT NULL,\n  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),\n  PRIMARY KEY (invocation_id, attempt_id),\n  UNIQUE (invocation_id, ordinal),\n  FOREIGN KEY (run_id, slot_id) REFERENCES ne19_run_expected_slots(run_id, slot_id) ON DELETE RESTRICT\n) STRICT;\nCREATE TABLE ne19_case_locks (\n  case_id TEXT PRIMARY KEY,\n  owner_id TEXT NOT NULL,\n  owner_generation INTEGER NOT NULL CHECK (owner_generation > 0),\n  owner_host TEXT NOT NULL,\n  owner_pid INTEGER NOT NULL CHECK (owner_pid > 0),\n  owner_boot_id TEXT NOT NULL,\n  owner_process_start TEXT NOT NULL,\n  acquired_at TEXT NOT NULL,\n  heartbeat_at TEXT NOT NULL\n) STRICT;\nCREATE INDEX ne19_invocation_sessions_state ON ne19_invocation_sessions(state, started_at, invocation_id);\nCREATE INDEX ne19_invocation_session_experiments_invocation ON ne19_invocation_session_experiments(invocation_id, ordinal);\nCREATE INDEX ne19_invocation_session_queued_attempts_run ON ne19_invocation_session_queued_attempts(run_id, slot_id);\nCREATE INDEX ne19_case_locks_owner ON ne19_case_locks(owner_id, owner_generation);\nCREATE TABLE ne19_teardown_obligations (\n  obligation_id TEXT PRIMARY KEY,\n  experiment_id TEXT NOT NULL,\n  owner_pid INTEGER NOT NULL CHECK (owner_pid > 0),\n  owner_host TEXT NOT NULL,\n  generation INTEGER NOT NULL DEFAULT 1 CHECK (generation > 0),\n  payload BLOB NOT NULL,\n  UNIQUE (experiment_id, owner_pid)\n) STRICT;\nCREATE TABLE ne19_shared_state_generations (\n  state_key TEXT NOT NULL,\n  generation INTEGER NOT NULL CHECK (generation > 0),\n  parent_generation INTEGER NOT NULL CHECK (parent_generation >= 0),\n  state_kind TEXT NOT NULL CHECK (state_kind IN ('active','recovering','free')),\n  owner_token TEXT NOT NULL,\n  owner_pid INTEGER NOT NULL CHECK (owner_pid > 0),\n  owner_host TEXT NOT NULL,\n  owner_process_identity TEXT NOT NULL,\n  heartbeat_at TEXT NOT NULL,\n  payload BLOB NOT NULL,\n  PRIMARY KEY (state_key, generation),\n  CHECK (parent_generation = generation - 1)\n) STRICT;\nCREATE TABLE ne19_kept_sandboxes (\n  entry_id TEXT PRIMARY KEY,\n  provider TEXT NOT NULL,\n  sandbox_id TEXT NOT NULL,\n  kept_at TEXT NOT NULL,\n  operation_generation INTEGER NOT NULL DEFAULT 0 CHECK (operation_generation >= 0),\n  payload BLOB NOT NULL,\n  UNIQUE (provider, sandbox_id)\n) STRICT;\nCREATE TABLE ne19_kept_sandbox_operation_leases (\n  entry_id TEXT PRIMARY KEY REFERENCES ne19_kept_sandboxes(entry_id) ON DELETE CASCADE,\n  generation INTEGER NOT NULL CHECK (generation > 0),\n  token TEXT NOT NULL,\n  holder TEXT NOT NULL,\n  owner_pid INTEGER NOT NULL CHECK (owner_pid > 0),\n  owner_host TEXT NOT NULL,\n  owner_process_identity TEXT NOT NULL,\n  operation TEXT NOT NULL,\n  acquired_at TEXT NOT NULL,\n  ttl_ms INTEGER NOT NULL CHECK (ttl_ms > 0)\n) STRICT;\nCREATE INDEX ne19_teardown_obligations_experiment ON ne19_teardown_obligations(experiment_id, owner_pid);\nCREATE INDEX ne19_shared_state_generations_head ON ne19_shared_state_generations(state_key, generation DESC);\nCREATE INDEX ne19_kept_sandboxes_kept_at ON ne19_kept_sandboxes(kept_at, entry_id);\n\n\nCREATE TABLE ne19_migration_state (\n  singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n  state TEXT NOT NULL CHECK (state IN ('committed','ready')),\n  source_format TEXT,\n  source_digest TEXT CHECK (source_digest IS NULL OR length(source_digest) = 64),\n  CHECK ((source_format IS NULL) = (source_digest IS NULL)),\n  CHECK (state != 'committed' OR source_format IS NOT NULL)\n) STRICT;`;\n"]}