@sema-agent/server 1.315.0 → 1.317.0

package/dist/plugins/outcome-ledger-sql.js

@@ -0,0 +1,158 @@
+import { randomUUID, createHash } from "node:crypto";
+import { pgSafeJsonStringify } from "./pg-safe-json.js";
+import { mysqlDriver, pgDriver } from "./sql-driver.js";
+export function taskSignature(s) {
+    if (s.tag)
+        return `tag:${s.tag}`;
+    const canon = JSON.stringify({
+        taskType: s.taskType ?? "",
+        toolset: [...(s.toolset ?? [])].sort(),
+        targetLang: s.targetLang ?? "",
+        moduleCount: s.moduleCount ?? 0,
+    });
+    return `h:${createHash("sha256").update(canon).digest("hex").slice(0, 16)}`;
+}
+export function deriveOutcome(m, runStatus = "completed-graded") {
+    if (runStatus === "infra-aborted")
+        return "aborted";
+    const oracleGreen = m.oracleTotal != null && m.oracleTotal > 0 && m.oraclePassed === m.oracleTotal;
+    const buildGreen = (m.assembleExit == null || m.assembleExit === 0) && (m.lintExit == null || m.lintExit === 0);
+    const mergeGreen = m.mergeOk !== false;
+    if (oracleGreen && buildGreen && mergeGreen)
+        return "pass";
+    const anyGreen = oracleGreen || (m.oraclePassed != null && m.oraclePassed > 0) || m.mergeOk === true;
+    return anyGreen ? "partial" : "fail";
+}
+export function coreOutcomeToLedgerRow(o) {
+    const passed = typeof o.oracle?.oraclePassed === "number" ? o.oracle.oraclePassed : o.oracle?.green ? 1 : 0;
+    const total = typeof o.oracle?.oracleTotal === "number" ? o.oracle.oracleTotal : 1;
+    return {
+        taskId: o.runId.slice(0, 64),
+        model: (o.model ?? "unknown").slice(0, 190),
+        signatureInputs: {
+            tag: o.taskSignature.slice(0, 186),
+            ...(o.signatureInputs?.toolset ? { toolset: o.signatureInputs.toolset } : {}),
+            ...(o.signatureInputs?.targetLang ? { targetLang: o.signatureInputs.targetLang } : {}),
+            ...(o.signatureInputs?.moduleCount !== undefined ? { moduleCount: o.signatureInputs.moduleCount } : {}),
+        },
+        mechanical: {
+            oraclePassed: passed,
+            oracleTotal: total,
+            ...(o.costMicroUsd !== undefined ? { costMicroUsd: o.costMicroUsd } : {}),
+            ...(o.turns !== undefined ? { turns: o.turns } : {}),
+        },
+        core: o,
+    };
+}
+export const PG_OUTCOME_LEDGER_SCHEMA = [
+    `CREATE TABLE IF NOT EXISTS outcome_ledger (
+     id             VARCHAR(64)  NOT NULL,
+     task_signature VARCHAR(190) NOT NULL,
+     model          VARCHAR(190) NOT NULL,
+     task_id        VARCHAR(64),
+     run_status     VARCHAR(20)  NOT NULL DEFAULT 'completed-graded',
+     route          VARCHAR(16),
+     worker_count   INTEGER,
+     oracle_passed  INTEGER,
+     oracle_total   INTEGER,
+     assemble_exit  INTEGER,
+     lint_exit      INTEGER,
+     merge_ok       SMALLINT,
+     replan_triggers JSONB,
+     cost_micro_usd BIGINT,
+     turns          INTEGER,
+     outcome        VARCHAR(8),
+     llm_assisted   JSONB,
+     signature_inputs JSONB,
+     -- design/73 §1 bridge: the VERBATIM core TaskOutcome fact (oracleHadRedRun / status / oracle blob) as it
+     -- came off core, kept alongside the derived mechanical columns. NULL when the caller recorded through the
+     -- non-core \`record()\` path (no core fact to bridge).
+     core_outcome   JSONB,
+     created_at     TIMESTAMPTZ(3) NOT NULL,
+     PRIMARY KEY (id)
+   )`,
+    `CREATE INDEX IF NOT EXISTS idx_outcome_ledger_sig_model ON outcome_ledger (task_signature, model, run_status)`,
+    `CREATE INDEX IF NOT EXISTS idx_outcome_ledger_outcome ON outcome_ledger (outcome)`,
+    `CREATE INDEX IF NOT EXISTS idx_outcome_ledger_created ON outcome_ledger (created_at)`,
+];
+export async function ensurePgOutcomeLedgerSchema(pool) {
+    for (const stmt of PG_OUTCOME_LEDGER_SCHEMA)
+        await pool.query(stmt);
+}
+export class SqlOutcomeLedger {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    q(tidb, pg) {
+        return this.db.dialect === "tidb" ? tidb : pg;
+    }
+    json(value) {
+        return this.db.dialect === "tidb" ? JSON.stringify(value) : pgSafeJsonStringify(value);
+    }
+    async record(o) {
+        const id = randomUUID().replace(/-/g, "").slice(0, 32);
+        const sig = taskSignature(o.signatureInputs);
+        const m = o.mechanical;
+        const runStatus = o.runStatus ?? "completed-graded";
+        await this.db.query(this.q(`INSERT INTO outcome_ledger
+        (id, task_signature, model, task_id, run_status, route, worker_count, oracle_passed, oracle_total,
+         assemble_exit, lint_exit, merge_ok, replan_triggers, cost_micro_usd, turns, outcome,
+         llm_assisted, signature_inputs, core_outcome, created_at)
+       VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`, `INSERT INTO outcome_ledger
+        (id, task_signature, model, task_id, run_status, route, worker_count, oracle_passed, oracle_total,
+         assemble_exit, lint_exit, merge_ok, replan_triggers, cost_micro_usd, turns, outcome,
+         llm_assisted, signature_inputs, core_outcome, created_at)
+       VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13::jsonb,$14,$15,$16,$17::jsonb,$18::jsonb,$19::jsonb,$20)`), [
+            id, sig, o.model, o.taskId ?? null, runStatus, m.route ?? null, m.workerCount ?? null,
+            m.oraclePassed ?? null, m.oracleTotal ?? null, m.assembleExit ?? null, m.lintExit ?? null,
+            m.mergeOk == null ? null : m.mergeOk ? 1 : 0,
+            m.replanTriggers ? this.json(m.replanTriggers) : null,
+            m.costMicroUsd ?? null, m.turns ?? null, deriveOutcome(m, runStatus),
+            o.llmAssisted ? this.json(o.llmAssisted) : null,
+            this.json(o.signatureInputs), o.core != null ? this.json(o.core) : null, new Date(),
+        ]);
+        return id;
+    }
+    async recordCore(o) {
+        await this.record(coreOutcomeToLedgerRow(o));
+    }
+    async summary(opts = {}) {
+        const clauses = [];
+        const params = [];
+        if (!opts.includeAborted)
+            clauses.push("run_status = 'completed-graded'");
+        if (opts.taskSignature) {
+            params.push(opts.taskSignature);
+            clauses.push(this.q("task_signature = ?", `task_signature = $${params.length}`));
+        }
+        const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+        const { rows } = await this.db.query(this.q(`SELECT task_signature, model, COUNT(*) n,
+              AVG(outcome = 'pass') pass_rate, AVG(cost_micro_usd) mean_cost
+         FROM outcome_ledger ${where}
+        GROUP BY task_signature, model
+        ORDER BY task_signature, model`, `SELECT task_signature, model, COUNT(*) n,
+              AVG((outcome = 'pass')::int) pass_rate, AVG(cost_micro_usd) mean_cost
+         FROM outcome_ledger ${where}
+        GROUP BY task_signature, model
+        ORDER BY task_signature, model`), params);
+        return rows.map((r) => ({
+            taskSignature: String(r.task_signature),
+            model: String(r.model),
+            n: Number(r.n),
+            passRate: Number(r.pass_rate),
+            meanCostMicroUsd: Number(r.mean_cost ?? 0),
+        }));
+    }
+}
+export class TiDBOutcomeLedger extends SqlOutcomeLedger {
+    constructor(pool) {
+        super(mysqlDriver(pool));
+    }
+}
+export class PgOutcomeLedger extends SqlOutcomeLedger {
+    constructor(pool) {
+        super(pgDriver(pool));
+    }
+}
+//# sourceMappingURL=outcome-ledger-sql.js.map

package/dist/plugins/pg-approval-store.d.ts

@@ -1,28 +1,2 @@
-import type { Pool, PoolClient } from "pg";
-import { type ApprovalRow, type ApprovalStatus } from "./tidb-approval-store.js";
-export type { ApprovalRow, ApprovalStatus } from "./tidb-approval-store.js";
-export declare const PG_APPROVAL_SCHEMA: string[];
-export declare function ensureSchema(pool: Pool | PoolClient): Promise<void>;
-export declare class PgApprovalStore {
-    private readonly pool;
-    constructor(pool: Pool);
-    createPending(id: string, scope: string | null, ctx: {
-        taskId?: string | null;
-        sessionId?: string | null;
-        owner?: string | null;
-        toolName: string;
-        args: unknown;
-    }): Promise<void>;
-    getStatus(id: string, scope: string | null): Promise<{
-        status: ApprovalStatus;
-        reason: string | null;
-        decidedBy: string | null;
-    } | undefined>;
-    decide(id: string, scope: string | null, decision: "approved" | "denied" | "expired", reason: string | null, decidedBy: string | null): Promise<boolean>;
-    listPending(scope: string | null, owner?: string): Promise<ApprovalRow[]>;
-    get(id: string, scope: string | null): Promise<ApprovalRow | undefined>;
-    getById(id: string): Promise<ApprovalRow | undefined>;
-    listPendingAll(): Promise<ApprovalRow[]>;
-    expireStale(olderThanMs: number): Promise<number>;
-}
+export { PgApprovalStore, PG_APPROVAL_SCHEMA, ensureSchema, type ApprovalRow, type ApprovalStatus, } from "./approval-store-sql.js";
 //# sourceMappingURL=pg-approval-store.d.ts.map

package/dist/plugins/pg-approval-store.js

@@ -1,84 +1,2 @@
-import { mapRow } from "./tidb-approval-store.js";
-import { pgProtocolJsonStringify } from "./pg-safe-json.js";
-export const PG_APPROVAL_SCHEMA = [
-    `CREATE TABLE IF NOT EXISTS approval (
-     id          VARCHAR(64)  NOT NULL,
-     task_id     VARCHAR(64),
-     session_id  VARCHAR(64),
-     owner       VARCHAR(190),
-     -- Single-DB fleet scope guard (tenant isolation). NULLABLE on purpose: a NULL-scope row is an untenanted
-     -- run, and every read/decide path matches it with \`scope IS NOT DISTINCT FROM $n\` (the PG twin of TiDB
-     -- \`<=>\`) so NULL matches only NULL and one tenant's scope NEVER matches another's.
-     scope       VARCHAR(190),
-     tool_name   VARCHAR(190) NOT NULL,
-     args        JSONB,
-     status      VARCHAR(16)  NOT NULL,
-     reason      TEXT,
-     decided_by  VARCHAR(190),
-     created_at  TIMESTAMPTZ(3) NOT NULL,
-     decided_at  TIMESTAMPTZ(3),
-     PRIMARY KEY (id)
-   )`,
-    `CREATE INDEX IF NOT EXISTS idx_approval_owner_status ON approval (owner, status)`,
-    `CREATE INDEX IF NOT EXISTS idx_approval_status ON approval (status)`,
-    `CREATE INDEX IF NOT EXISTS idx_approval_scope_status ON approval (scope, status)`,
-];
-export async function ensureSchema(pool) {
-    for (const stmt of PG_APPROVAL_SCHEMA)
-        await pool.query(stmt);
-}
-export class PgApprovalStore {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-    }
-    async createPending(id, scope, ctx) {
-        await this.pool.query("INSERT INTO approval (id, task_id, session_id, owner, scope, tool_name, args, status, created_at) " +
-            "VALUES ($1,$2,$3,$4,$5,$6,$7::jsonb,'pending',$8)", [
-            id,
-            ctx.taskId ?? null,
-            ctx.sessionId ?? null,
-            ctx.owner ?? null,
-            scope,
-            ctx.toolName,
-            ctx.args == null ? null : pgProtocolJsonStringify(ctx.args, "approval args"),
-            new Date(),
-        ]);
-    }
-    async getStatus(id, scope) {
-        const res = await this.pool.query("SELECT status, reason, decided_by FROM approval WHERE id = $1 AND scope IS NOT DISTINCT FROM $2", [id, scope]);
-        const r = res.rows[0];
-        if (!r)
-            return undefined;
-        return { status: r.status, reason: r.reason ?? null, decidedBy: r.decided_by ?? null };
-    }
-    async decide(id, scope, decision, reason, decidedBy) {
-        const res = await this.pool.query("UPDATE approval SET status = $1, reason = $2, decided_by = $3, decided_at = $4 WHERE id = $5 AND scope IS NOT DISTINCT FROM $6 AND status = 'pending'", [decision, reason, decidedBy, new Date(), id, scope]);
-        return (res.rowCount ?? 0) === 1;
-    }
-    async listPending(scope, owner) {
-        const res = owner
-            ? await this.pool.query("SELECT * FROM approval WHERE status = 'pending' AND scope IS NOT DISTINCT FROM $1 AND owner = $2 ORDER BY created_at ASC", [scope, owner])
-            : await this.pool.query("SELECT * FROM approval WHERE status = 'pending' AND scope IS NOT DISTINCT FROM $1 ORDER BY created_at ASC", [scope]);
-        return res.rows.map(mapRow);
-    }
-    async get(id, scope) {
-        const res = await this.pool.query("SELECT * FROM approval WHERE id = $1 AND scope IS NOT DISTINCT FROM $2", [id, scope]);
-        return res.rows[0] ? mapRow(res.rows[0]) : undefined;
-    }
-    async getById(id) {
-        const res = await this.pool.query("SELECT * FROM approval WHERE id = $1", [id]);
-        return res.rows[0] ? mapRow(res.rows[0]) : undefined;
-    }
-    async listPendingAll() {
-        const res = await this.pool.query("SELECT * FROM approval WHERE status = 'pending' ORDER BY created_at ASC");
-        return res.rows.map(mapRow);
-    }
-    async expireStale(olderThanMs) {
-        const cutoff = new Date(Date.now() - olderThanMs);
-        const res = await this.pool.query("UPDATE approval SET status = 'expired', reason = 'timed out before decision', decided_at = $1 " +
-            "WHERE status = 'pending' AND created_at < $2", [new Date(), cutoff]);
-        return res.rowCount ?? 0;
-    }
-}
+export { PgApprovalStore, PG_APPROVAL_SCHEMA, ensureSchema, } from "./approval-store-sql.js";
 //# sourceMappingURL=pg-approval-store.js.map

package/dist/plugins/pg-breaker-state.d.ts

@@ -1,20 +1,2 @@
-import type { Pool, PoolClient } from "pg";
-import type { BreakerSnapshot, BreakerState } from "@sema-agent/core";
-export declare const PG_BREAKER_STATE_SCHEMA: string[];
-export declare function ensureSchema(pool: Pool | PoolClient): Promise<void>;
-export declare class PgBreakerState implements BreakerState {
-    private readonly pool;
-    private readonly onWriteFail?;
-    private cache;
-    private timer?;
-    private readonly pending;
-    constructor(pool: Pool, onWriteFail?: ((streak: number) => void) | undefined);
-    private writeFailStreak;
-    get(key: string): BreakerSnapshot | undefined;
-    set(key: string, snap: BreakerSnapshot): void;
-    private writeThrough;
-    refresh(): Promise<void>;
-    startRefresh(intervalMs?: number): this;
-    stop(): void;
-}
+export { PgBreakerState, PG_BREAKER_STATE_SCHEMA, ensureSchema } from "./breaker-state-sql.js";
 //# sourceMappingURL=pg-breaker-state.d.ts.map

package/dist/plugins/pg-breaker-state.js

@@ -1,89 +1,2 @@
-export const PG_BREAKER_STATE_SCHEMA = [
-    `CREATE TABLE IF NOT EXISTS circuit_breaker (
-     breaker_key VARCHAR(190)   NOT NULL,
-     phase       VARCHAR(16)    NOT NULL,
-     failures    INTEGER        NOT NULL DEFAULT 0,
-     opened_at   TIMESTAMPTZ(3),
-     updated_at  TIMESTAMPTZ(3) NOT NULL,
-     PRIMARY KEY (breaker_key)
-   )`,
-];
-export async function ensureSchema(pool) {
-    for (const stmt of PG_BREAKER_STATE_SCHEMA)
-        await pool.query(stmt);
-}
-export class PgBreakerState {
-    pool;
-    onWriteFail;
-    cache = new Map();
-    timer;
-    pending = new Set();
-    constructor(pool, onWriteFail) {
-        this.pool = pool;
-        this.onWriteFail = onWriteFail;
-    }
-    writeFailStreak = 0;
-    get(key) {
-        return this.cache.get(key);
-    }
-    set(key, snap) {
-        this.cache.set(key, snap);
-        this.pending.add(key);
-        void this.writeThrough(key, snap);
-    }
-    async writeThrough(key, snap) {
-        try {
-            await this.pool.query("INSERT INTO circuit_breaker (breaker_key, phase, failures, opened_at, updated_at) VALUES ($1,$2,$3,$4,$5) " +
-                "ON CONFLICT (breaker_key) DO UPDATE SET phase=EXCLUDED.phase, failures=EXCLUDED.failures, opened_at=EXCLUDED.opened_at, updated_at=EXCLUDED.updated_at", [key, snap.phase, snap.failures, snap.openedAt != null ? new Date(snap.openedAt) : null, new Date()]);
-            this.pending.delete(key);
-            if (this.writeFailStreak > 0) {
-                this.writeFailStreak = 0;
-                try {
-                    this.onWriteFail?.(0);
-                }
-                catch { }
-            }
-        }
-        catch {
-            try {
-                this.onWriteFail?.(++this.writeFailStreak);
-            }
-            catch { }
-        }
-    }
-    async refresh() {
-        try {
-            const pendingAtStart = new Set(this.pending);
-            const guarded = (key) => this.pending.has(key) || pendingAtStart.has(key);
-            const res = await this.pool.query("SELECT breaker_key, phase, failures, opened_at FROM circuit_breaker");
-            const seen = new Set();
-            for (const r of res.rows) {
-                const key = String(r.breaker_key);
-                seen.add(key);
-                if (guarded(key))
-                    continue;
-                this.cache.set(key, {
-                    phase: r.phase,
-                    failures: Number(r.failures),
-                    openedAt: r.opened_at != null ? new Date(r.opened_at).getTime() : undefined,
-                });
-            }
-            for (const key of this.cache.keys())
-                if (!seen.has(key) && !guarded(key))
-                    this.cache.delete(key);
-        }
-        catch {
-        }
-    }
-    startRefresh(intervalMs = 5_000) {
-        this.timer ??= setInterval(() => void this.refresh(), intervalMs);
-        this.timer.unref?.();
-        return this;
-    }
-    stop() {
-        if (this.timer)
-            clearInterval(this.timer);
-        this.timer = undefined;
-    }
-}
+export { PgBreakerState, PG_BREAKER_STATE_SCHEMA, ensureSchema } from "./breaker-state-sql.js";
 //# sourceMappingURL=pg-breaker-state.js.map

package/dist/plugins/pg-file-snapshot-store.d.ts

@@ -1,28 +1,2 @@
-import { type FileSnapshotBounds, type FileSnapshotStore, type FileSnapshotResult, type ExecutionEnv } from "@sema-agent/core";
-import type { Pool } from "pg";
-import { type BlobBackend } from "./blob-backend.js";
-export declare class PgFileSnapshotStore implements FileSnapshotStore {
-    private readonly pool;
-    private readonly bounds;
-    private readonly inFlight;
-    private readonly blobs;
-    onSkippedVanished: ((count: number) => void | Promise<void>) | undefined;
-    constructor(pool: Pool, blobBackend?: BlobBackend, bounds?: FileSnapshotBounds);
-    private putBlobRow;
-    putBlob(hash: string, bytes: Uint8Array): Promise<FileSnapshotResult>;
-    snapshot(scope: string, key: string, env: ExecutionEnv, root: string, signal?: AbortSignal): Promise<FileSnapshotResult>;
-    importManifest(scope: string, key: string, manifest: Map<string, string>, srcGetBlob: (hash: string) => Promise<Uint8Array | undefined>): Promise<FileSnapshotResult>;
-    restore(scope: string, key: string, env: ExecutionEnv, root: string, signal?: AbortSignal): Promise<FileSnapshotResult>;
-    has(scope: string, key: string): Promise<boolean>;
-    listKeys(scope: string): Promise<string[]>;
-    exportManifest(scope: string, key: string): Promise<Map<string, string> | null>;
-    getBlob(hash: string): Promise<Uint8Array | undefined>;
-    hasBlobs(hashes: string[]): Promise<Set<string>>;
-    blobSizes(hashes: string[]): Promise<Map<string, number>>;
-    reap(scope: string, keepKeys: string[]): Promise<number>;
-    deleteBySession(scope: string): Promise<number>;
-    private gcOrphanBlobs;
-    sweepOrphanBlobs(): Promise<number>;
-    private tx;
-}
+export { PgFileSnapshotStore } from "./file-snapshot-store-sql.js";
 //# sourceMappingURL=pg-file-snapshot-store.d.ts.map

package/dist/plugins/pg-file-snapshot-store.js

@@ -1,191 +1,2 @@
-import { captureManifest, applyManifest, DEFAULT_SNAPSHOT_BOUNDS } from "@sema-agent/core";
-import { createHash } from "node:crypto";
-import { SqlBlobBackend, sqlBlobSizes } from "./blob-backend.js";
-export class PgFileSnapshotStore {
-    pool;
-    bounds;
-    inFlight = new Set();
-    blobs;
-    onSkippedVanished = undefined;
-    constructor(pool, blobBackend, bounds = DEFAULT_SNAPSHOT_BOUNDS) {
-        this.pool = pool;
-        this.bounds = bounds;
-        this.blobs = blobBackend ?? new SqlBlobBackend("pg", pool);
-    }
-    async putBlobRow(hash, bytes) {
-        await this.blobs.putBlob(hash, bytes);
-    }
-    async putBlob(hash, bytes) {
-        if (createHash("sha256").update(bytes).digest("hex") !== hash) {
-            return { ok: false, error: { code: "read_failed", message: `putBlob ${hash} fails content-address integrity — nothing stored` } };
-        }
-        try {
-            await this.putBlobRow(hash, bytes);
-            return { ok: true };
-        }
-        catch (err) {
-            return { ok: false, error: { code: "restore_failed", message: `putBlob ${hash} write/upload failed: ${err.message}` } };
-        }
-    }
-    async snapshot(scope, key, env, root, signal) {
-        const flightKey = `${scope} ${key}`;
-        if (this.inFlight.has(flightKey))
-            return { ok: true };
-        this.inFlight.add(flightKey);
-        try {
-            if (await this.has(scope, key))
-                return { ok: true };
-            let cap;
-            try {
-                cap = await captureManifest(env, root, this.bounds, signal, async (hash, bytes) => {
-                    await this.putBlobRow(hash, bytes);
-                });
-            }
-            catch (err) {
-                return { ok: false, error: { code: "restore_failed", message: `snapshot blob write failed: ${err.message}` } };
-            }
-            if (!cap.ok)
-                return { ok: false, error: cap.error };
-            if (cap.skippedVanished > 0 && this.onSkippedVanished) {
-                try {
-                    void Promise.resolve(this.onSkippedVanished(cap.skippedVanished)).catch(() => { });
-                }
-                catch { }
-            }
-            await this.tx(async (c) => {
-                const exists = await c.query("SELECT 1 FROM snapshot_manifest WHERE scope = $1 AND snap_key = $2 LIMIT 1", [scope, key]);
-                if (exists.rows[0])
-                    return;
-                for (const [relPath, hash] of cap.value) {
-                    await c.query("INSERT INTO snapshot_manifest (scope, snap_key, rel_path, blob_hash) VALUES ($1,$2,$3,$4)", [scope, key, relPath, hash]);
-                }
-            });
-            return { ok: true };
-        }
-        catch (err) {
-            return { ok: false, error: { code: "restore_failed", message: `snapshot persist failed: ${err.message}` } };
-        }
-        finally {
-            this.inFlight.delete(flightKey);
-        }
-    }
-    async importManifest(scope, key, manifest, srcGetBlob) {
-        const flightKey = `${scope} ${key}`;
-        if (this.inFlight.has(flightKey))
-            return { ok: true };
-        this.inFlight.add(flightKey);
-        try {
-            if (await this.has(scope, key))
-                return { ok: true };
-            for (const hash of new Set(manifest.values())) {
-                let bytes;
-                try {
-                    bytes = await srcGetBlob(hash);
-                }
-                catch (err) {
-                    return { ok: false, error: { code: "read_failed", message: `source blob ${hash} fetch failed: ${err.message}` } };
-                }
-                if (!bytes)
-                    return { ok: false, error: { code: "read_failed", message: `missing source blob ${hash}` } };
-                if (createHash("sha256").update(bytes).digest("hex") !== hash) {
-                    return { ok: false, error: { code: "read_failed", message: `source blob ${hash} fails content-address integrity` } };
-                }
-                await this.putBlobRow(hash, bytes);
-            }
-            await this.tx(async (c) => {
-                const exists = await c.query("SELECT 1 FROM snapshot_manifest WHERE scope = $1 AND snap_key = $2 LIMIT 1", [scope, key]);
-                if (exists.rows[0])
-                    return;
-                for (const [relPath, hash] of manifest) {
-                    await c.query("INSERT INTO snapshot_manifest (scope, snap_key, rel_path, blob_hash) VALUES ($1,$2,$3,$4)", [scope, key, relPath, hash]);
-                }
-            });
-            return { ok: true };
-        }
-        catch (err) {
-            return { ok: false, error: { code: "restore_failed", message: `import persist failed: ${err.message}` } };
-        }
-        finally {
-            this.inFlight.delete(flightKey);
-        }
-    }
-    async restore(scope, key, env, root, signal) {
-        try {
-            const r = await this.pool.query("SELECT rel_path, blob_hash FROM snapshot_manifest WHERE scope = $1 AND snap_key = $2", [scope, key]);
-            if (r.rows.length === 0)
-                return { ok: false, error: { code: "not_found", message: `no file snapshot for ${scope}/${key}` } };
-            const manifest = new Map(r.rows.map((row) => [row.rel_path, row.blob_hash]));
-            return await applyManifest(env, root, this.bounds, signal, manifest, (hash) => this.blobs.getBlob(hash));
-        }
-        catch (err) {
-            return { ok: false, error: { code: "restore_failed", message: `restore blob read failed: ${err.message}` } };
-        }
-    }
-    async has(scope, key) {
-        const r = await this.pool.query("SELECT 1 FROM snapshot_manifest WHERE scope = $1 AND snap_key = $2 LIMIT 1", [scope, key]);
-        return Boolean(r.rows[0]);
-    }
-    async listKeys(scope) {
-        const r = await this.pool.query("SELECT DISTINCT snap_key FROM snapshot_manifest WHERE scope = $1", [scope]);
-        return r.rows.map((row) => row.snap_key);
-    }
-    async exportManifest(scope, key) {
-        const r = await this.pool.query("SELECT rel_path, blob_hash FROM snapshot_manifest WHERE scope = $1 AND snap_key = $2", [scope, key]);
-        if (r.rows.length === 0)
-            return null;
-        return new Map(r.rows.map((row) => [row.rel_path, row.blob_hash]));
-    }
-    async getBlob(hash) {
-        return this.blobs.getBlob(hash);
-    }
-    async hasBlobs(hashes) {
-        return this.blobs.hasBlobs(hashes);
-    }
-    async blobSizes(hashes) {
-        return sqlBlobSizes("pg", this.pool, hashes);
-    }
-    async reap(scope, keepKeys) {
-        return this.tx(async (c) => {
-            const keys = await c.query("SELECT DISTINCT snap_key FROM snapshot_manifest WHERE scope = $1", [scope]);
-            const drop = keys.rows.map((k) => k.snap_key).filter((k) => !keepKeys.includes(k));
-            for (const k of drop)
-                await c.query("DELETE FROM snapshot_manifest WHERE scope = $1 AND snap_key = $2", [scope, k]);
-            return drop.length;
-        });
-    }
-    async deleteBySession(scope) {
-        const r = await this.pool.query("DELETE FROM snapshot_manifest WHERE scope = $1", [scope]);
-        return r.rowCount ?? 0;
-    }
-    async gcOrphanBlobs() {
-        const r = await this.pool.query("SELECT blob_hash FROM snapshot_blob WHERE blob_hash NOT IN (SELECT blob_hash FROM snapshot_manifest)").catch(() => undefined);
-        const orphans = (r?.rows ?? []).map((row) => row.blob_hash);
-        if (orphans.length === 0)
-            return 0;
-        return this.blobs.deleteBlobs(orphans);
-    }
-    async sweepOrphanBlobs() {
-        return this.gcOrphanBlobs();
-    }
-    async tx(fn) {
-        const c = await this.pool.connect();
-        try {
-            await c.query("BEGIN");
-            const out = await fn(c);
-            await c.query("COMMIT");
-            return out;
-        }
-        catch (err) {
-            try {
-                await c.query("ROLLBACK");
-            }
-            catch {
-            }
-            throw err;
-        }
-        finally {
-            c.release();
-        }
-    }
-}
+export { PgFileSnapshotStore } from "./file-snapshot-store-sql.js";
 //# sourceMappingURL=pg-file-snapshot-store.js.map

package/dist/plugins/pg-image-index.d.ts

@@ -1,23 +1,3 @@
-import type { Pool, PoolClient } from "pg";
-import { type ImageStatus, type ImageIndexEntry, type ImageIndexUpsert, type ImageViewer, type ImageListFilter } from "./store-contracts.js";
+export { PgImageIndex, PG_IMAGE_INDEX_SCHEMA, ensureSchema } from "./image-index-sql.js";
 export type { ImageNestedBuildMode, ImageCapabilities, ImagePodContract, ImageStatus, ImageVisibility, ImageIndexEntry, ImageIndexUpsert, ImageViewer, ImageListFilter, } from "./store-contracts.js";
-export declare const PG_IMAGE_INDEX_SCHEMA: string[];
-export declare function ensureSchema(pool: Pool | PoolClient): Promise<void>;
-export declare class PgImageIndex {
-    private readonly pool;
-    constructor(pool: Pool);
-    static idFor(repo: string, digest: string): string;
-    upsert(e: ImageIndexUpsert): Promise<string>;
-    registerBuilding(e: ImageIndexUpsert): Promise<string>;
-    getById(id: string): Promise<ImageIndexEntry | null>;
-    getByDigest(digest: string): Promise<ImageIndexEntry | null>;
-    latestPublished(profile: string, viewer: ImageViewer): Promise<ImageIndexEntry | null>;
-    list(filter: ImageListFilter): Promise<{
-        entries: ImageIndexEntry[];
-        nextCursor: string | null;
-    }>;
-    setStatus(id: string, status: ImageStatus, opts?: {
-        supersedes?: string | null;
-    }): Promise<void>;
-}
 //# sourceMappingURL=pg-image-index.d.ts.map