@alma-harness/runtime 0.11.0 → 0.12.0

package/dist/chunk-EGQL2P7U.js

@@ -0,0 +1,179 @@
+import {
+  namespace,
+  policies
+} from "./chunk-II7NDZRL.js";
+
+// src/postgres.ts
+import pg from "pg";
+import {
+  PostgresAuditLog,
+  PostgresSessionStore,
+  PostgresExecutionStore,
+  PostgresExecutionResultStore,
+  PostgresUsageInbox,
+  PostgresCostSettlementStore,
+  PostgresSpendStore,
+  migrateSessionStore,
+  migrateExecutionStore,
+  migrateExecutionResultStore,
+  migrateUsageInbox
+} from "@alma-harness/postgres";
+import { PostgresOperationSessionStore, PostgresOperationTreeStore, PostgresOperationAccountingStore, PostgresSessionLabelStore, migrateOperationAccountingStore, migrateOperationSessionStore, migrateSessionLabelStore } from "@alma-harness/postgres-execution";
+
+// src/maintenance-schema.ts
+import { roleBootstrapSql } from "@alma-harness/postgres";
+var MAINTENANCE_ROLE = "alma_maintenance";
+var DISCOVERY = {
+  alma_operation_admissions: ["org", "uid", "status", "deadline_at"],
+  alma_operation_roots: ["org", "uid", "id", "key", "status", "deadline_at"],
+  alma_operation_calls: ["org", "uid", "root_id", "operation_key", "call_id"],
+  alma_operation_financial_calls: ["org", "uid", "root_id", "call_id"],
+  alma_executions: ["org", "uid", "operation_key", "state", "deadline_at", "created_at", "pricing"],
+  alma_usage_inbox_pending: ["org", "uid", "id", "received_at"]
+};
+var policy = (table, name, clause) => `
+drop policy if exists ${name} on ${table};
+create policy ${name} on ${table} ${clause} to ${MAINTENANCE_ROLE} using (true)${clause.includes("select") ? "" : " with check (true)"};`;
+function maintenanceMigrationSql(schema) {
+  return `${roleBootstrapSql(MAINTENANCE_ROLE)}
+grant usage on schema ${schema} to ${MAINTENANCE_ROLE};
+${Object.entries(DISCOVERY).map(([table, columns]) => `revoke all on ${table} from ${MAINTENANCE_ROLE};
+grant select (${columns.join(", ")}) on ${table} to ${MAINTENANCE_ROLE};${policy(table, "alma_maintenance_discovery", "for select")}`).join("\n")}
+create table if not exists alma_maintenance_cursor (
+ id int primary key check (id = 1), org text collate "C", uid text collate "C", updated_at timestamptz not null default clock_timestamp(),
+ check ((org is null) = (uid is null))
+);
+create table if not exists alma_maintenance_scopes (
+ org text collate "C" not null, uid text collate "C" not null,
+ executions_after jsonb, usage_after jsonb, updated_at timestamptz not null default clock_timestamp(),
+ primary key (org, uid)
+);
+-- Bounded laps (spec: receipt-projections): additive and nullable, so a cursor written before them keeps its position.
+alter table alma_maintenance_scopes add column if not exists executions_bound jsonb;
+alter table alma_maintenance_scopes add column if not exists executions_budget int;
+alter table alma_maintenance_scopes add column if not exists usage_bound jsonb;
+alter table alma_maintenance_scopes add column if not exists usage_budget int;
+-- FORCE RLS binds the owner too, so the seed is written with it lifted inside this migration.
+alter table alma_maintenance_cursor no force row level security;
+insert into alma_maintenance_cursor (id) values (1) on conflict do nothing;
+${["alma_maintenance_cursor", "alma_maintenance_scopes"].map((t) => `alter table ${t} enable row level security;
+alter table ${t} force row level security;
+revoke all on ${t} from public, alma_app, alma_retention;${policy(t, "alma_maintenance_only", "for all")}`).join("\n")}
+grant select, update on alma_maintenance_cursor to ${MAINTENANCE_ROLE};
+grant select, insert, update on alma_maintenance_scopes to ${MAINTENANCE_ROLE};
+`;
+}
+
+// src/projections-schema.ts
+import { roleBootstrapSql as roleBootstrapSql2 } from "@alma-harness/postgres";
+var PROJECTION_ROLE = "alma_projection";
+var DISCOVERY2 = {
+  alma_cost_projection_pending: ["org", "uid", "consumer", "cost_id"],
+  alma_audit_cost: ["org", "uid", "id", "at", "settlement_id", "settlement_governed"]
+};
+function projectionMigrationSql(schema) {
+  return `${roleBootstrapSql2(PROJECTION_ROLE)}
+grant usage on schema ${schema} to ${PROJECTION_ROLE};
+${Object.entries(DISCOVERY2).map(([table, columns]) => `revoke all on ${table} from ${PROJECTION_ROLE};
+grant select (${columns.join(", ")}) on ${table} to ${PROJECTION_ROLE};
+drop policy if exists alma_projection_discovery on ${table};
+create policy alma_projection_discovery on ${table} for select to ${PROJECTION_ROLE} using (true);`).join("\n")}
+create table if not exists alma_projection_cursors (
+ consumer text collate "C" primary key, org text collate "C", uid text collate "C", updated_at timestamptz not null default clock_timestamp(),
+ check ((org is null) = (uid is null))
+);
+create table if not exists alma_projection_scopes (
+ consumer text collate "C" not null, org text collate "C" not null, uid text collate "C" not null,
+ after jsonb, bound jsonb, budget int, updated_at timestamptz not null default clock_timestamp(),
+ primary key (consumer, org, uid)
+);
+${["alma_projection_cursors", "alma_projection_scopes"].map((t) => `alter table ${t} enable row level security;
+alter table ${t} force row level security;
+revoke all on ${t} from public, alma_app, alma_retention, alma_maintenance;
+drop policy if exists alma_projection_only on ${t};
+create policy alma_projection_only on ${t} for all to ${PROJECTION_ROLE} using (true) with check (true);
+grant select, insert, update on ${t} to ${PROJECTION_ROLE};`).join("\n")}
+`;
+}
+
+// src/postgres.ts
+function limits(value) {
+  if (value === void 0) return { execution: 5, roots: 5 };
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Invalid runtime pool limits");
+  const fields = Object.getOwnPropertyDescriptors(value), keys = Reflect.ownKeys(fields);
+  if (keys.length !== 2 || !keys.includes("execution") || !keys.includes("roots")) throw new TypeError("Invalid runtime pool limits");
+  const execution = fields.execution?.value, roots = fields.roots?.value;
+  if (!Number.isSafeInteger(execution) || execution < 1 || !Number.isSafeInteger(roots) || roots < 1 || !Number.isSafeInteger(execution + roots)) throw new TypeError("Invalid runtime pool limits");
+  return { execution, roots };
+}
+function pools(n, max) {
+  const open = (schema, size) => {
+    const pool = new pg.Pool({
+      connectionString: n.connectionString,
+      options: `-c search_path=${schema} -c extra_float_digits=3`,
+      max: size,
+      connectionTimeoutMillis: 5e3,
+      idleTimeoutMillis: 1e4
+    });
+    pool.on("error", (error) => n.onPoolError(error, schema));
+    return pool;
+  };
+  const execution = open(n.schema, max.execution), roots = open(n.rootSchema, max.roots);
+  let closing;
+  return { execution, roots, close() {
+    return closing ??= Promise.allSettled([Promise.resolve().then(() => execution.end()), Promise.resolve().then(() => roots.end())]).then((results) => {
+      const errors = results.flatMap((r) => r.status === "rejected" ? [r.reason] : []);
+      if (errors.length) throw new AggregateError(errors, "Runtime pool cleanup failed");
+    });
+  } };
+}
+function createPostgresRuntime(value) {
+  const n = namespace(value), p = policies(value), max = limits(value.poolMax), owned = pools(n, max);
+  return { stores: {
+    sessions: new PostgresSessionStore(owned.execution),
+    admissions: new PostgresOperationSessionStore(owned.execution),
+    rootResults: new PostgresExecutionResultStore(owned.roots, p.rootResultPolicy),
+    step: {
+      executions: new PostgresExecutionStore(owned.execution),
+      results: new PostgresExecutionResultStore(owned.execution, p.stepResultPolicy),
+      inbox: new PostgresUsageInbox(owned.execution),
+      settlements: new PostgresCostSettlementStore(owned.execution),
+      spend: new PostgresSpendStore(owned.execution),
+      trees: new PostgresOperationTreeStore(owned.execution),
+      accounting: new PostgresOperationAccountingStore(owned.execution)
+    },
+    // The settlement migration already installs the audit tables in this namespace.
+    labels: new PostgresSessionLabelStore(owned.execution),
+    audit: new PostgresAuditLog(owned.execution)
+  }, close: owned.close };
+}
+async function migratePostgresRuntime(value) {
+  const n = namespace(value), owned = pools(n, { execution: 1, roots: 1 });
+  try {
+    await owned.execution.query(`create schema if not exists ${n.schema}`);
+    await owned.roots.query(`create schema if not exists ${n.rootSchema}`);
+    await migrateSessionStore(owned.execution);
+    await migrateExecutionStore(owned.execution);
+    await migrateExecutionResultStore(owned.execution);
+    await migrateUsageInbox(owned.execution);
+    await migrateOperationAccountingStore(owned.execution);
+    await migrateOperationSessionStore(owned.execution);
+    await migrateSessionLabelStore(owned.execution);
+    await migrateExecutionResultStore(owned.roots);
+    await owned.execution.query(maintenanceMigrationSql(n.schema));
+    await owned.execution.query(projectionMigrationSql(n.schema));
+    for (const [pool, schema] of [[owned.execution, n.schema], [owned.roots, n.rootSchema]]) {
+      await pool.query(`grant usage on schema ${schema} to alma_app, alma_retention; revoke create on schema ${schema} from public, alma_app, alma_retention`);
+    }
+  } finally {
+    await owned.close();
+  }
+}
+
+export {
+  MAINTENANCE_ROLE,
+  PROJECTION_ROLE,
+  createPostgresRuntime,
+  migratePostgresRuntime
+};
+//# sourceMappingURL=chunk-EGQL2P7U.js.map

package/dist/chunk-EGQL2P7U.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/postgres.ts","../src/maintenance-schema.ts","../src/projections-schema.ts"],"sourcesContent":["import pg from \"pg\";\nimport { PostgresAuditLog, PostgresSessionStore, PostgresExecutionStore, PostgresExecutionResultStore, PostgresUsageInbox, PostgresCostSettlementStore, PostgresSpendStore,\n  migrateSessionStore, migrateExecutionStore, migrateExecutionResultStore, migrateUsageInbox } from \"@alma-harness/postgres\";\nimport { PostgresOperationSessionStore, PostgresOperationTreeStore, PostgresOperationAccountingStore, PostgresSessionLabelStore, migrateOperationAccountingStore, migrateOperationSessionStore, migrateSessionLabelStore } from \"@alma-harness/postgres-execution\";\nimport type { Runtime, RuntimePolicies } from \"./index\";\nimport { namespace, policies } from \"./policies\";\nimport { maintenanceMigrationSql } from \"./maintenance-schema\";\nimport { projectionMigrationSql } from \"./projections-schema\";\nexport interface PostgresRuntimeNamespace { connectionString: string; schema: string; rootSchema: string; onPoolError: (error: Error, schema: string) => void }\nexport type PostgresRuntimeOptions = PostgresRuntimeNamespace & RuntimePolicies & {\n  /** Per owned pool, not per turn. Omission keeps five connections in each pool. */\n  poolMax?: { execution: number; roots: number };\n};\nfunction limits(value: unknown): { execution: number; roots: number } {\n  if(value===undefined)return {execution:5,roots:5};\n  if(!value || typeof value!==\"object\" || Array.isArray(value))throw new TypeError(\"Invalid runtime pool limits\");\n  const fields=Object.getOwnPropertyDescriptors(value),keys=Reflect.ownKeys(fields);\n  if(keys.length!==2 || !keys.includes(\"execution\") || !keys.includes(\"roots\"))throw new TypeError(\"Invalid runtime pool limits\");\n  const execution=fields.execution?.value,roots=fields.roots?.value;\n  if(!Number.isSafeInteger(execution) || execution<1 || !Number.isSafeInteger(roots) || roots<1 || !Number.isSafeInteger(execution+roots))throw new TypeError(\"Invalid runtime pool limits\");\n  return {execution,roots};\n}\nfunction pools(n: PostgresRuntimeNamespace, max: { execution: number; roots: number }) {\n  const open = (schema: string, size: number) => {\n    const pool = new pg.Pool({ connectionString: n.connectionString,\n    options: `-c search_path=${schema} -c extra_float_digits=3`, max: size, connectionTimeoutMillis: 5000, idleTimeoutMillis: 10000 });\n    pool.on(\"error\", error => n.onPoolError(error, schema));\n    return pool;\n  };\n  const execution = open(n.schema,max.execution), roots = open(n.rootSchema,max.roots);\n  let closing: Promise<void> | undefined;\n  return { execution, roots, close() {\n    return closing ??= Promise.allSettled([Promise.resolve().then(() => execution.end()), Promise.resolve().then(() => roots.end())]).then(results => {\n      const errors = results.flatMap(r => r.status === \"rejected\" ? [r.reason] : []);\n      if (errors.length) throw new AggregateError(errors, \"Runtime pool cleanup failed\");\n    });\n  } };\n}\n/** No connections, migrations or grants occur at construction. Owned pools pin both namespaces. */\nexport function createPostgresRuntime(value: PostgresRuntimeOptions): Runtime {\n  const n = namespace(value), p = policies(value), max = limits(value.poolMax), owned = pools(n,max);\n  return { stores: {\n    sessions: new PostgresSessionStore(owned.execution), admissions: new PostgresOperationSessionStore(owned.execution),\n    rootResults: new PostgresExecutionResultStore(owned.roots, p.rootResultPolicy),\n    step: { executions: new PostgresExecutionStore(owned.execution), results: new PostgresExecutionResultStore(owned.execution, p.stepResultPolicy),\n      inbox: new PostgresUsageInbox(owned.execution), settlements: new PostgresCostSettlementStore(owned.execution), spend: new PostgresSpendStore(owned.execution),\n      trees: new PostgresOperationTreeStore(owned.execution), accounting: new PostgresOperationAccountingStore(owned.execution) },\n    // The settlement migration already installs the audit tables in this namespace.\n    labels: new PostgresSessionLabelStore(owned.execution), audit: new PostgresAuditLog(owned.execution),\n  }, close: owned.close };\n}\n/** Explicit administrator operation. Partial installation may be rerun; no login memberships are granted. */\nexport async function migratePostgresRuntime(value: PostgresRuntimeNamespace): Promise<void> {\n  const n = namespace(value), owned = pools(n,{execution:1,roots:1});\n  try {\n    await owned.execution.query(`create schema if not exists ${n.schema}`);\n    await owned.roots.query(`create schema if not exists ${n.rootSchema}`);\n    await migrateSessionStore(owned.execution);\n    await migrateExecutionStore(owned.execution);\n    await migrateExecutionResultStore(owned.execution);\n    await migrateUsageInbox(owned.execution);\n    await migrateOperationAccountingStore(owned.execution);\n    await migrateOperationSessionStore(owned.execution);\n    await migrateSessionLabelStore(owned.execution);\n    await migrateExecutionResultStore(owned.roots);\n    await owned.execution.query(maintenanceMigrationSql(n.schema));\n    await owned.execution.query(projectionMigrationSql(n.schema));\n    for (const [pool, schema] of [[owned.execution, n.schema], [owned.roots, n.rootSchema]] as const) {\n      await pool.query(`grant usage on schema ${schema} to alma_app, alma_retention; revoke create on schema ${schema} from public, alma_app, alma_retention`);\n    }\n  } finally { await owned.close(); }\n}\n","import { roleBootstrapSql } from \"@alma-harness/postgres\";\nexport const MAINTENANCE_ROLE = \"alma_maintenance\";\n// DECISION: identifiers, states and times only; no input, evidence, settlement or result column (spec: runtime-maintenance).\nconst DISCOVERY: Record<string, string[]> = {\n  alma_operation_admissions: [\"org\", \"uid\", \"status\", \"deadline_at\"],\n  alma_operation_roots: [\"org\", \"uid\", \"id\", \"key\", \"status\", \"deadline_at\"],\n  alma_operation_calls: [\"org\", \"uid\", \"root_id\", \"operation_key\", \"call_id\"],\n  alma_operation_financial_calls: [\"org\", \"uid\", \"root_id\", \"call_id\"],\n  alma_executions: [\"org\", \"uid\", \"operation_key\", \"state\", \"deadline_at\", \"created_at\", \"pricing\"],\n  alma_usage_inbox_pending: [\"org\", \"uid\", \"id\", \"received_at\"],\n};\nconst policy = (table: string, name: string, clause: string) => `\ndrop policy if exists ${name} on ${table};\ncreate policy ${name} on ${table} ${clause} to ${MAINTENANCE_ROLE} using (true)${clause.includes(\"select\") ? \"\" : \" with check (true)\"};`;\n/** Runs in the execution namespace after the runtime's own migrations; the tables it grants on must exist. */\nexport function maintenanceMigrationSql(schema: string): string {\n  return `${roleBootstrapSql(MAINTENANCE_ROLE)}\ngrant usage on schema ${schema} to ${MAINTENANCE_ROLE};\n${Object.entries(DISCOVERY).map(([table, columns]) => `revoke all on ${table} from ${MAINTENANCE_ROLE};\ngrant select (${columns.join(\", \")}) on ${table} to ${MAINTENANCE_ROLE};${policy(table, \"alma_maintenance_discovery\", \"for select\")}`).join(\"\\n\")}\ncreate table if not exists alma_maintenance_cursor (\n id int primary key check (id = 1), org text collate \"C\", uid text collate \"C\", updated_at timestamptz not null default clock_timestamp(),\n check ((org is null) = (uid is null))\n);\ncreate table if not exists alma_maintenance_scopes (\n org text collate \"C\" not null, uid text collate \"C\" not null,\n executions_after jsonb, usage_after jsonb, updated_at timestamptz not null default clock_timestamp(),\n primary key (org, uid)\n);\n-- Bounded laps (spec: receipt-projections): additive and nullable, so a cursor written before them keeps its position.\nalter table alma_maintenance_scopes add column if not exists executions_bound jsonb;\nalter table alma_maintenance_scopes add column if not exists executions_budget int;\nalter table alma_maintenance_scopes add column if not exists usage_bound jsonb;\nalter table alma_maintenance_scopes add column if not exists usage_budget int;\n-- FORCE RLS binds the owner too, so the seed is written with it lifted inside this migration.\nalter table alma_maintenance_cursor no force row level security;\ninsert into alma_maintenance_cursor (id) values (1) on conflict do nothing;\n${[\"alma_maintenance_cursor\", \"alma_maintenance_scopes\"].map(t => `alter table ${t} enable row level security;\nalter table ${t} force row level security;\nrevoke all on ${t} from public, alma_app, alma_retention;${policy(t, \"alma_maintenance_only\", \"for all\")}`).join(\"\\n\")}\ngrant select, update on alma_maintenance_cursor to ${MAINTENANCE_ROLE};\ngrant select, insert, update on alma_maintenance_scopes to ${MAINTENANCE_ROLE};\n`;\n}\n","import { roleBootstrapSql } from \"@alma-harness/postgres\";\nexport const PROJECTION_ROLE = \"alma_projection\";\n// DECISION: identifiers, times and the governed flag only; no usage, cost, model or payload column (spec: receipt-projections).\nconst DISCOVERY: Record<string, string[]> = {\n  alma_cost_projection_pending: [\"org\", \"uid\", \"consumer\", \"cost_id\"],\n  alma_audit_cost: [\"org\", \"uid\", \"id\", \"at\", \"settlement_id\", \"settlement_governed\"],\n};\n/** Runs in the execution namespace after the runtime's own migrations. */\nexport function projectionMigrationSql(schema: string): string {\n  return `${roleBootstrapSql(PROJECTION_ROLE)}\ngrant usage on schema ${schema} to ${PROJECTION_ROLE};\n${Object.entries(DISCOVERY).map(([table, columns]) => `revoke all on ${table} from ${PROJECTION_ROLE};\ngrant select (${columns.join(\", \")}) on ${table} to ${PROJECTION_ROLE};\ndrop policy if exists alma_projection_discovery on ${table};\ncreate policy alma_projection_discovery on ${table} for select to ${PROJECTION_ROLE} using (true);`).join(\"\\n\")}\ncreate table if not exists alma_projection_cursors (\n consumer text collate \"C\" primary key, org text collate \"C\", uid text collate \"C\", updated_at timestamptz not null default clock_timestamp(),\n check ((org is null) = (uid is null))\n);\ncreate table if not exists alma_projection_scopes (\n consumer text collate \"C\" not null, org text collate \"C\" not null, uid text collate \"C\" not null,\n after jsonb, bound jsonb, budget int, updated_at timestamptz not null default clock_timestamp(),\n primary key (consumer, org, uid)\n);\n${[\"alma_projection_cursors\", \"alma_projection_scopes\"].map(t => `alter table ${t} enable row level security;\nalter table ${t} force row level security;\nrevoke all on ${t} from public, alma_app, alma_retention, alma_maintenance;\ndrop policy if exists alma_projection_only on ${t};\ncreate policy alma_projection_only on ${t} for all to ${PROJECTION_ROLE} using (true) with check (true);\ngrant select, insert, update on ${t} to ${PROJECTION_ROLE};`).join(\"\\n\")}\n`;\n}\n"],"mappings":"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","names":["roleBootstrapSql","DISCOVERY"]}

package/dist/chunk-II7NDZRL.js

@@ -0,0 +1,31 @@
+// src/policies.ts
+import { normalizeExecutionResultPolicy } from "@alma-harness/memory";
+function policies(value) {
+  return { stepResultPolicy: normalizeExecutionResultPolicy(value.stepResultPolicy), rootResultPolicy: normalizeExecutionResultPolicy(value.rootResultPolicy) };
+}
+function isAuditLog(value) {
+  return !!value && typeof value === "object" && ["access", "routing", "cost", "recall", "context"].every((k) => typeof value[k] === "function");
+}
+function namespace(value) {
+  const { connectionString, schema, rootSchema, onPoolError } = value;
+  if (typeof onPoolError !== "function") throw new TypeError("Runtime requires onPoolError reporting");
+  for (const s of [schema, rootSchema]) {
+    if (typeof s !== "string" || !/^[a-z_][a-z0-9_]{0,62}$/.test(s) || s === "public" || s === "information_schema" || s.startsWith("pg_")) throw new TypeError("Invalid dedicated runtime schema");
+  }
+  if (schema === rootSchema) throw new TypeError("Runtime result namespaces must be distinct");
+  let url;
+  try {
+    url = new URL(connectionString);
+  } catch {
+    throw new TypeError("Invalid PostgreSQL connection URL");
+  }
+  if (!["postgres:", "postgresql:"].includes(url.protocol) || !url.hostname || url.searchParams.has("options")) throw new TypeError("Runtime requires a PostgreSQL URL without startup options");
+  return { connectionString, schema, rootSchema, onPoolError };
+}
+
+export {
+  policies,
+  isAuditLog,
+  namespace
+};
+//# sourceMappingURL=chunk-II7NDZRL.js.map

package/dist/chunk-II7NDZRL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/policies.ts"],"sourcesContent":["import { normalizeExecutionResultPolicy } from \"@alma-harness/memory\";\nimport type { AuditLog } from \"@alma-harness/core\";\nimport type { RuntimePolicies } from \"./index\";\nimport type { PostgresRuntimeNamespace } from \"./postgres\";\nexport function policies(value: RuntimePolicies): RuntimePolicies {\n  return { stepResultPolicy: normalizeExecutionResultPolicy(value.stepResultPolicy), rootResultPolicy: normalizeExecutionResultPolicy(value.rootResultPolicy) };\n}\n/** An object carrying all five audit families; anything else fails construction rather than going unaudited. */\nexport function isAuditLog(value: unknown): value is AuditLog {\n  return !!value && typeof value === \"object\" && [\"access\", \"routing\", \"cost\", \"recall\", \"context\"].every(k => typeof (value as Record<string, unknown>)[k] === \"function\");\n}\n\n/** One validation for every login a runtime composition opens: dedicated schemas and a URL without startup options. */\nexport function namespace(value: PostgresRuntimeNamespace): PostgresRuntimeNamespace {\n  const { connectionString, schema, rootSchema, onPoolError } = value;\n  if (typeof onPoolError !== \"function\") throw new TypeError(\"Runtime requires onPoolError reporting\");\n  for (const s of [schema, rootSchema]) {\n    if (typeof s !== \"string\" || !/^[a-z_][a-z0-9_]{0,62}$/.test(s) || s === \"public\" || s === \"information_schema\" || s.startsWith(\"pg_\")) throw new TypeError(\"Invalid dedicated runtime schema\");\n  }\n  if (schema === rootSchema) throw new TypeError(\"Runtime result namespaces must be distinct\");\n  let url: URL;\n  try { url = new URL(connectionString); } catch { throw new TypeError(\"Invalid PostgreSQL connection URL\"); }\n  if (![\"postgres:\", \"postgresql:\"].includes(url.protocol) || !url.hostname || url.searchParams.has(\"options\")) throw new TypeError(\"Runtime requires a PostgreSQL URL without startup options\");\n  return { connectionString, schema, rootSchema, onPoolError };\n}\n"],"mappings":";AAAA,SAAS,sCAAsC;AAIxC,SAAS,SAAS,OAAyC;AAChE,SAAO,EAAE,kBAAkB,+BAA+B,MAAM,gBAAgB,GAAG,kBAAkB,+BAA+B,MAAM,gBAAgB,EAAE;AAC9J;AAEO,SAAS,WAAW,OAAmC;AAC5D,SAAO,CAAC,CAAC,SAAS,OAAO,UAAU,YAAY,CAAC,UAAU,WAAW,QAAQ,UAAU,SAAS,EAAE,MAAM,OAAK,OAAQ,MAAkC,CAAC,MAAM,UAAU;AAC1K;AAGO,SAAS,UAAU,OAA2D;AACnF,QAAM,EAAE,kBAAkB,QAAQ,YAAY,YAAY,IAAI;AAC9D,MAAI,OAAO,gBAAgB,WAAY,OAAM,IAAI,UAAU,wCAAwC;AACnG,aAAW,KAAK,CAAC,QAAQ,UAAU,GAAG;AACpC,QAAI,OAAO,MAAM,YAAY,CAAC,0BAA0B,KAAK,CAAC,KAAK,MAAM,YAAY,MAAM,wBAAwB,EAAE,WAAW,KAAK,EAAG,OAAM,IAAI,UAAU,kCAAkC;AAAA,EAChM;AACA,MAAI,WAAW,WAAY,OAAM,IAAI,UAAU,4CAA4C;AAC3F,MAAI;AACJ,MAAI;AAAE,UAAM,IAAI,IAAI,gBAAgB;AAAA,EAAG,QAAQ;AAAE,UAAM,IAAI,UAAU,mCAAmC;AAAA,EAAG;AAC3G,MAAI,CAAC,CAAC,aAAa,aAAa,EAAE,SAAS,IAAI,QAAQ,KAAK,CAAC,IAAI,YAAY,IAAI,aAAa,IAAI,SAAS,EAAG,OAAM,IAAI,UAAU,2DAA2D;AAC7L,SAAO,EAAE,kBAAkB,QAAQ,YAAY,YAAY;AAC7D;","names":[]}

package/dist/deployment.d.ts

@@ -0,0 +1,88 @@
+import * as _alma_harness_conversation from '@alma-harness/conversation';
+import { ConversationConfig } from '@alma-harness/conversation';
+import * as _alma_harness_execution from '@alma-harness/execution';
+import * as _alma_harness_core from '@alma-harness/core';
+import { BudgetCaps, ProviderId, SingleDispatchModelClient, ModelPrice } from '@alma-harness/core';
+import * as _alma_harness_single_call from '@alma-harness/single-call';
+import { SingleCallConfig, StructuredCallConfig } from '@alma-harness/single-call';
+import { Runtime } from './index.js';
+
+interface DeploymentLimits {
+    deadlineMs?: number;
+    runTimeoutMs?: number;
+    stepTimeoutMs?: number;
+    maxCalls?: number;
+    maxInputChars?: number;
+    maxRequestChars?: number;
+    maxOutputChars?: number;
+}
+type Observer = SingleCallConfig["onBackgroundError"];
+interface RuntimeDeploymentOptions {
+    runtime: Runtime;
+    clients: Partial<Record<ProviderId, SingleDispatchModelClient>>;
+    prices: ModelPrice[];
+    priceVersion: string;
+    consumers: string[];
+    caps: BudgetCaps;
+    retentionMs: number;
+    limits?: DeploymentLimits;
+    onBackgroundError: Observer;
+}
+/** `caps` replaces the deployment's caps whole; `limits` merge field by field. */
+interface OperationOverrides {
+    caps?: BudgetCaps;
+    limits?: DeploymentLimits;
+    onBackgroundError?: Observer;
+}
+type TextSupplied = "executions" | "results" | "inbox" | "settlements" | "spend" | "audit" | "clients" | "prices" | "priceVersion" | "consumers" | "resultRetentionMs" | "caps" | "maxInputChars" | "maxOutputChars" | "deadlineMs" | "onBackgroundError";
+type SingleCallOperation = Omit<SingleCallConfig, TextSupplied> & OperationOverrides;
+type StructuredCallOperation = Omit<StructuredCallConfig, TextSupplied | "trees" | "accounting"> & OperationOverrides;
+type ConversationOperation = Omit<ConversationConfig, "sessions" | "admissions" | "rootResults" | "step" | "prices" | "priceVersion" | "consumers" | "resultRetentionMs" | "caps" | "runTimeoutMs" | "maxCalls" | "maxInputChars"> & OperationOverrides;
+/** Deployment choices given once. Runners come from the existing factories, which keep every validation and binding. */
+declare function createRuntimeDeployment(value: RuntimeDeploymentOptions): {
+    singleCall(value: SingleCallOperation): {
+        run: (value: _alma_harness_single_call.SingleCallInput) => Promise<_alma_harness_single_call.SingleCallView>;
+        read: (scope: _alma_harness_core.Scope, operationKey: string) => Promise<_alma_harness_single_call.SingleCallView | null>;
+        recover: (scope: _alma_harness_core.Scope, operationKey: string, opts: {
+            leaseMs: number;
+        }) => Promise<_alma_harness_single_call.SingleCallView | null>;
+        reconcileUsage: (scope: _alma_harness_core.Scope, query?: _alma_harness_core.UsageInboxQuery, options?: {
+            skip?(operationKey: string): boolean | Promise<boolean>;
+        }) => Promise<{
+            after?: {
+                receivedAt: string;
+                id: string;
+            };
+            scanned: number;
+            acknowledged: number;
+        }>;
+        reconcileExpired: (scope: _alma_harness_core.Scope, opts?: {
+            limit?: number;
+        }) => Promise<_alma_harness_core.ExecutionRecord[]>;
+    };
+    structuredCall(value: StructuredCallOperation): {
+        run: (value: _alma_harness_single_call.SingleCallInput) => Promise<_alma_harness_single_call.StructuredCallView>;
+        read: (scope: _alma_harness_core.Scope, operationKey: string) => Promise<_alma_harness_single_call.StructuredCallView | null>;
+        recover(scope: _alma_harness_core.Scope, operationKey: string, opts: {
+            leaseMs: number;
+        }): Promise<_alma_harness_single_call.GovernedStepView | null>;
+        reconcileUsage(scope: _alma_harness_core.Scope, operationKey: string, query?: _alma_harness_core.UsageInboxQuery): Promise<{
+            after?: {
+                receivedAt: string;
+                id: string;
+            };
+            scanned: number;
+            acknowledged: number;
+        }>;
+        reconcileExpired(scope: _alma_harness_core.Scope, opts?: {
+            limit?: number;
+        }): Promise<{
+            roots: _alma_harness_execution.OperationRootRecord[];
+            executions: _alma_harness_core.ExecutionRecord[];
+        }>;
+    };
+    conversation(value: ConversationOperation): _alma_harness_conversation.ConversationRunner;
+};
+type RuntimeDeployment = ReturnType<typeof createRuntimeDeployment>;
+
+export { type ConversationOperation, type DeploymentLimits, type OperationOverrides, type RuntimeDeployment, type RuntimeDeploymentOptions, type SingleCallOperation, type StructuredCallOperation, createRuntimeDeployment };

package/dist/deployment.js

@@ -0,0 +1,130 @@
+import {
+  isAuditLog
+} from "./chunk-II7NDZRL.js";
+
+// src/deployment.ts
+import { createConversationRunner } from "@alma-harness/conversation";
+import { createSingleCallRunner, createStructuredCallRunner } from "@alma-harness/single-call";
+var LIMITS = ["deadlineMs", "runTimeoutMs", "stepTimeoutMs", "maxCalls", "maxInputChars", "maxRequestChars", "maxOutputChars"];
+var OWNED = /* @__PURE__ */ new Set([
+  "sessions",
+  "admissions",
+  "rootResults",
+  "executions",
+  "results",
+  "inbox",
+  "settlements",
+  "spend",
+  "trees",
+  "accounting",
+  "labels",
+  "audit",
+  "clients",
+  "prices",
+  "priceVersion",
+  "consumers",
+  "resultRetentionMs",
+  "step",
+  ...LIMITS
+]);
+var invalid = (what) => {
+  throw new TypeError(`Invalid runtime deployment ${what}`);
+};
+var record = (value, what) => value && typeof value === "object" && !Array.isArray(value) ? value : invalid(what);
+function data(value, what) {
+  const d = Object.getOwnPropertyDescriptors(record(value, what));
+  return Object.fromEntries(Reflect.ownKeys(d).map((k) => {
+    const p = d[k];
+    if (typeof k !== "string" || !("value" in p) || p.value === void 0) invalid(what);
+    return [k, p.value];
+  }));
+}
+function limits(value) {
+  const l = data(value, "limits");
+  for (const [k, n] of Object.entries(l)) if (!LIMITS.includes(k) || !Number.isSafeInteger(n) || n < 1) invalid("limits");
+  return l;
+}
+function createRuntimeDeployment(value) {
+  const o = data(value, "options");
+  for (const k of Object.keys(o)) if (!["runtime", "clients", "prices", "priceVersion", "consumers", "caps", "retentionMs", "limits", "onBackgroundError"].includes(k)) invalid("options");
+  const runtimeStores = record(record(o.runtime, "runtime").stores, "runtime");
+  const stores = { ...runtimeStores, step: { ...record(runtimeStores.step, "runtime") } };
+  if (!isAuditLog(stores.audit)) invalid("audit");
+  const clients = { ...record(o.clients, "clients") };
+  if (!Array.isArray(o.prices) || !Array.isArray(o.consumers) || typeof o.priceVersion !== "string" || typeof o.onBackgroundError !== "function") invalid("options");
+  if (!Number.isSafeInteger(o.retentionMs) || o.retentionMs < 1) invalid("retention");
+  const prices = structuredClone(o.prices), consumers = [...o.consumers], caps = structuredClone(record(o.caps, "caps"));
+  const base = limits(o.limits ?? {}), observer = o.onBackgroundError, priceVersion = o.priceVersion, retention = o.retentionMs;
+  function split(value2, required) {
+    const { caps: c, limits: l, onBackgroundError: ob, ...operation } = data(value2, "operation");
+    for (const k of Object.keys(operation)) if (OWNED.has(k)) invalid(`operation field ${k}`);
+    if (ob !== void 0 && typeof ob !== "function") invalid("operation observer");
+    const merged = { ...base, ...l === void 0 ? {} : limits(l) };
+    for (const k of required) if (merged[k] === void 0) invalid(`limit ${k}`);
+    return {
+      operation,
+      caps: structuredClone(c === void 0 ? caps : record(c, "caps")),
+      limits: merged,
+      onBackgroundError: ob ?? observer
+    };
+  }
+  const text = (s) => ({
+    executions: stores.step.executions,
+    results: stores.step.results,
+    inbox: stores.step.inbox,
+    settlements: stores.step.settlements,
+    spend: stores.step.spend,
+    audit: stores.audit,
+    clients: { ...clients },
+    prices: structuredClone(prices),
+    priceVersion,
+    consumers: [...consumers],
+    caps: s.caps,
+    resultRetentionMs: retention,
+    deadlineMs: s.limits.deadlineMs,
+    maxInputChars: s.limits.maxInputChars,
+    maxOutputChars: s.limits.maxOutputChars,
+    onBackgroundError: s.onBackgroundError
+  });
+  const TEXT = ["deadlineMs", "maxInputChars", "maxOutputChars"];
+  return {
+    singleCall(value2) {
+      const s = split(value2, TEXT);
+      return createSingleCallRunner({ ...s.operation, ...text(s) });
+    },
+    structuredCall(value2) {
+      const s = split(value2, TEXT);
+      return createStructuredCallRunner({ ...s.operation, ...text(s), trees: stores.step.trees, accounting: stores.step.accounting });
+    },
+    conversation(value2) {
+      const s = split(value2, ["runTimeoutMs", "stepTimeoutMs", "maxCalls", "maxInputChars", "maxRequestChars", "maxOutputChars"]);
+      return createConversationRunner({
+        ...s.operation,
+        sessions: stores.sessions,
+        admissions: stores.admissions,
+        rootResults: stores.rootResults,
+        prices: structuredClone(prices),
+        priceVersion,
+        consumers: [...consumers],
+        caps: s.caps,
+        resultRetentionMs: retention,
+        runTimeoutMs: s.limits.runTimeoutMs,
+        maxCalls: s.limits.maxCalls,
+        maxInputChars: s.limits.maxInputChars,
+        step: {
+          ...stores.step,
+          audit: stores.audit,
+          clients: { ...clients },
+          runTimeoutMs: s.limits.stepTimeoutMs,
+          maxRequestChars: s.limits.maxRequestChars,
+          maxOutputChars: s.limits.maxOutputChars,
+          onBackgroundError: s.onBackgroundError
+        }
+      });
+    }
+  };
+}
+export {
+  createRuntimeDeployment
+};
+//# sourceMappingURL=deployment.js.map

package/dist/deployment.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/deployment.ts"],"sourcesContent":["import type { BudgetCaps, ModelPrice, ProviderId, SingleDispatchModelClient } from \"@alma-harness/core\";\nimport { createConversationRunner, type ConversationConfig } from \"@alma-harness/conversation\";\nimport { createSingleCallRunner, createStructuredCallRunner, type SingleCallConfig, type StructuredCallConfig } from \"@alma-harness/single-call\";\nimport type { Runtime } from \"./index\";\nimport { isAuditLog } from \"./policies\";\n\nexport interface DeploymentLimits {\n  deadlineMs?: number; runTimeoutMs?: number; stepTimeoutMs?: number; maxCalls?: number;\n  maxInputChars?: number; maxRequestChars?: number; maxOutputChars?: number;\n}\ntype Observer = SingleCallConfig[\"onBackgroundError\"];\nexport interface RuntimeDeploymentOptions {\n  runtime: Runtime;\n  clients: Partial<Record<ProviderId, SingleDispatchModelClient>>;\n  prices: ModelPrice[]; priceVersion: string; consumers: string[];\n  caps: BudgetCaps; retentionMs: number; limits?: DeploymentLimits;\n  onBackgroundError: Observer;\n}\n/** `caps` replaces the deployment's caps whole; `limits` merge field by field. */\nexport interface OperationOverrides { caps?: BudgetCaps; limits?: DeploymentLimits; onBackgroundError?: Observer }\ntype TextSupplied = \"executions\" | \"results\" | \"inbox\" | \"settlements\" | \"spend\" | \"audit\" | \"clients\" | \"prices\" | \"priceVersion\" | \"consumers\"\n  | \"resultRetentionMs\" | \"caps\" | \"maxInputChars\" | \"maxOutputChars\" | \"deadlineMs\" | \"onBackgroundError\";\nexport type SingleCallOperation = Omit<SingleCallConfig, TextSupplied> & OperationOverrides;\nexport type StructuredCallOperation = Omit<StructuredCallConfig, TextSupplied | \"trees\" | \"accounting\"> & OperationOverrides;\nexport type ConversationOperation = Omit<ConversationConfig, \"sessions\" | \"admissions\" | \"rootResults\" | \"step\" | \"prices\" | \"priceVersion\" | \"consumers\"\n  | \"resultRetentionMs\" | \"caps\" | \"runTimeoutMs\" | \"maxCalls\" | \"maxInputChars\"> & OperationOverrides;\n\nconst LIMITS = [\"deadlineMs\", \"runTimeoutMs\", \"stepTimeoutMs\", \"maxCalls\", \"maxInputChars\", \"maxRequestChars\", \"maxOutputChars\"] as const;\ntype Limit = typeof LIMITS[number];\n// DECISION: one owned set for every runner kind. None of these is a legitimate operation field of any kind.\nconst OWNED = new Set<string>([\"sessions\", \"admissions\", \"rootResults\", \"executions\", \"results\", \"inbox\", \"settlements\", \"spend\", \"trees\", \"accounting\",\n  \"labels\", \"audit\", \"clients\", \"prices\", \"priceVersion\", \"consumers\", \"resultRetentionMs\", \"step\", ...LIMITS]);\nconst invalid = (what: string): never => { throw new TypeError(`Invalid runtime deployment ${what}`); };\nconst record = (value: unknown, what: string): Record<string, unknown> =>\n  value && typeof value === \"object\" && !Array.isArray(value) ? value as Record<string, unknown> : invalid(what);\n\n/** Own data properties only: an accessor or an explicit undefined never reads as omitted. */\nfunction data(value: unknown, what: string): Record<string, unknown> {\n  const d = Object.getOwnPropertyDescriptors(record(value, what));\n  return Object.fromEntries(Reflect.ownKeys(d).map(k => {\n    const p = d[k as string]!;\n    if (typeof k !== \"string\" || !(\"value\" in p) || p.value === undefined) invalid(what);\n    return [k, p.value];\n  }));\n}\nfunction limits(value: unknown): DeploymentLimits {\n  const l = data(value, \"limits\");\n  for (const [k, n] of Object.entries(l)) if (!(LIMITS as readonly string[]).includes(k) || !Number.isSafeInteger(n) || (n as number) < 1) invalid(\"limits\");\n  return l as DeploymentLimits;\n}\n\n/** Deployment choices given once. Runners come from the existing factories, which keep every validation and binding. */\nexport function createRuntimeDeployment(value: RuntimeDeploymentOptions) {\n  const o = data(value, \"options\") as unknown as RuntimeDeploymentOptions;\n  for (const k of Object.keys(o)) if (![\"runtime\", \"clients\", \"prices\", \"priceVersion\", \"consumers\", \"caps\", \"retentionMs\", \"limits\", \"onBackgroundError\"].includes(k)) invalid(\"options\");\n  // Snapshot: collections copied at both store levels; the capabilities inside stay the originals.\n  const runtimeStores = record(record(o.runtime, \"runtime\").stores, \"runtime\") as unknown as Runtime[\"stores\"];\n  const stores = { ...runtimeStores, step: { ...record(runtimeStores.step, \"runtime\") } } as Runtime[\"stores\"];\n  if (!isAuditLog(stores.audit)) invalid(\"audit\");\n  const clients = { ...record(o.clients, \"clients\") } as RuntimeDeploymentOptions[\"clients\"];\n  if (!Array.isArray(o.prices) || !Array.isArray(o.consumers) || typeof o.priceVersion !== \"string\" || typeof o.onBackgroundError !== \"function\") invalid(\"options\");\n  if (!Number.isSafeInteger(o.retentionMs) || o.retentionMs < 1) invalid(\"retention\");\n  const prices = structuredClone(o.prices), consumers = [...o.consumers], caps = structuredClone(record(o.caps, \"caps\")) as BudgetCaps;\n  const base = limits(o.limits ?? {}), observer = o.onBackgroundError, priceVersion = o.priceVersion, retention = o.retentionMs;\n\n  function split(value: unknown, required: readonly Limit[]) {\n    const { caps: c, limits: l, onBackgroundError: ob, ...operation } = data(value, \"operation\");\n    for (const k of Object.keys(operation)) if (OWNED.has(k)) invalid(`operation field ${k}`);\n    if (ob !== undefined && typeof ob !== \"function\") invalid(\"operation observer\");\n    const merged: DeploymentLimits = { ...base, ...(l === undefined ? {} : limits(l)) };\n    for (const k of required) if (merged[k] === undefined) invalid(`limit ${k}`);\n    return { operation, caps: structuredClone(c === undefined ? caps : record(c, \"caps\")) as BudgetCaps,\n      limits: merged as Required<DeploymentLimits>, onBackgroundError: (ob ?? observer) as Observer };\n  }\n  const text = (s: ReturnType<typeof split>) => ({ executions: stores.step.executions, results: stores.step.results, inbox: stores.step.inbox,\n    settlements: stores.step.settlements, spend: stores.step.spend, audit: stores.audit, clients: { ...clients }, prices: structuredClone(prices),\n    priceVersion, consumers: [...consumers], caps: s.caps, resultRetentionMs: retention, deadlineMs: s.limits.deadlineMs,\n    maxInputChars: s.limits.maxInputChars, maxOutputChars: s.limits.maxOutputChars, onBackgroundError: s.onBackgroundError });\n  const TEXT = [\"deadlineMs\", \"maxInputChars\", \"maxOutputChars\"] as const;\n  return {\n    singleCall(value: SingleCallOperation) {\n      const s = split(value, TEXT);\n      return createSingleCallRunner({ ...s.operation, ...text(s) } as SingleCallConfig);\n    },\n    structuredCall(value: StructuredCallOperation) {\n      const s = split(value, TEXT);\n      return createStructuredCallRunner({ ...s.operation, ...text(s), trees: stores.step.trees, accounting: stores.step.accounting } as StructuredCallConfig);\n    },\n    conversation(value: ConversationOperation) {\n      const s = split(value, [\"runTimeoutMs\", \"stepTimeoutMs\", \"maxCalls\", \"maxInputChars\", \"maxRequestChars\", \"maxOutputChars\"]);\n      return createConversationRunner({ ...s.operation, sessions: stores.sessions, admissions: stores.admissions, rootResults: stores.rootResults,\n        prices: structuredClone(prices), priceVersion, consumers: [...consumers], caps: s.caps, resultRetentionMs: retention,\n        runTimeoutMs: s.limits.runTimeoutMs, maxCalls: s.limits.maxCalls, maxInputChars: s.limits.maxInputChars,\n        step: { ...stores.step, audit: stores.audit, clients: { ...clients }, runTimeoutMs: s.limits.stepTimeoutMs,\n          maxRequestChars: s.limits.maxRequestChars, maxOutputChars: s.limits.maxOutputChars, onBackgroundError: s.onBackgroundError },\n      } as ConversationConfig);\n    },\n  };\n}\nexport type RuntimeDeployment = ReturnType<typeof createRuntimeDeployment>;\n"],"mappings":"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","names":["value"]}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ExecutionResultPolicy } from '@alma-harness/core';
+import { SessionLabelStore, AuditLog, ExecutionResultPolicy } from '@alma-harness/core';
 import { ConversationConfig } from '@alma-harness/conversation';
 
 interface RuntimePolicies {
@@ -7,6 +7,10 @@ interface RuntimePolicies {
 }
 type RuntimeStores = Pick<ConversationConfig, "sessions" | "admissions" | "rootResults"> & {
     step: Pick<ConversationConfig["step"], "executions" | "results" | "inbox" | "settlements" | "spend" | "trees" | "accounting">;
+    /** Host attribution per session; register it with erasure (spec: session-labels). */
+    labels: SessionLabelStore;
+    /** The runtime's own audit trail, on the execution namespace (spec: runtime-deployment). */
+    audit: AuditLog;
 };
 interface Runtime {
     stores: RuntimeStores;

package/dist/maintenance-core-DDX5ryx7.d.ts

@@ -0,0 +1,73 @@
+import { UsageInboxQuery, Scope } from '@alma-harness/core';
+import { RuntimeStores } from './index.js';
+
+type ExecutionCursor = {
+    createdAt: string;
+    operationKey: string;
+};
+type UsageCursor = NonNullable<UsageInboxQuery["after"]>;
+interface RecoverableExecution {
+    operationKey: string;
+    createdAt: string;
+    rootKey: string | null;
+}
+interface ScopeClaim {
+    alive(): boolean;
+    release(): Promise<void>;
+    onLost?(fn: () => void): void;
+}
+/** A finite lap: items after `after` up to `bound`, at most `budget` more attempts (spec: receipt-projections). A null bound is a cursor written before laps existed. */
+interface Lap<C> {
+    after: C | null;
+    bound: C | null;
+    budget: number | null;
+}
+interface MaintenanceCursors {
+    executions: Lap<ExecutionCursor> | null;
+    usage: Lap<UsageCursor> | null;
+}
+/** Cross-scope metadata only: identifiers, states, times and the maintenance cursors (spec: runtime-maintenance). */
+interface MaintenanceDiscovery {
+    /** Throws unless the logins keep discovery and scoped work apart. */
+    verify(): Promise<void>;
+    nextScopes(limit: number): Promise<Scope[]>;
+    claim(scope: Scope): Promise<ScopeClaim | null>;
+    recoverable(scope: Scope, after: ExecutionCursor | null, bound: ExecutionCursor, limit: number): Promise<RecoverableExecution[]>;
+    /** The greatest eligible execution and how many are eligible up to it; null when none is. */
+    executionLap(scope: Scope): Promise<{
+        bound: ExecutionCursor;
+        budget: number;
+    } | null>;
+    usageLap(scope: Scope): Promise<{
+        bound: UsageCursor;
+        budget: number;
+    } | null>;
+    /** Root keys of the given operation keys that are members of a root. */
+    members(scope: Scope, operationKeys: string[]): Promise<Map<string, string>>;
+    cursors(scope: Scope): Promise<MaintenanceCursors>;
+    saveCursors(scope: Scope, cursors: MaintenanceCursors): Promise<void>;
+}
+interface MaintenanceReport {
+    scopes: number;
+    skipped: number;
+    expired: {
+        admissions: number;
+        roots: number;
+        executions: number;
+    };
+    recovered: number;
+    acknowledged: number;
+    failed: number;
+}
+/** Store work per scope; no client, no release, no content in the report. */
+declare function createMaintenance(options: {
+    stores: RuntimeStores;
+    discovery: MaintenanceDiscovery;
+}): {
+    maintain(value: {
+        limit: number;
+        signal?: AbortSignal;
+    }): Promise<MaintenanceReport>;
+};
+
+export { type ExecutionCursor as E, type Lap as L, type MaintenanceReport as M, type RecoverableExecution as R, type ScopeClaim as S, type UsageCursor as U, type MaintenanceDiscovery as a, type MaintenanceCursors as b, createMaintenance as c };

package/dist/maintenance.d.ts

@@ -0,0 +1,32 @@
+import { M as MaintenanceReport, a as MaintenanceDiscovery } from './maintenance-core-DDX5ryx7.js';
+export { E as ExecutionCursor, L as Lap, b as MaintenanceCursors, R as RecoverableExecution, S as ScopeClaim, U as UsageCursor, c as createMaintenance } from './maintenance-core-DDX5ryx7.js';
+import pg from 'pg';
+import { RuntimePolicies } from './index.js';
+import '@alma-harness/core';
+import '@alma-harness/conversation';
+
+interface PostgresMaintenanceOptions extends RuntimePolicies {
+    /** A login that is a member of alma_maintenance only. */
+    discovery: {
+        connectionString: string;
+    };
+    /** A login that is a member of alma_app only, never the request path's. */
+    worker: {
+        connectionString: string;
+    };
+    schema: string;
+    rootSchema: string;
+    onPoolError: (error: Error, schema: string) => void;
+}
+/** The PostgreSQL discovery on a pool of the discovery login; `workerURL` is only used to verify the worker login. */
+declare function createPostgresMaintenanceDiscovery(pool: pg.Pool, workerURL: string): MaintenanceDiscovery;
+/** Its own logins and pools, never the request path's. Construction opens no connection (spec: runtime-maintenance). */
+declare function createPostgresMaintenance(value: PostgresMaintenanceOptions): {
+    maintain: (value: {
+        limit: number;
+        signal?: AbortSignal;
+    }) => Promise<MaintenanceReport>;
+    close(): Promise<void>;
+};
+
+export { MaintenanceDiscovery, MaintenanceReport, type PostgresMaintenanceOptions, createPostgresMaintenance, createPostgresMaintenanceDiscovery };