@tenetkit/pg 0.32.0 → 0.33.1

package/dist/postgres/schema.js

@@ -1,17 +1,17 @@
-export const SCHEMA_VERSION = 8;
-export const V7_SCHEMA_CHECKSUM = "4d86018b3453e9757e05694ce981fc486a15a00ebb36874b49821f6289e6d495";
-export const SCHEMA_META_TABLE = "baton_schema_meta";
-export const MIGRATIONS_TABLE = "baton_sql_migrations";
-export const NOTIFY_CHANNEL = "baton_run_events";
-export const V7_SCHEMA_STATEMENTS = [
-    `CREATE TABLE IF NOT EXISTS baton_schema_meta (
+export const SCHEMA_VERSION = 1;
+export const MIGRATION_NAME = "tenetkit_runtime";
+export const SCHEMA_META_TABLE = "tenetkit_schema_meta";
+export const MIGRATIONS_TABLE = "tenetkit_sql_migrations";
+export const NOTIFY_CHANNEL = "tenetkit_run_events";
+export const SCHEMA_STATEMENTS = [
+    `CREATE TABLE IF NOT EXISTS tenetkit_schema_meta (
   id INTEGER PRIMARY KEY CHECK (id = 1),
   version INTEGER NOT NULL,
   checksum TEXT NOT NULL,
   dirty BOOLEAN NOT NULL DEFAULT FALSE,
   applied_at TIMESTAMPTZ NOT NULL
 )`,
-    `CREATE TABLE IF NOT EXISTS baton_lanes (
+    `CREATE TABLE IF NOT EXISTS tenetkit_lanes (
   address TEXT NOT NULL,
   session_id TEXT NOT NULL,
   accepted_sequence BIGINT NOT NULL,
@@ -19,7 +19,7 @@ export const V7_SCHEMA_STATEMENTS = [
   head_run_id TEXT,
   PRIMARY KEY (address, session_id)
 )`,
-    `CREATE TABLE IF NOT EXISTS baton_runs (
+    `CREATE TABLE IF NOT EXISTS tenetkit_runs (
   run_id TEXT PRIMARY KEY,
   status TEXT NOT NULL,
   address TEXT NOT NULL,
@@ -55,15 +55,15 @@ export const V7_SCHEMA_STATEMENTS = [
   updated_at TIMESTAMPTZ NOT NULL,
   UNIQUE (address, session_id, idempotency_key)
 )`,
-    `CREATE TABLE IF NOT EXISTS baton_run_events (
-  run_id TEXT NOT NULL REFERENCES baton_runs(run_id),
+    `CREATE TABLE IF NOT EXISTS tenetkit_run_events (
+  run_id TEXT NOT NULL REFERENCES tenetkit_runs(run_id),
   sequence INTEGER NOT NULL,
   event_id TEXT NOT NULL UNIQUE,
   event_json TEXT NOT NULL,
   PRIMARY KEY (run_id, sequence)
 )`,
-    `CREATE TABLE IF NOT EXISTS baton_run_operations (
-  run_id TEXT NOT NULL REFERENCES baton_runs(run_id),
+    `CREATE TABLE IF NOT EXISTS tenetkit_run_operations (
+  run_id TEXT NOT NULL REFERENCES tenetkit_runs(run_id),
   operation_id TEXT NOT NULL,
   operation_key TEXT NOT NULL,
   kind TEXT NOT NULL,
@@ -83,8 +83,8 @@ export const V7_SCHEMA_STATEMENTS = [
   PRIMARY KEY (run_id, operation_id),
   UNIQUE (run_id, operation_key)
 )`,
-    `CREATE TABLE IF NOT EXISTS baton_run_waits (
-  run_id TEXT NOT NULL REFERENCES baton_runs(run_id),
+    `CREATE TABLE IF NOT EXISTS tenetkit_run_waits (
+  run_id TEXT NOT NULL REFERENCES tenetkit_runs(run_id),
   wait_id TEXT NOT NULL,
   reason TEXT NOT NULL,
   status TEXT NOT NULL,
@@ -96,9 +96,9 @@ export const V7_SCHEMA_STATEMENTS = [
   closed_at TIMESTAMPTZ,
   PRIMARY KEY (run_id, wait_id)
 )`,
-    `CREATE TABLE IF NOT EXISTS baton_run_links (
-  parent_run_id TEXT NOT NULL REFERENCES baton_runs(run_id),
-  child_run_id TEXT NOT NULL REFERENCES baton_runs(run_id),
+    `CREATE TABLE IF NOT EXISTS tenetkit_run_links (
+  parent_run_id TEXT NOT NULL REFERENCES tenetkit_runs(run_id),
+  child_run_id TEXT NOT NULL REFERENCES tenetkit_runs(run_id),
   invocation_id TEXT NOT NULL,
   readiness TEXT NOT NULL,
   terminal_event_id TEXT,
@@ -107,10 +107,10 @@ export const V7_SCHEMA_STATEMENTS = [
   PRIMARY KEY (parent_run_id, child_run_id),
   UNIQUE (child_run_id)
 )`,
-    `CREATE INDEX IF NOT EXISTS baton_run_links_readiness_idx ON baton_run_links(parent_run_id, readiness, created_at, child_run_id)`,
-    `CREATE TABLE IF NOT EXISTS baton_run_steering (
+    `CREATE INDEX IF NOT EXISTS tenetkit_run_links_readiness_idx ON tenetkit_run_links(parent_run_id, readiness, created_at, child_run_id)`,
+    `CREATE TABLE IF NOT EXISTS tenetkit_run_steering (
   entry_id TEXT PRIMARY KEY,
-  run_id TEXT NOT NULL REFERENCES baton_runs(run_id),
+  run_id TEXT NOT NULL REFERENCES tenetkit_runs(run_id),
   sequence BIGINT NOT NULL,
   idempotency_key TEXT NOT NULL,
   digest TEXT NOT NULL,
@@ -120,16 +120,16 @@ export const V7_SCHEMA_STATEMENTS = [
   UNIQUE (run_id, sequence),
   UNIQUE (run_id, idempotency_key)
 )`,
-    `CREATE INDEX IF NOT EXISTS baton_run_steering_pending_idx
-    ON baton_run_steering(run_id, sequence) WHERE consumed_operation_id IS NULL AND discarded_reason IS NULL`,
-    `CREATE TABLE IF NOT EXISTS baton_agent_names (
+    `CREATE INDEX IF NOT EXISTS tenetkit_run_steering_pending_idx
+    ON tenetkit_run_steering(run_id, sequence) WHERE consumed_operation_id IS NULL AND discarded_reason IS NULL`,
+    `CREATE TABLE IF NOT EXISTS tenetkit_agent_names (
   scope TEXT NOT NULL,
   name TEXT NOT NULL,
-  run_id TEXT NOT NULL REFERENCES baton_runs(run_id),
+  run_id TEXT NOT NULL REFERENCES tenetkit_runs(run_id),
   PRIMARY KEY (scope, name)
 )`,
-    `CREATE INDEX IF NOT EXISTS baton_agent_names_run_idx ON baton_agent_names(run_id)`,
-    `CREATE TABLE IF NOT EXISTS baton_messages (
+    `CREATE INDEX IF NOT EXISTS tenetkit_agent_names_run_idx ON tenetkit_agent_names(run_id)`,
+    `CREATE TABLE IF NOT EXISTS tenetkit_messages (
   entry_id TEXT PRIMARY KEY,
   target_session_id TEXT NOT NULL,
   sequence BIGINT NOT NULL,
@@ -151,17 +151,17 @@ export const V7_SCHEMA_STATEMENTS = [
   UNIQUE (target_session_id, message_id, idempotency_key),
   UNIQUE (target_session_id, sequence)
 )`,
-    `CREATE INDEX IF NOT EXISTS baton_messages_pending_idx
-    ON baton_messages(target_session_id, sequence) WHERE delivered_run_id IS NULL`,
-    `CREATE INDEX IF NOT EXISTS baton_runs_claim_idx
-    ON baton_runs(status, lease_expires_at)
+    `CREATE INDEX IF NOT EXISTS tenetkit_messages_pending_idx
+    ON tenetkit_messages(target_session_id, sequence) WHERE delivered_run_id IS NULL`,
+    `CREATE INDEX IF NOT EXISTS tenetkit_runs_claim_idx
+    ON tenetkit_runs(status, lease_expires_at)
     WHERE status IN ('queued', 'running', 'waiting', 'needs-resolution', 'cancelling')`,
-    `CREATE INDEX IF NOT EXISTS baton_lanes_head_idx ON baton_lanes(head_run_id)`,
-    `CREATE INDEX IF NOT EXISTS baton_run_operations_status_idx ON baton_run_operations(status)`,
-    `CREATE INDEX IF NOT EXISTS baton_run_waits_due_idx ON baton_run_waits(status, due_at)`,
-    `CREATE TABLE IF NOT EXISTS baton_fan_outs (
+    `CREATE INDEX IF NOT EXISTS tenetkit_lanes_head_idx ON tenetkit_lanes(head_run_id)`,
+    `CREATE INDEX IF NOT EXISTS tenetkit_run_operations_status_idx ON tenetkit_run_operations(status)`,
+    `CREATE INDEX IF NOT EXISTS tenetkit_run_waits_due_idx ON tenetkit_run_waits(status, due_at)`,
+    `CREATE TABLE IF NOT EXISTS tenetkit_fan_outs (
   fan_out_id TEXT PRIMARY KEY,
-  parent_run_id TEXT NOT NULL REFERENCES baton_runs(run_id),
+  parent_run_id TEXT NOT NULL REFERENCES tenetkit_runs(run_id),
   idempotency_key TEXT NOT NULL,
   input_digest TEXT NOT NULL,
   join_json TEXT NOT NULL,
@@ -172,15 +172,15 @@ export const V7_SCHEMA_STATEMENTS = [
   updated_at TIMESTAMPTZ NOT NULL,
   UNIQUE (parent_run_id, idempotency_key)
 )`,
-    `CREATE TABLE IF NOT EXISTS baton_fan_out_members (
-  fan_out_id TEXT NOT NULL REFERENCES baton_fan_outs(fan_out_id),
+    `CREATE TABLE IF NOT EXISTS tenetkit_fan_out_members (
+  fan_out_id TEXT NOT NULL REFERENCES tenetkit_fan_outs(fan_out_id),
   ordinal INTEGER NOT NULL,
   member_key TEXT NOT NULL,
   selection TEXT NOT NULL,
   display_label TEXT,
   prompt_json TEXT NOT NULL,
   origin_json TEXT,
-  child_run_id TEXT NOT NULL UNIQUE REFERENCES baton_runs(run_id),
+  child_run_id TEXT NOT NULL UNIQUE REFERENCES tenetkit_runs(run_id),
   depth INTEGER NOT NULL,
   status TEXT NOT NULL,
   terminal_event_id TEXT,
@@ -188,24 +188,24 @@ export const V7_SCHEMA_STATEMENTS = [
   PRIMARY KEY (fan_out_id, ordinal),
   UNIQUE (fan_out_id, member_key)
 )`,
-    `CREATE INDEX IF NOT EXISTS baton_fan_out_members_status_idx ON baton_fan_out_members(fan_out_id, status, ordinal)`,
-    `CREATE TABLE IF NOT EXISTS baton_tree_roots (
-  root_run_id TEXT PRIMARY KEY REFERENCES baton_runs(run_id),
+    `CREATE INDEX IF NOT EXISTS tenetkit_fan_out_members_status_idx ON tenetkit_fan_out_members(fan_out_id, status, ordinal)`,
+    `CREATE TABLE IF NOT EXISTS tenetkit_tree_roots (
+  root_run_id TEXT PRIMARY KEY REFERENCES tenetkit_runs(run_id),
   earliest_position BIGINT NOT NULL DEFAULT 0,
   last_position BIGINT NOT NULL DEFAULT -1
 )`,
-    `CREATE TABLE IF NOT EXISTS baton_tree_event_index (
-  root_run_id TEXT NOT NULL REFERENCES baton_tree_roots(root_run_id),
+    `CREATE TABLE IF NOT EXISTS tenetkit_tree_event_index (
+  root_run_id TEXT NOT NULL REFERENCES tenetkit_tree_roots(root_run_id),
   position BIGINT NOT NULL,
   run_id TEXT NOT NULL,
   run_sequence INTEGER NOT NULL,
-  event_id TEXT NOT NULL UNIQUE REFERENCES baton_run_events(event_id),
+  event_id TEXT NOT NULL UNIQUE REFERENCES tenetkit_run_events(event_id),
   PRIMARY KEY (root_run_id, position),
   UNIQUE (run_id, run_sequence),
-  FOREIGN KEY (run_id, run_sequence) REFERENCES baton_run_events(run_id, sequence)
+  FOREIGN KEY (run_id, run_sequence) REFERENCES tenetkit_run_events(run_id, sequence)
   )`,
-    `CREATE TABLE IF NOT EXISTS baton_program_runs (
-  run_id TEXT PRIMARY KEY REFERENCES baton_runs(run_id),
+    `CREATE TABLE IF NOT EXISTS tenetkit_program_runs (
+  run_id TEXT PRIMARY KEY REFERENCES tenetkit_runs(run_id),
   program_pin TEXT NOT NULL,
   budget_json TEXT NOT NULL,
   deadline_millis BIGINT NOT NULL,
@@ -215,8 +215,8 @@ export const V7_SCHEMA_STATEMENTS = [
   log_bytes BIGINT NOT NULL DEFAULT 0,
   active_slots BIGINT NOT NULL DEFAULT 0
 )`,
-    `CREATE TABLE IF NOT EXISTS baton_program_operations (
-  run_id TEXT NOT NULL REFERENCES baton_program_runs(run_id),
+    `CREATE TABLE IF NOT EXISTS tenetkit_program_operations (
+  run_id TEXT NOT NULL REFERENCES tenetkit_program_runs(run_id),
   operation_name TEXT NOT NULL,
   kind TEXT NOT NULL,
   capability TEXT NOT NULL,
@@ -233,27 +233,27 @@ export const V7_SCHEMA_STATEMENTS = [
   resolution_json TEXT,
   PRIMARY KEY (run_id, operation_name)
 )`,
-    `CREATE TABLE IF NOT EXISTS baton_executable_registrations (
+    `CREATE TABLE IF NOT EXISTS tenetkit_executable_registrations (
   pin TEXT PRIMARY KEY,
   codec TEXT NOT NULL,
   version TEXT NOT NULL,
   payload_json TEXT NOT NULL,
   registration_digest TEXT NOT NULL
 )`,
-    `CREATE TABLE IF NOT EXISTS baton_run_registrations (
-  run_id TEXT NOT NULL REFERENCES baton_runs(run_id),
-  pin TEXT NOT NULL REFERENCES baton_executable_registrations(pin),
+    `CREATE TABLE IF NOT EXISTS tenetkit_run_registrations (
+  run_id TEXT NOT NULL REFERENCES tenetkit_runs(run_id),
+  pin TEXT NOT NULL REFERENCES tenetkit_executable_registrations(pin),
   PRIMARY KEY (run_id, pin)
   )`,
-    `CREATE INDEX IF NOT EXISTS baton_run_registrations_pin_idx ON baton_run_registrations(pin)`,
-    `CREATE TABLE IF NOT EXISTS baton_sessions (
+    `CREATE INDEX IF NOT EXISTS tenetkit_run_registrations_pin_idx ON tenetkit_run_registrations(pin)`,
+    `CREATE TABLE IF NOT EXISTS tenetkit_sessions (
   session_id TEXT PRIMARY KEY,
   leaf_id TEXT,
   next_seq BIGINT NOT NULL DEFAULT 0,
   owner_token TEXT,
   updated_at TIMESTAMPTZ NOT NULL
 )`,
-    `CREATE TABLE IF NOT EXISTS baton_session_entries (
+    `CREATE TABLE IF NOT EXISTS tenetkit_session_entries (
   session_id TEXT NOT NULL,
   entry_id TEXT NOT NULL,
   parent_id TEXT,
@@ -263,13 +263,11 @@ export const V7_SCHEMA_STATEMENTS = [
   created_at TIMESTAMPTZ NOT NULL,
   PRIMARY KEY (session_id, entry_id)
 )`,
-    `CREATE UNIQUE INDEX IF NOT EXISTS baton_session_entries_seq_idx ON baton_session_entries(session_id, seq)`,
-    `CREATE INDEX IF NOT EXISTS baton_session_entries_parent_idx ON baton_session_entries(session_id, parent_id)`,
-];
-export const EXTERNAL_CHILD_STATEMENTS = [
-    `CREATE TABLE IF NOT EXISTS baton_external_child_placements (
+    `CREATE UNIQUE INDEX IF NOT EXISTS tenetkit_session_entries_seq_idx ON tenetkit_session_entries(session_id, seq)`,
+    `CREATE INDEX IF NOT EXISTS tenetkit_session_entries_parent_idx ON tenetkit_session_entries(session_id, parent_id)`,
+    `CREATE TABLE IF NOT EXISTS tenetkit_external_child_placements (
   placement_id TEXT PRIMARY KEY,
-  parent_run_id TEXT NOT NULL REFERENCES baton_runs(run_id),
+  parent_run_id TEXT NOT NULL REFERENCES tenetkit_runs(run_id),
   partition TEXT NOT NULL,
   external_run_id TEXT NOT NULL,
   invocation_id TEXT NOT NULL,
@@ -289,10 +287,10 @@ export const EXTERNAL_CHILD_STATEMENTS = [
   CHECK ((settlement_id IS NULL AND outcome_json IS NULL AND outcome_event_id IS NULL AND settled_at IS NULL)
     OR (settlement_id IS NOT NULL AND outcome_json IS NOT NULL AND outcome_event_id IS NOT NULL AND settled_at IS NOT NULL))
 )`,
-    `CREATE INDEX IF NOT EXISTS baton_external_child_placements_parent_idx
-    ON baton_external_child_placements(parent_run_id, settlement_id, created_at)`,
+    `CREATE INDEX IF NOT EXISTS tenetkit_external_child_placements_parent_idx
+    ON tenetkit_external_child_placements(parent_run_id, settlement_id, created_at)`,
 ];
-export const SCHEMA_STATEMENTS = [...V7_SCHEMA_STATEMENTS, ...EXTERNAL_CHILD_STATEMENTS];
+export const SCHEMA_TABLES = SCHEMA_STATEMENTS.flatMap((statement) => statement.match(/^CREATE TABLE IF NOT EXISTS (\w+)/)?.slice(1, 2) ?? []);
 export const schemaChecksum = () => {
     const hasher = new Bun.CryptoHasher("sha256");
     hasher.update(SCHEMA_STATEMENTS.join("\n"));

package/dist/postgres/session-storage.js

@@ -6,12 +6,12 @@ const { encodePayload, entryPayloadEquivalence, pathFromRows, requireActive, sto
 const lockSession = (sessionId) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     yield* sql `
-      INSERT INTO baton_sessions (session_id, leaf_id, next_seq, owner_token, updated_at)
+      INSERT INTO tenetkit_sessions (session_id, leaf_id, next_seq, owner_token, updated_at)
       VALUES (${sessionId}, NULL, 0, NULL, NOW())
       ON CONFLICT (session_id) DO NOTHING
     `;
     const rows = yield* sql `
-      SELECT leaf_id, next_seq, owner_token FROM baton_sessions
+      SELECT leaf_id, next_seq, owner_token FROM tenetkit_sessions
       WHERE session_id = ${sessionId}
       FOR UPDATE
     `;
@@ -21,14 +21,14 @@ const lockSession = (sessionId) => Effect.gen(function* () {
 const loadEntries = (sessionId) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     return yield* sql `
-      SELECT entry_id, parent_id, seq, tag, payload_json FROM baton_session_entries
+      SELECT entry_id, parent_id, seq, tag, payload_json FROM tenetkit_session_entries
       WHERE session_id = ${sessionId} ORDER BY seq
     `;
 });
 const insertEntry = (input) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     yield* sql `
-      INSERT INTO baton_session_entries (session_id, entry_id, parent_id, seq, tag, payload_json, created_at)
+      INSERT INTO tenetkit_session_entries (session_id, entry_id, parent_id, seq, tag, payload_json, created_at)
       VALUES (${input.sessionId}, ${input.id}, ${input.parentId}, ${input.seq}, ${input.tag},
         ${encodePayload(input.payload)}, NOW())
     `;
@@ -37,13 +37,13 @@ const advanceSession = (input) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     if (input.ownerToken === undefined) {
         yield* sql `
-        UPDATE baton_sessions SET leaf_id = ${input.leafId}, next_seq = ${input.nextSeq}, updated_at = NOW()
+        UPDATE tenetkit_sessions SET leaf_id = ${input.leafId}, next_seq = ${input.nextSeq}, updated_at = NOW()
         WHERE session_id = ${input.sessionId}
       `;
     }
     else {
         yield* sql `
-        UPDATE baton_sessions SET leaf_id = ${input.leafId}, next_seq = ${input.nextSeq},
+        UPDATE tenetkit_sessions SET leaf_id = ${input.leafId}, next_seq = ${input.nextSeq},
           owner_token = ${input.ownerToken}, updated_at = NOW()
         WHERE session_id = ${input.sessionId}
       `;

package/dist/postgres/session-store.js

@@ -21,7 +21,7 @@ export const appendCompletedSessionEntry = (input) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     const session = yield* lockSession(input.sessionId);
     const rows = yield* sql `
-      SELECT entry_id, parent_id, seq, tag, payload_json FROM baton_session_entries
+      SELECT entry_id, parent_id, seq, tag, payload_json FROM tenetkit_session_entries
       WHERE session_id = ${input.sessionId} AND entry_id = ${input.entryId}
     `;
     const existing = rows[0];
@@ -65,7 +65,7 @@ export const verifyCompletedSessionEntry = (input) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     const session = yield* lockSession(input.sessionId);
     const rows = yield* sql `
-      SELECT entry_id, parent_id, seq, tag, payload_json FROM baton_session_entries
+      SELECT entry_id, parent_id, seq, tag, payload_json FROM tenetkit_session_entries
       WHERE session_id = ${input.sessionId} AND entry_id = ${input.entryId}
     `;
     const existing = rows[0];
@@ -86,7 +86,7 @@ export const appendInterruptedSessionEntry = (input) => Effect.gen(function* ()
     const sql = yield* SqlClient.SqlClient;
     const session = yield* lockSession(input.sessionId);
     const rows = yield* sql `
-      SELECT entry_id, parent_id, seq, tag, payload_json FROM baton_session_entries
+      SELECT entry_id, parent_id, seq, tag, payload_json FROM tenetkit_session_entries
       WHERE session_id = ${input.sessionId} AND entry_id = ${input.entryId}
     `;
     const existing = rows[0];
@@ -129,7 +129,7 @@ export const verifyInterruptedSessionEntry = (input) => Effect.gen(function* ()
     const sql = yield* SqlClient.SqlClient;
     const session = yield* lockSession(input.sessionId);
     const rows = yield* sql `
-      SELECT entry_id, parent_id, seq, tag, payload_json FROM baton_session_entries
+      SELECT entry_id, parent_id, seq, tag, payload_json FROM tenetkit_session_entries
       WHERE session_id = ${input.sessionId} AND entry_id = ${input.entryId}
     `;
     const existing = rows[0];
@@ -150,7 +150,7 @@ export const appendHandoffSessionEntry = (input) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     const session = yield* lockSession(input.sessionId);
     const rows = yield* sql `
-      SELECT entry_id, parent_id, seq, tag, payload_json FROM baton_session_entries
+      SELECT entry_id, parent_id, seq, tag, payload_json FROM tenetkit_session_entries
       WHERE session_id = ${input.sessionId} AND entry_id = ${input.entryId}
     `;
     const existing = rows[0];
@@ -193,7 +193,7 @@ export const verifyHandoffSessionEntry = (input) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     const session = yield* lockSession(input.sessionId);
     const rows = yield* sql `
-      SELECT entry_id, parent_id, seq, tag, payload_json FROM baton_session_entries
+      SELECT entry_id, parent_id, seq, tag, payload_json FROM tenetkit_session_entries
       WHERE session_id = ${input.sessionId} AND entry_id = ${input.entryId}
     `;
     const existing = rows[0];
@@ -221,7 +221,7 @@ export const makePostgresSessionStore = (options) => {
         const session = yield* lockSession(sessionId);
         if (appendOptions?.id !== undefined) {
             const rows = yield* sql `
-          SELECT entry_id, parent_id, seq, tag, payload_json FROM baton_session_entries
+          SELECT entry_id, parent_id, seq, tag, payload_json FROM tenetkit_session_entries
           WHERE session_id = ${sessionId} AND entry_id = ${appendOptions.id}
         `;
             const existing = rows[0];
@@ -249,7 +249,7 @@ export const makePostgresSessionStore = (options) => {
         if (appendOptions?.id === undefined) {
             while (true) {
                 const collision = yield* sql `
-            SELECT entry_id FROM baton_session_entries
+            SELECT entry_id FROM tenetkit_session_entries
             WHERE session_id = ${sessionId} AND entry_id = ${String(generatedSequence)}
           `;
                 if (collision[0] === undefined)
@@ -278,7 +278,7 @@ export const makePostgresSessionStore = (options) => {
         const sql = yield* SqlClient.SqlClient;
         const session = yield* lockSession(sessionId);
         const rows = yield* sql `
-        SELECT entry_id, parent_id, seq, tag, payload_json FROM baton_session_entries
+        SELECT entry_id, parent_id, seq, tag, payload_json FROM tenetkit_session_entries
         WHERE session_id = ${sessionId} AND entry_id = ${prepared.id}
       `;
         const existing = rows[0];
@@ -343,7 +343,7 @@ export const makePostgresSessionStore = (options) => {
             let sequence = Number(session.next_seq);
             while (true) {
                 const collision = yield* sql `
-            SELECT entry_id FROM baton_session_entries
+            SELECT entry_id FROM tenetkit_session_entries
             WHERE session_id = ${sessionId} AND entry_id = ${String(sequence)}
           `;
                 if (collision[0] === undefined)
@@ -358,7 +358,7 @@ export const makePostgresSessionStore = (options) => {
         path: (leaf) => runNoTxn(Effect.gen(function* () {
             const sql = yield* SqlClient.SqlClient;
             const sessions = yield* sql `
-            SELECT leaf_id, next_seq, owner_token FROM baton_sessions WHERE session_id = ${sessionId}
+            SELECT leaf_id, next_seq, owner_token FROM tenetkit_sessions WHERE session_id = ${sessionId}
           `;
             return { target: leaf ?? sessions[0]?.leaf_id ?? null, rows: yield* loadEntries(sessionId) };
         }).pipe(Effect.flatMap(({ rows, target }) => {
@@ -370,17 +370,17 @@ export const makePostgresSessionStore = (options) => {
             yield* lockSession(sessionId);
             if (id !== null) {
                 const rows = yield* sql `
-              SELECT entry_id FROM baton_session_entries WHERE session_id = ${sessionId} AND entry_id = ${id}
+              SELECT entry_id FROM tenetkit_session_entries WHERE session_id = ${sessionId} AND entry_id = ${id}
             `;
                 if (rows[0] === undefined)
                     return yield* storeError(`Session entry ${id} does not exist`);
             }
-            yield* sql `UPDATE baton_sessions SET leaf_id = ${id}, updated_at = NOW() WHERE session_id = ${sessionId}`;
+            yield* sql `UPDATE tenetkit_sessions SET leaf_id = ${id}, updated_at = NOW() WHERE session_id = ${sessionId}`;
         })).pipe(mapReadError),
         leaf: Effect.orDie(runNoTxn(Effect.gen(function* () {
             const sql = yield* SqlClient.SqlClient;
             const rows = yield* sql `
-            SELECT leaf_id, next_seq, owner_token FROM baton_sessions WHERE session_id = ${sessionId}
+            SELECT leaf_id, next_seq, owner_token FROM tenetkit_sessions WHERE session_id = ${sessionId}
           `;
             return rows[0]?.leaf_id ?? null;
         }))),

package/dist/postgres/store-admit.js

@@ -28,7 +28,7 @@ export const admitSend = Function.dual(4, (hub, addressBindings, nextId, input)
     const treePolicy = yield* normalizeTreePolicy(input.treePolicy);
     const digest = rootDigest(input.message, treePolicy);
     const existing = yield* sql `
-      SELECT * FROM baton_runs
+      SELECT * FROM tenetkit_runs
       WHERE address = ${input.message.to}
         AND session_id = ${input.message.sessionId}
         AND idempotency_key = ${input.message.idempotencyKey}
@@ -55,7 +55,7 @@ export const admitSend = Function.dual(4, (hub, addressBindings, nextId, input)
         };
     }
     if (input.runId !== undefined) {
-        const byId = yield* sql `SELECT * FROM baton_runs WHERE run_id = ${input.runId}`;
+        const byId = yield* sql `SELECT * FROM tenetkit_runs WHERE run_id = ${input.runId}`;
         if (byId[0] !== undefined)
             return yield* RunIdConflict.make({ runId: input.runId, existingRunId: byId[0].run_id });
     }

package/dist/postgres/store-cancel.js

@@ -7,11 +7,11 @@ import { cancelOwnedFanOuts } from "./store-fan-out.js";
 import { reconcileProgramCancellation } from "tenetkit/runtime/driver/sql/store-program";
 export const deferCancelledFanOutParent = Function.dual(2, (sql, runId) => Effect.gen(function* () {
     const running = yield* sql `
-      SELECT fan_out_id FROM baton_fan_outs WHERE parent_run_id = ${runId} AND status = 'running' LIMIT 1
+      SELECT fan_out_id FROM tenetkit_fan_outs WHERE parent_run_id = ${runId} AND status = 'running' LIMIT 1
     `;
     if (running.length === 0 && !(yield* hasUnsettledChild(runId)))
         return false;
-    yield* sql `UPDATE baton_runs SET owner_worker_id = NULL, lease_expires_at = NULL WHERE run_id = ${runId}`;
+    yield* sql `UPDATE tenetkit_runs SET owner_worker_id = NULL, lease_expires_at = NULL WHERE run_id = ${runId}`;
     return true;
 }));
 export const makeCancelRun = (input) => {
@@ -27,12 +27,12 @@ export const makeCancelRun = (input) => {
         if (!terminal)
             yield* reconcileProgramCancellation(runId, reason ?? current.cancelReason);
         yield* input.sql `
-        UPDATE baton_run_waits SET status = 'cancelled', closed_at = NOW()
+        UPDATE tenetkit_run_waits SET status = 'cancelled', closed_at = NOW()
         WHERE run_id = ${runId} AND status = 'open'
       `;
         const linked = yield* input.sql `
-        SELECT l.child_run_id FROM baton_run_links l
-        LEFT JOIN baton_fan_out_members m ON m.child_run_id = l.child_run_id
+        SELECT l.child_run_id FROM tenetkit_run_links l
+        LEFT JOIN tenetkit_fan_out_members m ON m.child_run_id = l.child_run_id
         WHERE l.parent_run_id = ${runId} AND m.child_run_id IS NULL
         ORDER BY l.child_run_id ASC
       `;
@@ -58,7 +58,7 @@ export const makeCancelRun = (input) => {
         if (isTerminal(current.status))
             return;
         const running = yield* input.sql `
-        SELECT fan_out_id FROM baton_fan_outs WHERE parent_run_id = ${runId} AND status = 'running' LIMIT 1
+        SELECT fan_out_id FROM tenetkit_fan_outs WHERE parent_run_id = ${runId} AND status = 'running' LIMIT 1
       `;
         if (running.length > 0)
             return;

package/dist/postgres/store-fan-out.js

@@ -3,14 +3,14 @@ import { admitFanOut, inspectFanOut } from "tenetkit/runtime/driver/sql/store-fa
 import { NOTIFY_CHANNEL } from "./schema.js";
 export const fanOutStoreMethods = (input) => ({
     admitFanOut: (fanOut) => input
-        .run(input.sql `SELECT run_id FROM baton_runs WHERE run_id = ${fanOut.parentRunId} FOR UPDATE`.pipe(Effect.andThen(input.sql `SELECT pg_advisory_xact_lock(hashtext(${`fanout:${fanOut.parentRunId}:${fanOut.idempotencyKey}`}))`), Effect.andThen(admitFanOut(input.hub, fanOut))))
+        .run(input.sql `SELECT run_id FROM tenetkit_runs WHERE run_id = ${fanOut.parentRunId} FOR UPDATE`.pipe(Effect.andThen(input.sql `SELECT pg_advisory_xact_lock(hashtext(${`fanout:${fanOut.parentRunId}:${fanOut.idempotencyKey}`}))`), Effect.andThen(admitFanOut(input.hub, fanOut))))
         .pipe(Effect.tap((receipt) => input.runNoTxn(Effect.forEach([receipt.parentRunId, ...receipt.childRunIds], (runId) => input.pg.notify(NOTIFY_CHANNEL, runId), { discard: true })))),
     inspectFanOut: (fanOutId) => input.runNoTxn(inspectFanOut(fanOutId)),
 });
 export const cancelOwnedFanOuts = Function.dual(2, (sql, parentRunId) => Effect.gen(function* () {
     const owned = yield* sql `
-      SELECT m.child_run_id FROM baton_fan_outs f
-      JOIN baton_fan_out_members m ON m.fan_out_id = f.fan_out_id
+      SELECT m.child_run_id FROM tenetkit_fan_outs f
+      JOIN tenetkit_fan_out_members m ON m.fan_out_id = f.fan_out_id
       WHERE f.parent_run_id = ${parentRunId} AND f.status = 'running' ORDER BY m.ordinal ASC
     `;
     return owned.map((row) => row.child_run_id);

package/dist/postgres/store-model-response.js

@@ -11,12 +11,12 @@ import { sameInterruptedModelOutcome, sameInterruptedModelResponse, validateInte
 import { appendCompletedSessionEntry, appendInterruptedSessionEntry, verifyCompletedSessionEntry, verifyInterruptedSessionEntry, } from "./session-store.js";
 export const postgresModelResponseOperations = (input) => {
     const { sql, hub, run, requireRun, requireClaim } = input;
-    const fenced = (claim, effect) => run(sql `SELECT run_id FROM baton_runs WHERE run_id = ${claim.runId} FOR UPDATE`.pipe(Effect.andThen(requireClaim(claim)), Effect.andThen(effect)));
+    const fenced = (claim, effect) => run(sql `SELECT run_id FROM tenetkit_runs WHERE run_id = ${claim.runId} FOR UPDATE`.pipe(Effect.andThen(requireClaim(claim)), Effect.andThen(effect)));
     return {
         commitInterruptedModelResponse: (op) => fenced(op, Effect.gen(function* () {
             const loaded = yield* requireRun(op.runId);
             const rows = yield* sql `
-            SELECT * FROM baton_run_operations
+            SELECT * FROM tenetkit_run_operations
             WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
             FOR UPDATE
           `;
@@ -58,20 +58,20 @@ export const postgresModelResponseOperations = (input) => {
             }
             yield* appendInterruptedSessionEntry(sessionEntry).pipe(Effect.mapError((error) => RuntimeUnavailable.make({ message: error.message })));
             yield* sql `
-            UPDATE baton_run_operations
+            UPDATE tenetkit_run_operations
             SET status = 'failed', error_json = ${encodeJsonValue(op.outcome.error)}, finished_at = NOW()
             WHERE run_id = ${op.runId} AND operation_id = ${op.operationId} AND status = 'running'
           `;
             yield* appendEvent(hub, yield* requireRun(op.runId), validated.event);
             const completed = yield* sql `
-            SELECT * FROM baton_run_operations WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
+            SELECT * FROM tenetkit_run_operations WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
           `;
             return toOperationRecord(completed[0]);
         })),
         commitModelResponse: (op) => fenced(op, Effect.gen(function* () {
             const loaded = yield* requireRun(op.runId);
             const existing = yield* sql `
-            SELECT * FROM baton_run_operations
+            SELECT * FROM tenetkit_run_operations
             WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
             FOR UPDATE
           `;
@@ -116,7 +116,7 @@ export const postgresModelResponseOperations = (input) => {
             }
             for (const entryId of new Set(op.steeringEntryIds ?? [])) {
                 const rows = yield* sql `
-              SELECT consumed_operation_id FROM baton_run_steering
+              SELECT consumed_operation_id FROM tenetkit_run_steering
               WHERE run_id = ${op.runId} AND entry_id = ${entryId}
             `;
                 if (rows[0]?.consumed_operation_id !== op.operationId) {
@@ -131,13 +131,13 @@ export const postgresModelResponseOperations = (input) => {
             });
             yield* appendCompletedSessionEntry(sessionEntry).pipe(Effect.mapError((error) => RuntimeUnavailable.make({ message: error.message })));
             yield* sql `
-            UPDATE baton_run_operations
+            UPDATE tenetkit_run_operations
             SET status = 'succeeded', result_json = ${encodeJsonValue(validated.reference)}, finished_at = NOW()
             WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
               AND status IN ('requested', 'running')
           `;
             yield* sql `
-            UPDATE baton_runs SET
+            UPDATE tenetkit_runs SET
               driver_checkpoint_json = COALESCE(${op.checkpoint === undefined ? null : encodeJson(ExecutionCheckpoint, op.checkpoint)}, driver_checkpoint_json),
               executable_ref_json = ${encodeExecutableRef(executableRef)},
               continuation_json = CASE WHEN ${op.continuation === undefined ? 0 : 1} = 1
@@ -148,7 +148,7 @@ export const postgresModelResponseOperations = (input) => {
           `;
             yield* appendEvent(hub, yield* requireRun(op.runId), validated.event);
             const rows = yield* sql `
-            SELECT * FROM baton_run_operations WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
+            SELECT * FROM tenetkit_run_operations WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
           `;
             return toOperationRecord(rows[0]);
         })),