@sema-agent/server 1.315.0 → 1.316.0

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

package/dist/plugins/pg-image-index.js

@@ -1,218 +1,2 @@
-import { createHash } from "node:crypto";
-import { pgSafeJsonStringify, pgSanitizeText, pgHasUnstorable, PgUnstorableError } from "./pg-safe-json.js";
-import { mapImageRow as mapRow, } from "./store-contracts.js";
-export const PG_IMAGE_INDEX_SCHEMA = [
-    `CREATE TABLE IF NOT EXISTS sandbox_image_index (
-     id                 VARCHAR(64)  NOT NULL,
-     profile            VARCHAR(64)  NOT NULL,
-     bands              JSONB,
-     repo               VARCHAR(255) NOT NULL,
-     tag                VARCHAR(128) NOT NULL,
-     digest             VARCHAR(80)  NOT NULL,
-     toolchain_versions JSONB,
-     capabilities       JSONB,
-     pod_contract       JSONB,
-     size_bytes         BIGINT,
-     status             VARCHAR(16)  NOT NULL DEFAULT 'building',
-     visibility         VARCHAR(16)  NOT NULL DEFAULT 'public',
-     tenant_id          VARCHAR(64),
-     manifest_sha       VARCHAR(64),
-     recipe_git_sha     VARCHAR(64),
-     generator_version  VARCHAR(32),
-     build_date         TIMESTAMPTZ(3),
-     supersedes         VARCHAR(64),
-     signed             SMALLINT     NOT NULL DEFAULT 0,
-     created_at         TIMESTAMPTZ(3) NOT NULL,
-     updated_at         TIMESTAMPTZ(3) NOT NULL,
-     PRIMARY KEY (id)
-   )`,
-    `CREATE UNIQUE INDEX IF NOT EXISTS uq_repo_digest ON sandbox_image_index (repo, digest)`,
-    `CREATE INDEX IF NOT EXISTS idx_profile_status ON sandbox_image_index (profile, status, visibility)`,
-    `CREATE INDEX IF NOT EXISTS idx_digest ON sandbox_image_index (digest)`,
-    `CREATE INDEX IF NOT EXISTS idx_tenant ON sandbox_image_index (tenant_id, status)`,
-];
-export async function ensureSchema(pool) {
-    for (const stmt of PG_IMAGE_INDEX_SCHEMA)
-        await pool.query(stmt);
-}
-const MAX_LIMIT = 200;
-const DEFAULT_LIMIT = 50;
-function visibilityClause(viewer, startIdx) {
-    if (viewer.operator)
-        return { sql: "1=1", params: [], nextIdx: startIdx };
-    if (viewer.tenantId)
-        return {
-            sql: `(visibility = 'public' OR tenant_id = $${startIdx})`,
-            params: [viewer.tenantId],
-            nextIdx: startIdx + 1,
-        };
-    return { sql: "visibility = 'public'", params: [], nextIdx: startIdx };
-}
-function encodeCursor(e) {
-    return Buffer.from(`${e.createdAt}|${e.id}`, "utf8").toString("base64url");
-}
-function decodeCursor(c) {
-    try {
-        const [createdAt, id] = Buffer.from(c, "base64url").toString("utf8").split("|");
-        if (!createdAt || !id)
-            return null;
-        return { createdAt, id };
-    }
-    catch {
-        return null;
-    }
-}
-const UPSERT_COLS = "(id, profile, bands, repo, tag, digest, toolchain_versions, capabilities, pod_contract, size_bytes, " +
-    "status, visibility, tenant_id, manifest_sha, recipe_git_sha, generator_version, build_date, supersedes, " +
-    "signed, created_at, updated_at)";
-const UPSERT_VALUES = "($1,$2,$3::jsonb,$4,$5,$6,$7::jsonb,$8::jsonb,$9::jsonb,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21)";
-function upsertParams(e, id, now) {
-    return [
-        id,
-        pgSanitizeText(e.profile),
-        pgSafeJsonStringify(e.bands ?? []),
-        e.repo,
-        pgSanitizeText(e.tag),
-        e.digest,
-        pgSafeJsonStringify(e.toolchainVersions ?? {}),
-        pgSafeJsonStringify(e.capabilities ?? {}),
-        pgSafeJsonStringify(e.podContract ?? {}),
-        e.sizeBytes,
-        e.status,
-        e.visibility,
-        e.tenantId ?? null,
-        e.manifestSha ?? null,
-        e.recipeGitSha == null ? null : pgSanitizeText(e.recipeGitSha),
-        e.generatorVersion == null ? null : pgSanitizeText(e.generatorVersion),
-        e.buildDate ? new Date(e.buildDate) : null,
-        e.supersedes == null ? null : pgSanitizeText(e.supersedes),
-        e.signed ? 1 : 0,
-        now,
-        now,
-    ];
-}
-export class PgImageIndex {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-    }
-    static idFor(repo, digest) {
-        return createHash("sha256").update(`${repo}@${digest}`).digest("hex").slice(0, 64);
-    }
-    async upsert(e) {
-        if (pgHasUnstorable(e.repo))
-            throw new PgUnstorableError("image repo (identity)");
-        if (e.tenantId != null && pgHasUnstorable(e.tenantId))
-            throw new PgUnstorableError("image tenantId (identity)");
-        const id = PgImageIndex.idFor(e.repo, e.digest);
-        const now = new Date();
-        await this.pool.query(`INSERT INTO sandbox_image_index ${UPSERT_COLS}
-       VALUES ${UPSERT_VALUES}
-       ON CONFLICT (id) DO UPDATE SET
-         profile = EXCLUDED.profile, bands = EXCLUDED.bands, tag = EXCLUDED.tag,
-         toolchain_versions = EXCLUDED.toolchain_versions, capabilities = EXCLUDED.capabilities,
-         pod_contract = EXCLUDED.pod_contract, size_bytes = EXCLUDED.size_bytes,
-         status = EXCLUDED.status, visibility = EXCLUDED.visibility, tenant_id = EXCLUDED.tenant_id,
-         manifest_sha = EXCLUDED.manifest_sha, recipe_git_sha = EXCLUDED.recipe_git_sha,
-         generator_version = EXCLUDED.generator_version, build_date = EXCLUDED.build_date,
-         supersedes = EXCLUDED.supersedes, signed = EXCLUDED.signed, updated_at = EXCLUDED.updated_at`, upsertParams(e, id, now));
-        return id;
-    }
-    async registerBuilding(e) {
-        if (pgHasUnstorable(e.repo))
-            throw new PgUnstorableError("image repo (identity)");
-        if (e.tenantId != null && pgHasUnstorable(e.tenantId))
-            throw new PgUnstorableError("image tenantId (identity)");
-        const id = PgImageIndex.idFor(e.repo, e.digest);
-        const now = new Date();
-        await this.pool.query(`INSERT INTO sandbox_image_index ${UPSERT_COLS}
-       VALUES ${UPSERT_VALUES}
-       ON CONFLICT (id) DO UPDATE SET
-         profile = EXCLUDED.profile, bands = EXCLUDED.bands, tag = EXCLUDED.tag,
-         toolchain_versions = EXCLUDED.toolchain_versions, capabilities = EXCLUDED.capabilities,
-         pod_contract = EXCLUDED.pod_contract, size_bytes = EXCLUDED.size_bytes,
-         status = CASE WHEN sandbox_image_index.status = 'published'
-                       THEN sandbox_image_index.status ELSE EXCLUDED.status END,
-         visibility = CASE WHEN sandbox_image_index.status = 'published'
-                           THEN sandbox_image_index.visibility ELSE EXCLUDED.visibility END,
-         tenant_id = CASE WHEN sandbox_image_index.status = 'published'
-                          THEN sandbox_image_index.tenant_id ELSE EXCLUDED.tenant_id END,
-         manifest_sha = EXCLUDED.manifest_sha, recipe_git_sha = EXCLUDED.recipe_git_sha,
-         generator_version = EXCLUDED.generator_version, build_date = EXCLUDED.build_date,
-         supersedes = EXCLUDED.supersedes,
-         signed = CASE WHEN sandbox_image_index.status = 'published'
-                       THEN sandbox_image_index.signed ELSE EXCLUDED.signed END,
-         updated_at = EXCLUDED.updated_at`, upsertParams(e, id, now));
-        return id;
-    }
-    async getById(id) {
-        const res = await this.pool.query("SELECT * FROM sandbox_image_index WHERE id = $1 LIMIT 1", [id]);
-        return res.rows[0] ? mapRow(res.rows[0]) : null;
-    }
-    async getByDigest(digest) {
-        const res = await this.pool.query("SELECT * FROM sandbox_image_index WHERE digest = $1 ORDER BY updated_at DESC LIMIT 1", [digest]);
-        return res.rows[0] ? mapRow(res.rows[0]) : null;
-    }
-    async latestPublished(profile, viewer) {
-        const vis = visibilityClause(viewer, 2);
-        const res = await this.pool.query(`SELECT * FROM sandbox_image_index
-        WHERE profile = $1 AND status = 'published' AND ${vis.sql}
-        ORDER BY build_date DESC NULLS LAST, created_at DESC LIMIT 1`, [profile, ...vis.params]);
-        return res.rows[0] ? mapRow(res.rows[0]) : null;
-    }
-    async list(filter) {
-        const limit = Math.min(Math.max(1, filter.limit ?? DEFAULT_LIMIT), MAX_LIMIT);
-        const vis = visibilityClause(filter, 1);
-        const where = [vis.sql];
-        const params = [...vis.params];
-        let idx = vis.nextIdx;
-        if (filter.profile) {
-            where.push(`profile = $${idx++}`);
-            params.push(filter.profile);
-        }
-        if (filter.status) {
-            where.push(`status = $${idx++}`);
-            params.push(filter.status);
-        }
-        if (filter.capability) {
-            where.push(`capabilities -> $${idx++} = 'true'::jsonb`);
-            params.push(filter.capability);
-        }
-        if (filter.cursor) {
-            const c = decodeCursor(filter.cursor);
-            if (c) {
-                where.push(`(created_at < $${idx} OR (created_at = $${idx + 1} AND id < $${idx + 2}))`);
-                params.push(new Date(c.createdAt), new Date(c.createdAt), c.id);
-                idx += 3;
-            }
-        }
-        const sql = `SELECT * FROM sandbox_image_index WHERE ${where.join(" AND ")} ` +
-            `ORDER BY created_at DESC, id DESC LIMIT $${idx}`;
-        params.push(limit + 1);
-        const res = await this.pool.query(sql, params);
-        let entries = res.rows.map(mapRow);
-        let nextCursor = null;
-        if (entries.length > limit) {
-            entries = entries.slice(0, limit);
-            const last = entries[entries.length - 1];
-            nextCursor = encodeCursor({ createdAt: last.createdAt, id: last.id });
-        }
-        if (filter.latestOnly) {
-            const seen = new Set();
-            entries = entries.filter((e) => (seen.has(e.profile) ? false : (seen.add(e.profile), true)));
-        }
-        return { entries, nextCursor };
-    }
-    async setStatus(id, status, opts) {
-        const sets = ["status = $1", "updated_at = $2"];
-        const params = [status, new Date()];
-        let idx = 3;
-        if (opts && "supersedes" in opts) {
-            sets.push(`supersedes = $${idx++}`);
-            params.push(opts.supersedes ?? null);
-        }
-        params.push(id);
-        await this.pool.query(`UPDATE sandbox_image_index SET ${sets.join(", ")} WHERE id = $${idx}`, params);
-    }
-}
+export { PgImageIndex, PG_IMAGE_INDEX_SCHEMA, ensureSchema } from "./image-index-sql.js";
 //# sourceMappingURL=pg-image-index.js.map