@tenetkit/pg 0.31.0 → 0.33.0

package/dist/postgres/claims.js

@@ -8,13 +8,13 @@ export const claimReadyRuns = (options) => Effect.gen(function* () {
     const claimed = yield* sql `
       WITH candidates AS (
         SELECT r.run_id
-        FROM baton_runs r
+        FROM tenetkit_runs r
         WHERE r.status IN ('queued', 'running', 'cancelling')
           AND r.cancellation_requested = FALSE
           AND (
-            (r.parent_run_id IS NULL AND EXISTS (SELECT 1 FROM baton_lanes l WHERE l.head_run_id = r.run_id))
+            (r.parent_run_id IS NULL AND EXISTS (SELECT 1 FROM tenetkit_lanes l WHERE l.head_run_id = r.run_id))
             OR EXISTS (
-              SELECT 1 FROM baton_run_links link
+              SELECT 1 FROM tenetkit_run_links link
               WHERE link.child_run_id = r.run_id AND link.readiness = 'ready'
             )
           )
@@ -27,7 +27,7 @@ export const claimReadyRuns = (options) => Effect.gen(function* () {
         FOR UPDATE OF r SKIP LOCKED
         LIMIT ${options.limit}
       )
-      UPDATE baton_runs AS r
+      UPDATE tenetkit_runs AS r
       SET
         owner_worker_id = ${options.workerId},
         lease_expires_at = NOW() + (${leaseMs}::double precision * INTERVAL '1 millisecond'),
@@ -61,7 +61,7 @@ export const refreshLease = (input) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     const leaseMs = Duration.toMillis(input.lease);
     const rows = yield* sql `
-      UPDATE baton_runs
+      UPDATE tenetkit_runs
       SET
         lease_expires_at = NOW() + (${leaseMs}::double precision * INTERVAL '1 millisecond'),
         updated_at = NOW()
@@ -86,7 +86,7 @@ export const requireClaim = (input) => Effect.gen(function* () {
 export const releaseClaim = (input) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     yield* sql `
-      UPDATE baton_runs
+      UPDATE tenetkit_runs
       SET owner_worker_id = NULL, lease_expires_at = NULL, updated_at = NOW()
       WHERE run_id = ${input.runId}
         AND owner_worker_id = ${input.workerId}

package/dist/postgres/locks.js

@@ -11,7 +11,7 @@ import { loadRun } from "./pg-helpers.js";
 export const lockRun = (runId) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     yield* sql `SELECT pg_advisory_xact_lock(hashtext(${`run:${runId}`}))`;
-    yield* sql `SELECT run_id FROM baton_runs WHERE run_id = ${runId} FOR UPDATE`;
+    yield* sql `SELECT run_id FROM tenetkit_runs WHERE run_id = ${runId} FOR UPDATE`;
 });
 export const lockRunHierarchy = (runId) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
@@ -19,7 +19,7 @@ export const lockRunHierarchy = (runId) => Effect.gen(function* () {
     let current = runId;
     while (true) {
         const row = (yield* sql `
-        SELECT parent_run_id FROM baton_runs WHERE run_id = ${current}
+        SELECT parent_run_id FROM tenetkit_runs WHERE run_id = ${current}
       `)[0];
         if (row?.parent_run_id === null || row?.parent_run_id === undefined)
             break;
@@ -41,7 +41,7 @@ export const lockMailbox = (targetSessionId) => Effect.gen(function* () {
 }).pipe(Effect.asVoid);
 export const lockSpawnParent = (runId) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
-    yield* sql `SELECT run_id FROM baton_runs WHERE run_id = ${runId} FOR UPDATE`;
+    yield* sql `SELECT run_id FROM tenetkit_runs WHERE run_id = ${runId} FOR UPDATE`;
     const parent = yield* loadRun(runId);
     if (parent === undefined)
         return yield* RunNotFound.make({ runId });

package/dist/postgres/pg-helpers.js

@@ -16,14 +16,14 @@ import { hasUnsettledChild, loadTerminalEvent, reconcileChildWaitWith, } from "t
 import { appendTerminalToolResultsForEvent } from "tenetkit/runtime/driver/sql/session-terminalization";
 export const loadRun = (runId) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
-    const rows = yield* sql `SELECT * FROM baton_runs WHERE run_id = ${runId}`;
+    const rows = yield* sql `SELECT * FROM tenetkit_runs WHERE run_id = ${runId}`;
     const row = rows[0];
     return row === undefined ? undefined : yield* decodeRunEffect(row);
 });
 export const requireRun = (runId) => loadRun(runId).pipe(Effect.flatMap((loaded) => loaded === undefined ? Effect.fail(RunNotFound.make({ runId })) : Effect.succeed(loaded)));
 export const emitAgentEvent = Function.dual(2, (hub, input) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
-    yield* sql `SELECT run_id FROM baton_runs WHERE run_id = ${input.runId} FOR UPDATE`;
+    yield* sql `SELECT run_id FROM tenetkit_runs WHERE run_id = ${input.runId} FOR UPDATE`;
     const loaded = yield* loadRun(input.runId);
     if (loaded === undefined)
         return yield* RunNotFound.make({ runId: input.runId });
@@ -38,7 +38,7 @@ export const emitAgentEvent = Function.dual(2, (hub, input) => Effect.gen(functi
         return yield* RunTerminal.make({ runId: loaded.runId, status: loaded.status });
     yield* appendEvent(hub, loaded, input.event);
     if (input.event._tag === "TurnCompleted") {
-        yield* sql `UPDATE baton_runs SET continuation_json = NULL WHERE run_id = ${loaded.runId}`;
+        yield* sql `UPDATE tenetkit_runs SET continuation_json = NULL WHERE run_id = ${loaded.runId}`;
     }
 }));
 export const loadEventsAfter = Function.dual(2, (runId, cursor) => Effect.gen(function* () {
@@ -47,7 +47,7 @@ export const loadEventsAfter = Function.dual(2, (runId, cursor) => Effect.gen(fu
     if (run === undefined)
         return [];
     const rows = yield* sql `
-      SELECT * FROM baton_run_events
+      SELECT * FROM tenetkit_run_events
       WHERE run_id = ${runId} AND sequence > ${cursor}
       ORDER BY sequence ASC
     `;
@@ -56,7 +56,7 @@ export const loadEventsAfter = Function.dual(2, (runId, cursor) => Effect.gen(fu
 export const allocateSequence = (runId) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     const rows = yield* sql `
-      UPDATE baton_runs
+      UPDATE tenetkit_runs
       SET last_sequence = last_sequence + 1, updated_at = NOW()
       WHERE run_id = ${runId}
       RETURNING last_sequence
@@ -90,15 +90,15 @@ export const appendEvent = Function.dual((args) => args.length >= 4 || (args.len
         ...partial,
     };
     yield* sql `
-      INSERT INTO baton_run_events (run_id, sequence, event_id, event_json)
+      INSERT INTO tenetkit_run_events (run_id, sequence, event_id, event_json)
       VALUES (${run.runId}, ${sequence}, ${event.eventId}, ${encodeEvent(event)})
     `;
     const treeRoot = (yield* sql `
-      UPDATE baton_tree_roots SET last_position = last_position + 1
+      UPDATE tenetkit_tree_roots SET last_position = last_position + 1
       WHERE root_run_id = ${run.rootRunId} RETURNING last_position
     `)[0];
     yield* sql `
-      INSERT INTO baton_tree_event_index (root_run_id, position, run_id, run_sequence, event_id)
+      INSERT INTO tenetkit_tree_event_index (root_run_id, position, run_id, run_sequence, event_id)
       VALUES (${run.rootRunId}, ${Number(treeRoot.last_position)}, ${run.runId}, ${sequence}, ${event.eventId})
     `;
     const status = nextStatus ?? run.status;
@@ -118,7 +118,7 @@ export const appendEvent = Function.dual((args) => args.length >= 4 || (args.len
     const terminalPartial = event._tag === "RunCompleted" || event._tag === "RunFailed" || event._tag === "RunCancelled";
     if (terminalPartial) {
         yield* sql `
-        UPDATE baton_runs SET
+        UPDATE tenetkit_runs SET
           status = ${status},
           active_wait_id = ${activeWaitId},
           terminal_event_id = ${terminalEventId},
@@ -137,7 +137,7 @@ export const appendEvent = Function.dual((args) => args.length >= 4 || (args.len
     }
     else {
         yield* sql `
-        UPDATE baton_runs SET
+        UPDATE tenetkit_runs SET
           status = ${status},
           active_wait_id = ${activeWaitId},
           terminal_event_id = ${terminalEventId},
@@ -154,7 +154,7 @@ export const appendEvent = Function.dual((args) => args.length >= 4 || (args.len
 export const promoteHead = Function.dual(3, (hub, address, sessionId) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     const lanes = yield* sql `
-      SELECT head_run_id, queue_json FROM baton_lanes
+      SELECT head_run_id, queue_json FROM tenetkit_lanes
       WHERE address = ${address} AND session_id = ${sessionId}
       FOR UPDATE
     `;
@@ -167,7 +167,7 @@ export const promoteHead = Function.dual(3, (hub, address, sessionId) => Effect.
         return;
     if (lane.head_run_id !== headId) {
         yield* sql `
-        UPDATE baton_lanes SET head_run_id = ${headId}
+        UPDATE tenetkit_lanes SET head_run_id = ${headId}
         WHERE address = ${address} AND session_id = ${sessionId}
       `;
     }
@@ -178,7 +178,7 @@ export const promoteHead = Function.dual(3, (hub, address, sessionId) => Effect.
 export const removeFromLane = Function.dual(3, (address, sessionId, runId) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     const lanes = yield* sql `
-      SELECT queue_json FROM baton_lanes
+      SELECT queue_json FROM tenetkit_lanes
       WHERE address = ${address} AND session_id = ${sessionId}
       FOR UPDATE
     `;
@@ -187,11 +187,11 @@ export const removeFromLane = Function.dual(3, (address, sessionId, runId) => Ef
         return;
     const queue = decodeQueue(lane.queue_json).filter((id) => id !== runId);
     if (queue.length === 0) {
-        yield* sql `DELETE FROM baton_lanes WHERE address = ${address} AND session_id = ${sessionId}`;
+        yield* sql `DELETE FROM tenetkit_lanes WHERE address = ${address} AND session_id = ${sessionId}`;
     }
     else {
         yield* sql `
-        UPDATE baton_lanes
+        UPDATE tenetkit_lanes
         SET queue_json = ${encodeQueue(queue)}, head_run_id = ${queue[0]}
         WHERE address = ${address} AND session_id = ${sessionId}
       `;
@@ -207,11 +207,11 @@ export const completeRun = Function.dual(3, (hub, run, result) => Effect.gen(fun
         return yield* RunTerminal.make({ runId: run.runId, status: run.status });
     if (run.cancellationRequested) {
         const runningFanOut = yield* sql `
-        SELECT fan_out_id FROM baton_fan_outs WHERE parent_run_id = ${run.runId} AND status = 'running' LIMIT 1
+        SELECT fan_out_id FROM tenetkit_fan_outs WHERE parent_run_id = ${run.runId} AND status = 'running' LIMIT 1
       `;
         if (runningFanOut.length > 0 || (yield* hasUnsettledChild(run.runId))) {
             yield* sql `
-          UPDATE baton_runs SET owner_worker_id = NULL, lease_expires_at = NULL WHERE run_id = ${run.runId}
+          UPDATE tenetkit_runs SET owner_worker_id = NULL, lease_expires_at = NULL WHERE run_id = ${run.runId}
         `;
             return;
         }
@@ -222,11 +222,11 @@ export const completeRun = Function.dual(3, (hub, run, result) => Effect.gen(fun
         return;
     }
     const runningFanOut = yield* sql `
-      SELECT fan_out_id FROM baton_fan_outs WHERE parent_run_id = ${run.runId} AND status = 'running' LIMIT 1
+      SELECT fan_out_id FROM tenetkit_fan_outs WHERE parent_run_id = ${run.runId} AND status = 'running' LIMIT 1
     `;
     if (runningFanOut.length > 0) {
         yield* sql `
-        UPDATE baton_runs SET status = 'waiting', owner_worker_id = NULL, lease_expires_at = NULL,
+        UPDATE tenetkit_runs SET status = 'waiting', owner_worker_id = NULL, lease_expires_at = NULL,
           suspension_json = NULL,
           pending_outcome_json = ${encodeJson(PendingRunOutcome, { _tag: "Completed", result })}
         WHERE run_id = ${run.runId}
@@ -242,18 +242,18 @@ export const settleParent = Function.dual(3, (hub, child, terminalEventId) => Ef
     if (child.parentRunId === undefined)
         return;
     const sql = yield* SqlClient.SqlClient;
-    yield* sql `SELECT run_id FROM baton_runs WHERE run_id = ${child.parentRunId} FOR UPDATE`;
+    yield* sql `SELECT run_id FROM tenetkit_runs WHERE run_id = ${child.parentRunId} FOR UPDATE`;
     const parent = yield* loadRun(child.parentRunId);
     if (parent === undefined)
         return;
     const existing = yield* sql `
-      SELECT child_run_id FROM baton_run_links
+      SELECT child_run_id FROM tenetkit_run_links
       WHERE parent_run_id = ${parent.runId} AND child_run_id = ${child.runId} AND terminal_event_id IS NOT NULL
     `;
     if (existing.length > 0)
         return;
     yield* sql `
-      UPDATE baton_run_links
+      UPDATE tenetkit_run_links
       SET readiness = 'settled', terminal_event_id = ${terminalEventId}, settled_at = NOW()
       WHERE parent_run_id = ${parent.runId} AND child_run_id = ${child.runId}
     `;
@@ -279,15 +279,15 @@ export const settleParent = Function.dual(3, (hub, child, terminalEventId) => Ef
     }
     if (currentParent?.status === "queued") {
         const unsettled = yield* sql `
-        SELECT l.child_run_id FROM baton_run_links l
-        JOIN baton_runs r ON r.run_id = l.child_run_id
+        SELECT l.child_run_id FROM tenetkit_run_links l
+        JOIN tenetkit_runs r ON r.run_id = l.child_run_id
         WHERE l.parent_run_id = ${parent.runId}
           AND r.status NOT IN ('succeeded', 'failed', 'cancelled')
         LIMIT 1
       `;
         if (unsettled.length === 0) {
             const attempt = currentParent.attempt + 1;
-            yield* sql `UPDATE baton_runs SET attempt_fence = ${attempt} WHERE run_id = ${parent.runId}`;
+            yield* sql `UPDATE tenetkit_runs SET attempt_fence = ${attempt} WHERE run_id = ${parent.runId}`;
             yield* appendEvent(hub, { ...currentParent, attempt }, { _tag: "RunAttemptStarted", attempt }, "running");
         }
         return;
@@ -295,7 +295,7 @@ export const settleParent = Function.dual(3, (hub, child, terminalEventId) => Ef
     if (currentParent?.status !== "cancelling" || currentParent.ownerWorkerId !== undefined)
         return;
     const running = yield* sql `
-      SELECT fan_out_id FROM baton_fan_outs WHERE parent_run_id = ${parent.runId} AND status = 'running' LIMIT 1
+      SELECT fan_out_id FROM tenetkit_fan_outs WHERE parent_run_id = ${parent.runId} AND status = 'running' LIMIT 1
     `;
     if (running.length > 0)
         return;
@@ -312,7 +312,7 @@ export const settleParent = Function.dual(3, (hub, child, terminalEventId) => Ef
 export const insertRun = (input) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     yield* sql `
-      INSERT INTO baton_runs (
+      INSERT INTO tenetkit_runs (
         run_id, status, address, session_id, message_id, message_json, message_digest, idempotency_key,
         executable_ref_json, executable_manifest_json, root_run_id, depth, max_depth, max_subagents, parent_run_id, invocation_id, active_wait_id, attempt, attempt_fence,
         last_sequence, cancellation_requested, cancel_reason, terminal_event_id, accepted_sequence,
@@ -327,20 +327,20 @@ export const insertRun = (input) => Effect.gen(function* () {
       )
     `;
     if (input.runId === input.rootRunId) {
-        yield* sql `INSERT INTO baton_tree_roots (root_run_id) VALUES (${input.runId})`;
+        yield* sql `INSERT INTO tenetkit_tree_roots (root_run_id) VALUES (${input.runId})`;
     }
 });
 export const enqueueLane = Function.dual(3, (address, sessionId, runId) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     const lanes = yield* sql `
-      SELECT accepted_sequence, queue_json, head_run_id FROM baton_lanes
+      SELECT accepted_sequence, queue_json, head_run_id FROM tenetkit_lanes
       WHERE address = ${address} AND session_id = ${sessionId}
       FOR UPDATE
     `;
     const lane = lanes[0];
     if (lane === undefined) {
         yield* sql `
-        INSERT INTO baton_lanes (address, session_id, accepted_sequence, queue_json, head_run_id)
+        INSERT INTO tenetkit_lanes (address, session_id, accepted_sequence, queue_json, head_run_id)
         VALUES (${address}, ${sessionId}, 0, ${encodeQueue([runId])}, ${runId})
       `;
         return { acceptedSequence: 0, isHead: true };
@@ -349,7 +349,7 @@ export const enqueueLane = Function.dual(3, (address, sessionId, runId) => Effec
     const queue = [...decodeQueue(lane.queue_json), runId];
     const head = lane.head_run_id ?? queue[0];
     yield* sql `
-      UPDATE baton_lanes
+      UPDATE tenetkit_lanes
       SET accepted_sequence = ${acceptedSequence}, queue_json = ${encodeQueue(queue)}, head_run_id = ${head}
       WHERE address = ${address} AND session_id = ${sessionId}
     `;

package/dist/postgres/run-schema.js

@@ -1,9 +1,13 @@
-import { DateTime, Effect, Layer, Redacted } from "effect";
+import { Cause, DateTime, Effect, Layer, Redacted } from "effect";
 import { Migrator, SqlClient } from "effect/unstable/sql";
 import { PgClient } from "@effect/sql-pg";
 import { SchemaChecksumMismatch, SchemaDirty, SchemaMigrationFailed, SchemaUpgradeRequired, SchemaVersionUnsupported, } from "tenetkit/runtime/driver/sql/errors";
 import { mapSqlError } from "tenetkit/runtime/driver/sql/sql-effect";
-import { MIGRATIONS_TABLE, SCHEMA_META_TABLE, SCHEMA_STATEMENTS, SCHEMA_VERSION, schemaChecksum } from "./schema.js";
+import { MIGRATION_NAME, MIGRATIONS_TABLE, SCHEMA_META_TABLE, SCHEMA_STATEMENTS, SCHEMA_TABLES, SCHEMA_VERSION, schemaChecksum, } from "./schema.js";
+const migrationFailure = (source, fallback) => (error) => SchemaMigrationFailed.make({
+    source,
+    message: typeof error === "object" && error !== null && "message" in error ? String(error.message) : fallback,
+});
 const readMeta = (source) => mapSqlError(Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     const exists = yield* sql `
@@ -25,7 +29,18 @@ const readMeta = (source) => mapSqlError(Effect.gen(function* () {
     source,
     message: "message" in error ? String(error.message) : "schema meta read failed",
 })));
-const migrationEffect = Effect.gen(function* () {
+const verifyMigrationIdentity = (source) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const migrations = yield* sql `
+      SELECT migration_id, name FROM ${sql(MIGRATIONS_TABLE)} ORDER BY migration_id
+    `;
+    if (migrations.length !== 1 ||
+        Number(migrations[0]?.migration_id) !== 1 ||
+        migrations[0]?.name !== MIGRATION_NAME) {
+        return yield* SchemaMigrationFailed.make({ source, message: "migration identity mismatch" });
+    }
+}).pipe(Effect.mapError(migrationFailure(source, "migration identity read failed")));
+const baselineMigration = Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     for (const statement of SCHEMA_STATEMENTS)
         yield* sql.unsafe(statement);
@@ -35,12 +50,21 @@ const migrationEffect = Effect.gen(function* () {
     VALUES (1, ${SCHEMA_VERSION}, ${schemaChecksum()}, FALSE, ${now})
   `;
 });
+const runMigrations = (source) => {
+    const migrate = Migrator.make({});
+    return migrate({
+        loader: Migrator.fromRecord({ [`0001_${MIGRATION_NAME}`]: baselineMigration }),
+        table: MIGRATIONS_TABLE,
+    }).pipe(Effect.catchCause((cause) => Cause.hasInterrupts(cause)
+        ? Effect.interrupt
+        : SchemaMigrationFailed.make({ source, message: Cause.pretty(cause) || "migration failed" })));
+};
 export const plan = (source) => Effect.map(readMeta(source), (meta) => ({
     current: meta.version,
     required: SCHEMA_VERSION,
     checksum: schemaChecksum(),
     statements: meta.present ? [] : SCHEMA_STATEMENTS,
-    upgradeRequired: !meta.present,
+    upgradeRequired: meta.version < SCHEMA_VERSION,
 }));
 export const check = (source) => Effect.gen(function* () {
     const meta = yield* readMeta(source);
@@ -55,6 +79,7 @@ export const check = (source) => Effect.gen(function* () {
     if (meta.version !== SCHEMA_VERSION || meta.checksum !== expected) {
         return yield* SchemaChecksumMismatch.make({ source, expected, actual: meta.checksum });
     }
+    yield* verifyMigrationIdentity(source);
 });
 export const apply = (source) => Effect.gen(function* () {
     const meta = yield* readMeta(source);
@@ -63,7 +88,7 @@ export const apply = (source) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     const existing = yield* sql `
       SELECT COUNT(*) AS present FROM information_schema.tables
-      WHERE table_schema = current_schema() AND table_name LIKE 'baton\_%' ESCAPE '\'
+      WHERE table_schema = current_schema() AND table_name IN ${sql.in(SCHEMA_TABLES)}
     `;
     if (Number(existing[0]?.present ?? 0) > 0) {
         return yield* SchemaMigrationFailed.make({
@@ -71,14 +96,7 @@ export const apply = (source) => Effect.gen(function* () {
             message: "cannot create the baseline over an existing TenetKit schema",
         });
     }
-    const runMigrations = Migrator.make({});
-    yield* runMigrations({
-        loader: Migrator.fromRecord({ "0001_baton_runtime": migrationEffect }),
-        table: MIGRATIONS_TABLE,
-    }).pipe(Effect.mapError((error) => SchemaMigrationFailed.make({
-        source,
-        message: "message" in error ? String(error.message) : "migration failed",
-    })));
+    yield* runMigrations(source);
     yield* check(source).pipe(Effect.catchTag("tenetkit/runtime/SchemaUpgradeRequired", (error) => SchemaMigrationFailed.make({ source, message: `schema absent after apply: ${error.current}` })));
 });
 export const markDirty = (source) => mapSqlError(Effect.gen(function* () {

package/dist/postgres/schema.d.ts

@@ -1,6 +1,8 @@
-export declare const SCHEMA_VERSION = 7;
-export declare const SCHEMA_META_TABLE = "baton_schema_meta";
-export declare const MIGRATIONS_TABLE = "baton_sql_migrations";
-export declare const NOTIFY_CHANNEL = "baton_run_events";
+export declare const SCHEMA_VERSION = 1;
+export declare const MIGRATION_NAME = "tenetkit_runtime";
+export declare const SCHEMA_META_TABLE = "tenetkit_schema_meta";
+export declare const MIGRATIONS_TABLE = "tenetkit_sql_migrations";
+export declare const NOTIFY_CHANNEL = "tenetkit_run_events";
 export declare const SCHEMA_STATEMENTS: ReadonlyArray<string>;
+export declare const SCHEMA_TABLES: ReadonlyArray<string>;
 export declare const schemaChecksum: () => string;