niceeval 0.14.4-canary.67 → 0.15.0

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

@@ -1,11 +1,443 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RECORD_SQLITE_BASELINE_SQL = void 0;
-const legacy_schema_017_ts_1 = require("./legacy-schema-017.cjs");
 /**
- * Exact current ProjectDatabase 0.18 schema. The 0.18 namespace is disjoint
- * from every 0.17 writable object so stale prepared writers cannot cross the
- * migration commit boundary.
+ * Exact current ProjectDatabase 0.18 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.
  */
-exports.RECORD_SQLITE_BASELINE_SQL = legacy_schema_017_ts_1.RECORD_SQLITE_017_BASELINE_SQL.replaceAll(/\bne_/gu, "ne18_");
+exports.RECORD_SQLITE_BASELINE_SQL = `
+CREATE TABLE ne18_record_metadata (
+  singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+  format TEXT NOT NULL,
+  storage_revision INTEGER NOT NULL CHECK (storage_revision > 0),
+  storage_generation TEXT NOT NULL,
+  schema_fingerprint TEXT NOT NULL CHECK (length(schema_fingerprint) = 64),
+  created_at TEXT NOT NULL,
+  barrier_state TEXT NOT NULL CHECK (barrier_state IN ('open','draining','portable')),
+  portable_generation TEXT,
+  portable_revision INTEGER CHECK (portable_revision IS NULL OR portable_revision >= 0),
+  portable_gate_id TEXT,
+  record_payload BLOB,
+  record_digest TEXT,
+  CHECK ((record_payload IS NULL) = (record_digest IS NULL)),
+  CHECK (record_digest IS NULL OR length(record_digest) = 64),
+  CHECK ((barrier_state = 'portable') = (portable_generation IS NOT NULL)),
+  CHECK ((barrier_state = 'portable') = (portable_revision IS NOT NULL)),
+  CHECK ((barrier_state = 'open') = (portable_gate_id IS NULL))
+) STRICT;
+CREATE TABLE ne18_coordination_state (
+  singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+  revision INTEGER NOT NULL CHECK (revision >= 0),
+  operational_generation TEXT NOT NULL,
+  next_writer_sequence INTEGER NOT NULL CHECK (next_writer_sequence > 0),
+  writer_ticket_id TEXT,
+  writer_sequence INTEGER CHECK (writer_sequence IS NULL OR writer_sequence > 0),
+  writer_host TEXT,
+  writer_pid INTEGER CHECK (writer_pid IS NULL OR writer_pid > 0),
+  writer_boot_id TEXT,
+  writer_process_start TEXT,
+  writer_deadline INTEGER CHECK (writer_deadline IS NULL OR writer_deadline > 0),
+  writer_enqueued_at INTEGER CHECK (writer_enqueued_at IS NULL OR writer_enqueued_at > 0),
+  writer_nonce TEXT,
+  writer_admitted_at INTEGER CHECK (writer_admitted_at IS NULL OR writer_admitted_at > 0),
+  writer_lease_expires_at INTEGER CHECK (writer_lease_expires_at IS NULL OR writer_lease_expires_at > 0),
+  barrier_id TEXT,
+  barrier_nonce TEXT,
+  barrier_host TEXT,
+  barrier_pid INTEGER CHECK (barrier_pid IS NULL OR barrier_pid > 0),
+  barrier_boot_id TEXT,
+  barrier_process_start TEXT,
+  barrier_deadline INTEGER CHECK (barrier_deadline IS NULL OR barrier_deadline > 0),
+  barrier_requested_at INTEGER CHECK (barrier_requested_at IS NULL OR barrier_requested_at > 0),
+  barrier_lease_expires_at INTEGER CHECK (barrier_lease_expires_at IS NULL OR barrier_lease_expires_at > 0),
+  barrier_status TEXT CHECK (barrier_status IS NULL OR barrier_status IN ('requested','active')),
+  barrier_active_at INTEGER CHECK (barrier_active_at IS NULL OR barrier_active_at > 0),
+  CHECK ((writer_ticket_id IS NULL) = (writer_sequence IS NULL)),
+  CHECK ((writer_ticket_id IS NULL) = (writer_host IS NULL)),
+  CHECK ((writer_ticket_id IS NULL) = (writer_pid IS NULL)),
+  CHECK ((writer_ticket_id IS NULL) = (writer_boot_id IS NULL)),
+  CHECK ((writer_ticket_id IS NULL) = (writer_process_start IS NULL)),
+  CHECK ((writer_ticket_id IS NULL) = (writer_deadline IS NULL)),
+  CHECK ((writer_ticket_id IS NULL) = (writer_enqueued_at IS NULL)),
+  CHECK ((writer_ticket_id IS NULL) = (writer_nonce IS NULL)),
+  CHECK ((writer_ticket_id IS NULL) = (writer_admitted_at IS NULL)),
+  CHECK ((writer_ticket_id IS NULL) = (writer_lease_expires_at IS NULL)),
+  CHECK ((barrier_id IS NULL) = (barrier_nonce IS NULL)),
+  CHECK ((barrier_id IS NULL) = (barrier_host IS NULL)),
+  CHECK ((barrier_id IS NULL) = (barrier_pid IS NULL)),
+  CHECK ((barrier_id IS NULL) = (barrier_boot_id IS NULL)),
+  CHECK ((barrier_id IS NULL) = (barrier_process_start IS NULL)),
+  CHECK ((barrier_id IS NULL) = (barrier_deadline IS NULL)),
+  CHECK ((barrier_id IS NULL) = (barrier_requested_at IS NULL)),
+  CHECK ((barrier_id IS NULL) = (barrier_lease_expires_at IS NULL)),
+  CHECK ((barrier_id IS NULL) = (barrier_status IS NULL)),
+  CHECK (
+    (barrier_status IS NULL AND barrier_active_at IS NULL) OR
+    (barrier_status = 'requested' AND barrier_active_at IS NULL) OR
+    (barrier_status = 'active' AND barrier_active_at IS NOT NULL)
+  )
+) STRICT;
+CREATE TABLE ne18_coordination_tickets (
+  ticket_id TEXT PRIMARY KEY,
+  sequence INTEGER NOT NULL UNIQUE CHECK (sequence > 0),
+  host TEXT NOT NULL,
+  pid INTEGER NOT NULL CHECK (pid > 0),
+  boot_id TEXT NOT NULL,
+  process_start TEXT NOT NULL,
+  deadline INTEGER NOT NULL CHECK (deadline > 0),
+  enqueued_at INTEGER NOT NULL CHECK (enqueued_at > 0)
+) STRICT;
+CREATE TABLE ne18_runs (
+  run_id TEXT PRIMARY KEY,
+  status TEXT NOT NULL CHECK (status IN ('open','sealing','sealed')),
+  writer_generation TEXT NOT NULL,
+  started_at TEXT NOT NULL,
+  core_payload BLOB,
+  core_digest TEXT CHECK (core_digest IS NULL OR length(core_digest) = 64),
+  mutation_sequence INTEGER NOT NULL DEFAULT 0 CHECK (mutation_sequence >= 0),
+  candidate_seal_identity TEXT CHECK (candidate_seal_identity IS NULL OR length(candidate_seal_identity) = 64),
+  candidate_seal_entry_count INTEGER CHECK (candidate_seal_entry_count IS NULL OR candidate_seal_entry_count >= 0),
+  candidate_seal_staged_count INTEGER NOT NULL DEFAULT 0 CHECK (candidate_seal_staged_count >= 0),
+  logical_seal_identity TEXT,
+  CHECK ((core_payload IS NULL) = (core_digest IS NULL)),
+  CHECK ((candidate_seal_identity IS NULL) = (candidate_seal_entry_count IS NULL)),
+  CHECK ((status = 'open') = (candidate_seal_identity IS NULL)),
+  CHECK (candidate_seal_entry_count IS NULL OR candidate_seal_staged_count <= candidate_seal_entry_count),
+  CHECK (status != 'open' OR candidate_seal_staged_count = 0),
+  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,
+  slot_id TEXT NOT NULL,
+  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),
+  core_payload BLOB NOT NULL,
+  core_digest TEXT NOT NULL CHECK (length(core_digest) = 64),
+  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,
+  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')),
+  core_payload BLOB,
+  core_digest TEXT CHECK (core_digest IS NULL OR length(core_digest) = 64),
+  CHECK ((core_payload IS NULL) = (core_digest IS NULL)),
+  PRIMARY KEY (origin_run_id, attempt_id)
+) STRICT;
+CREATE TABLE ne18_members (
+  target_run_id TEXT NOT NULL,
+  slot_id TEXT NOT NULL,
+  origin_run_id TEXT,
+  attempt_id TEXT,
+  action TEXT NOT NULL CHECK (action IN ('executed','carried','accepted','not-dispatched','interrupted')),
+  core_payload BLOB NOT NULL,
+  core_digest TEXT NOT NULL CHECK (length(core_digest) = 64),
+  PRIMARY KEY (target_run_id, slot_id),
+  CHECK (
+    (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
+) STRICT;
+CREATE TABLE ne18_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_attempt_id TEXT,
+  family TEXT NOT NULL,
+  family_revision INTEGER NOT NULL CHECK (family_revision > 0),
+  logical_identity TEXT,
+  canonical_payload BLOB,
+  canonical_digest TEXT CHECK (canonical_digest IS NULL OR length(canonical_digest) = 64),
+  logical_inventory BLOB,
+  inventory_digest TEXT CHECK (inventory_digest IS NULL OR length(inventory_digest) = 64),
+  CHECK ((canonical_payload IS NULL) = (canonical_digest IS NULL)),
+  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
+) STRICT;
+CREATE TABLE ne18_attachment_references (
+  attachment_id TEXT NOT NULL REFERENCES ne18_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,
+  canonical_payload BLOB NOT NULL,
+  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,
+  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),
+  logical_identity TEXT NOT NULL,
+  canonical_payload BLOB NOT NULL,
+  canonical_digest TEXT NOT NULL CHECK (length(canonical_digest) = 64),
+  PRIMARY KEY (attachment_id, ordinal),
+  UNIQUE (attachment_id, logical_identity)
+) STRICT;
+CREATE TABLE ne18_contents (
+  content_id TEXT PRIMARY KEY,
+  attachment_id TEXT NOT NULL REFERENCES ne18_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),
+  chunk_count INTEGER CHECK (chunk_count IS NULL OR chunk_count >= 0),
+  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,
+  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,
+  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,
+  digest TEXT NOT NULL CHECK (length(digest) = 64),
+  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 TABLE ne18_run_publication_clock (
+  singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+  revision INTEGER NOT NULL CHECK (revision >= 0)
+) STRICT;
+CREATE TABLE ne18_run_resources (
+  run_id TEXT PRIMARY KEY,
+  invocation_id TEXT NOT NULL,
+  experiment_id TEXT NOT NULL,
+  started_at TEXT NOT NULL,
+  initial_writer_generation TEXT NOT NULL,
+  current_writer_generation TEXT NOT NULL,
+  terminal_state TEXT CHECK (terminal_state IS NULL OR terminal_state IN ('completed','interrupted','failed')),
+  completed_at TEXT,
+  created_revision INTEGER NOT NULL UNIQUE CHECK (created_revision > 0),
+  close_revision INTEGER UNIQUE CHECK (close_revision IS NULL OR close_revision > created_revision),
+  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,
+  slot_id TEXT NOT NULL,
+  ordinal INTEGER NOT NULL CHECK (ordinal >= 0),
+  eval_id TEXT NOT NULL,
+  attempt_ordinal INTEGER NOT NULL CHECK (attempt_ordinal >= 0),
+  execution_identity_digest TEXT NOT NULL CHECK (length(execution_identity_digest) = 64),
+  PRIMARY KEY (run_id, slot_id),
+  UNIQUE (run_id, ordinal)
+) STRICT;
+CREATE TABLE ne18_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,
+  origin_slot_id TEXT NOT NULL,
+  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
+) STRICT;
+CREATE TABLE ne18_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,
+  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
+) STRICT;
+CREATE TABLE ne18_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
+) STRICT;
+CREATE TABLE ne18_run_recoveries (
+  run_id TEXT PRIMARY KEY REFERENCES ne18_run_resources(run_id) ON DELETE RESTRICT,
+  previous_writer_generation TEXT NOT NULL,
+  recovery_writer_generation TEXT NOT NULL,
+  evidence_kind TEXT NOT NULL,
+  evidence_identity TEXT NOT NULL,
+  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,
+  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 TABLE ne18_invocation_sessions (
+  invocation_id TEXT PRIMARY KEY,
+  state TEXT NOT NULL CHECK (state IN ('active','recovering','completed','interrupted','failed')),
+  owner_id TEXT NOT NULL,
+  owner_generation INTEGER NOT NULL CHECK (owner_generation > 0),
+  owner_host TEXT NOT NULL,
+  owner_pid INTEGER NOT NULL CHECK (owner_pid > 0),
+  owner_boot_id TEXT NOT NULL,
+  owner_process_start TEXT NOT NULL,
+  started_at TEXT NOT NULL,
+  heartbeat_at TEXT NOT NULL,
+  active_projection BLOB,
+  recovering_at TEXT,
+  closed_at TEXT,
+  terminal_projection BLOB,
+  CHECK ((state IN ('completed','interrupted','failed')) = (closed_at IS NOT NULL)),
+  CHECK ((state IN ('completed','interrupted','failed')) = (terminal_projection IS NOT NULL)),
+  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,
+  experiment_id TEXT NOT NULL,
+  run_id TEXT NOT NULL UNIQUE REFERENCES ne18_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,
+  attempt_id TEXT NOT NULL,
+  run_id TEXT NOT NULL REFERENCES ne18_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
+) STRICT;
+CREATE TABLE ne18_case_locks (
+  case_id TEXT PRIMARY KEY,
+  owner_id TEXT NOT NULL,
+  owner_generation INTEGER NOT NULL CHECK (owner_generation > 0),
+  owner_host TEXT NOT NULL,
+  owner_pid INTEGER NOT NULL CHECK (owner_pid > 0),
+  owner_boot_id TEXT NOT NULL,
+  owner_process_start TEXT NOT NULL,
+  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 (
+  obligation_id TEXT PRIMARY KEY,
+  experiment_id TEXT NOT NULL,
+  owner_pid INTEGER NOT NULL CHECK (owner_pid > 0),
+  owner_host TEXT NOT NULL,
+  generation INTEGER NOT NULL DEFAULT 1 CHECK (generation > 0),
+  payload BLOB NOT NULL,
+  UNIQUE (experiment_id, owner_pid)
+) STRICT;
+CREATE TABLE ne18_shared_state_generations (
+  state_key TEXT NOT NULL,
+  generation INTEGER NOT NULL CHECK (generation > 0),
+  parent_generation INTEGER NOT NULL CHECK (parent_generation >= 0),
+  state_kind TEXT NOT NULL CHECK (state_kind IN ('active','recovering','free')),
+  owner_token TEXT NOT NULL,
+  owner_pid INTEGER NOT NULL CHECK (owner_pid > 0),
+  owner_host TEXT NOT NULL,
+  owner_process_identity TEXT NOT NULL,
+  heartbeat_at TEXT NOT NULL,
+  payload BLOB NOT NULL,
+  PRIMARY KEY (state_key, generation),
+  CHECK (parent_generation = generation - 1)
+) STRICT;
+CREATE TABLE ne18_kept_sandboxes (
+  entry_id TEXT PRIMARY KEY,
+  provider TEXT NOT NULL,
+  sandbox_id TEXT NOT NULL,
+  kept_at TEXT NOT NULL,
+  operation_generation INTEGER NOT NULL DEFAULT 0 CHECK (operation_generation >= 0),
+  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,
+  generation INTEGER NOT NULL CHECK (generation > 0),
+  token TEXT NOT NULL,
+  holder TEXT NOT NULL,
+  owner_pid INTEGER NOT NULL CHECK (owner_pid > 0),
+  owner_host TEXT NOT NULL,
+  owner_process_identity TEXT NOT NULL,
+  operation TEXT NOT NULL,
+  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 TABLE ne18_migration_state (
+  singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+  state TEXT NOT NULL CHECK (state IN ('committed','ready')),
+  source_format TEXT,
+  source_digest TEXT CHECK (source_digest IS NULL OR length(source_digest) = 64),
+  CHECK ((source_format IS NULL) = (source_digest IS NULL)),
+  CHECK (state != 'committed' OR source_format IS NOT NULL)
+) STRICT;`;
 //# sourceMappingURL=current-schema.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"current-schema.js","sourceRoot":"","sources":["current-schema.ts"],"names":[],"mappings":";;;AAAA,iEAAwE;AACxE;;;;GAIG;AACU,QAAA,0BAA0B,GAAG,qDAA8B,CAAC,UAAU,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC","sourcesContent":["import { RECORD_SQLITE_017_BASELINE_SQL } from \"./legacy-schema-017.ts\";\n/**\n * Exact current ProjectDatabase 0.18 schema. The 0.18 namespace is disjoint\n * from every 0.17 writable object so stale prepared writers cannot cross the\n * migration commit boundary.\n */\nexport const RECORD_SQLITE_BASELINE_SQL = RECORD_SQLITE_017_BASELINE_SQL.replaceAll(/\\bne_/gu, \"ne18_\");\n"]}
+{"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"]}

package/dist/record/sqlite/current-schema.d.cts

@@ -1,6 +1,6 @@
 /**
- * Exact current ProjectDatabase 0.18 schema. The 0.18 namespace is disjoint
- * from every 0.17 writable object so stale prepared writers cannot cross the
- * migration commit boundary.
+ * Exact current ProjectDatabase 0.18 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.
  */
-export declare const RECORD_SQLITE_BASELINE_SQL: string;
+export declare 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;";