ghcr-manager 0.0.4 → 0.9.0

package/dist/db/planner/_planner-plan-artifacts.js

@@ -0,0 +1,211 @@
+import { mapBlockedRootRow, mapClosureManifestRow } from "./_planner-types.js";
+export class PlannerPlanArtifacts {
+    #sql;
+    constructor(sql) {
+        this.#sql = sql;
+    }
+    build(scanId, directTargetRoots) {
+        const deleteRootCandidates = directTargetRoots.filter((root) => root.selectionMode === "delete-root");
+        if (deleteRootCandidates.length === 0) {
+            return {
+                closureManifests: [],
+                blockedRoots: [],
+                fullyDeletableRoots: []
+            };
+        }
+        return this.#withDirectTargetRootsTempTable(deleteRootCandidates, () => {
+            const closureManifests = this.#listClosureManifests(scanId);
+            const blockedRoots = this.#listBlockedRoots(scanId);
+            const blockedVersionIds = new Set(blockedRoots.map((root) => root.blockedVersionId));
+            const fullyDeletableRoots = deleteRootCandidates.filter((root) => !blockedVersionIds.has(root.versionId));
+            return {
+                closureManifests,
+                blockedRoots,
+                fullyDeletableRoots
+            };
+        });
+    }
+    #listClosureManifests(scanId) {
+        const sql = `
+      WITH direct_target_closure AS (
+        SELECT
+          dtr.root_version_id AS source_version_id,
+          dtr.root_digest AS source_digest,
+          dtr.root_version_id AS member_version_id,
+          dtr.root_digest AS member_digest,
+          dtr.root_manifest_kind AS member_manifest_kind,
+          0 AS hops_from_root,
+          'root' AS member_role
+        FROM temp_direct_target_roots dtr
+
+        UNION ALL
+
+        SELECT
+          dtr.root_version_id AS source_version_id,
+          dtr.root_digest AS source_digest,
+          m.version_id AS member_version_id,
+          m.digest AS member_digest,
+          m.manifest_kind AS member_manifest_kind,
+          mr.min_distance AS hops_from_root,
+          'descendant' AS member_role
+        FROM temp_direct_target_roots dtr
+        JOIN manifest_reachability mr
+          ON mr.scan_id = ?
+         AND mr.ancestor_digest = dtr.root_digest
+         AND mr.min_distance > 0
+        JOIN manifests m
+          ON m.scan_id = ?
+         AND m.digest = mr.descendant_digest
+      )
+      SELECT
+        source_version_id,
+        source_digest,
+        member_version_id,
+        member_digest,
+        member_manifest_kind,
+        hops_from_root,
+        member_role
+      FROM direct_target_closure
+      ORDER BY source_digest, hops_from_root, member_digest
+    `;
+        return this.#sql.all(sql, [scanId, scanId]).map(mapClosureManifestRow);
+    }
+    #listBlockedRoots(scanId) {
+        const sql = `
+      WITH retained_roots AS (
+        SELECT
+          m.version_id AS root_version_id,
+          m.digest AS root_digest
+        FROM manifests m
+        WHERE m.scan_id = ?
+          AND NOT EXISTS (
+            SELECT 1
+            FROM manifest_reachability mr
+            WHERE mr.scan_id = m.scan_id
+              AND mr.descendant_digest = m.digest
+              AND mr.min_distance > 0
+          )
+          AND NOT EXISTS (
+            SELECT 1
+            FROM temp_direct_target_roots dtr
+            WHERE dtr.root_digest = m.digest
+          )
+      ),
+      direct_target_closure AS (
+        SELECT
+          dtr.root_version_id AS root_version_id,
+          dtr.root_digest AS root_digest,
+          dtr.root_manifest_kind AS member_manifest_kind,
+          dtr.root_digest AS member_digest,
+          0 AS hops_from_root
+        FROM temp_direct_target_roots dtr
+
+        UNION ALL
+
+        SELECT
+          dtr.root_version_id AS root_version_id,
+          dtr.root_digest AS root_digest,
+          m.manifest_kind AS member_manifest_kind,
+          m.digest AS member_digest,
+          mr.min_distance AS hops_from_root
+        FROM temp_direct_target_roots dtr
+        JOIN manifest_reachability mr
+          ON mr.scan_id = ?
+         AND mr.ancestor_digest = dtr.root_digest
+         AND mr.min_distance > 0
+        JOIN manifests m
+          ON m.scan_id = ?
+         AND m.digest = mr.descendant_digest
+      ),
+      ranked_blocks AS (
+        SELECT
+          dtc.root_version_id AS blocked_version_id,
+          dtc.root_digest AS blocked_digest,
+          rr.root_version_id AS blocking_version_id,
+          rr.root_digest AS blocking_digest,
+          dtc.member_digest AS overlap_digest,
+          dtc.member_manifest_kind AS overlap_manifest_kind,
+          'overlap-with-retained-root' AS block_reason,
+          ROW_NUMBER() OVER (
+            PARTITION BY dtc.root_digest, rr.root_digest
+            ORDER BY
+              dtc.hops_from_root,
+              retained_overlap.min_distance,
+              dtc.member_digest
+          ) AS rn
+        FROM direct_target_closure dtc
+        JOIN retained_roots rr
+          ON rr.root_digest <> dtc.root_digest
+        JOIN manifest_reachability retained_overlap
+          ON retained_overlap.scan_id = ?
+         AND retained_overlap.ancestor_digest = rr.root_digest
+         AND retained_overlap.descendant_digest = dtc.member_digest
+      )
+      SELECT
+        blocked_version_id,
+        blocked_digest,
+        blocking_version_id,
+        blocking_digest,
+        overlap_digest,
+        overlap_manifest_kind,
+        block_reason
+      FROM ranked_blocks
+      WHERE rn = 1
+      ORDER BY blocked_digest, blocking_digest, overlap_digest
+    `;
+        return this.#sql
+            .all(sql, [scanId, scanId, scanId, scanId])
+            .map(mapBlockedRootRow);
+    }
+    #withDirectTargetRootsTempTable(directTargetRoots, callback) {
+        this.#sql.exec(`
+      CREATE TEMP TABLE IF NOT EXISTS temp_direct_target_roots (
+        root_version_id INTEGER NOT NULL,
+        root_digest TEXT NOT NULL,
+        root_manifest_kind TEXT,
+        direct_target_reason TEXT NOT NULL,
+        selection_mode TEXT NOT NULL
+      )
+    `);
+        this.#sql.exec(`
+      CREATE INDEX IF NOT EXISTS idx_temp_direct_target_roots_digest
+        ON temp_direct_target_roots(root_digest)
+    `);
+        this.#sql.exec(`
+      CREATE INDEX IF NOT EXISTS idx_temp_direct_target_roots_version_digest
+        ON temp_direct_target_roots(root_version_id, root_digest)
+    `);
+        this.#sql.exec("DELETE FROM temp_direct_target_roots");
+        this.#insertDirectTargetRoots(directTargetRoots);
+        try {
+            return callback();
+        }
+        finally {
+            this.#sql.exec("DELETE FROM temp_direct_target_roots");
+        }
+    }
+    #insertDirectTargetRoots(directTargetRoots) {
+        const insertSql = `
+      INSERT INTO temp_direct_target_roots (
+        root_version_id,
+        root_digest,
+        root_manifest_kind,
+        direct_target_reason,
+        selection_mode
+      ) VALUES (?, ?, ?, ?, ?)
+    `;
+        this.#sql.traceSql(insertSql, ["<chunked rows omitted>"]);
+        const insert = this.#sql.database.prepare(insertSql);
+        const insertMany = this.#sql.database.transaction((roots) => {
+            for (const root of roots) {
+                insert.run(root.versionId, root.digest, root.manifestKind ?? null, root.reason, root.selectionMode);
+            }
+        });
+        const chunkSize = 1000;
+        for (let index = 0; index < directTargetRoots.length; index += chunkSize) {
+            const chunk = directTargetRoots.slice(index, index + chunkSize);
+            insertMany(chunk);
+            this.#sql.logger.debug(`Inserted ${chunk.length} direct target root row(s) into temp_direct_target_roots`);
+        }
+    }
+}

package/dist/db/planner/_planner-repository.d.ts

@@ -0,0 +1,34 @@
+import type Database from "better-sqlite3";
+import type { DeletePlan, PlannerLogger } from "./_planner-types.js";
+export type { DeletePlan, DeletePlanBlockedRoot, DeletePlanClosureManifest, DeletePlanProtectedRoot, DeletePlanRoot, DeletePlanRootDecision } from "./_planner-types.js";
+export declare class PlannerRepository {
+    #private;
+    constructor(database: Database.Database, logger?: PlannerLogger);
+    getDeleteUntaggedPlan(owner: string, packageName: string): DeletePlan;
+    getLatestCompletedScanId(owner: string, packageName: string): number;
+    getKeepNUntaggedPlan(owner: string, packageName: string, keepCount: number): DeletePlan;
+    getKeepNTaggedPlan(owner: string, packageName: string, keepCount: number): DeletePlan;
+    getDeleteUntaggedPlanWithCutoff(owner: string, packageName: string, options?: {
+        olderThan?: string;
+        cutoffTimestamp?: string;
+    }): DeletePlan;
+    getKeepNUntaggedPlanWithCutoff(owner: string, packageName: string, keepCount: number, options?: {
+        olderThan?: string;
+        cutoffTimestamp?: string;
+    }): DeletePlan;
+    getKeepNTaggedPlanWithCutoff(owner: string, packageName: string, keepCount: number, excludeTags: string[], options?: {
+        olderThan?: string;
+        cutoffTimestamp?: string;
+    }): DeletePlan;
+    getDeleteTagsPlan(owner: string, packageName: string, deleteTags: string[], excludeTags: string[]): DeletePlan;
+    getDeleteTagsPlanWithCutoff(owner: string, packageName: string, deleteTags: string[], excludeTags: string[], options?: {
+        deleteTagsRequested?: boolean;
+        deleteGhostImages?: boolean;
+        deletePartialImages?: boolean;
+        deleteOrphanedImages?: boolean;
+        keepNTagged?: number;
+        useRegex?: boolean;
+        olderThan?: string;
+        cutoffTimestamp?: string;
+    }): DeletePlan;
+}

package/dist/db/planner/_planner-repository.js

@@ -0,0 +1,126 @@
+import { buildPlanOutputs } from "./_planner-output.js";
+import { PlannerPlanArtifacts } from "./_planner-plan-artifacts.js";
+import { PlannerSql } from "./_planner-sql.js";
+import { PlannerTaggedTargets } from "./_planner-tagged-targets.js";
+import { PlannerUntaggedTargets } from "./_planner-untagged-targets.js";
+export class PlannerRepository {
+    #untaggedTargets;
+    #taggedTargets;
+    #planArtifacts;
+    constructor(database, logger) {
+        const sql = new PlannerSql(database, logger);
+        this.#untaggedTargets = new PlannerUntaggedTargets(sql);
+        this.#taggedTargets = new PlannerTaggedTargets(sql);
+        this.#planArtifacts = new PlannerPlanArtifacts(sql);
+    }
+    getDeleteUntaggedPlan(owner, packageName) {
+        return this.getDeleteUntaggedPlanWithCutoff(owner, packageName);
+    }
+    getLatestCompletedScanId(owner, packageName) {
+        return this.#untaggedTargets.getLatestCompletedScan(owner, packageName).scan_id;
+    }
+    getKeepNUntaggedPlan(owner, packageName, keepCount) {
+        return this.getKeepNUntaggedPlanWithCutoff(owner, packageName, keepCount);
+    }
+    getKeepNTaggedPlan(owner, packageName, keepCount) {
+        return this.getKeepNTaggedPlanWithCutoff(owner, packageName, keepCount, []);
+    }
+    getDeleteUntaggedPlanWithCutoff(owner, packageName, options) {
+        const scan = this.#untaggedTargets.getLatestCompletedScan(owner, packageName);
+        const directTargetRoots = this.#untaggedTargets.listDeleteUntaggedDirectTargetRoots(scan.scan_id, options?.cutoffTimestamp);
+        const planArtifacts = this.#planArtifacts.build(scan.scan_id, directTargetRoots);
+        return {
+            owner: scan.owner,
+            packageName: scan.package_name,
+            scanCompletedAt: scan.scan_completed_at,
+            plannerInputs: _buildPlannerInputs({
+                deleteUntagged: true,
+                olderThan: options?.olderThan,
+                cutoffTimestamp: options?.cutoffTimestamp
+            }),
+            ...buildPlanOutputs([], directTargetRoots, planArtifacts)
+        };
+    }
+    getKeepNUntaggedPlanWithCutoff(owner, packageName, keepCount, options) {
+        const scan = this.#untaggedTargets.getLatestCompletedScan(owner, packageName);
+        const directTargetRoots = this.#untaggedTargets.listKeepNUntaggedDirectTargetRoots(scan.scan_id, keepCount, options?.cutoffTimestamp);
+        const planArtifacts = this.#planArtifacts.build(scan.scan_id, directTargetRoots);
+        return {
+            owner: scan.owner,
+            packageName: scan.package_name,
+            scanCompletedAt: scan.scan_completed_at,
+            plannerInputs: _buildPlannerInputs({
+                keepNUntagged: keepCount,
+                olderThan: options?.olderThan,
+                cutoffTimestamp: options?.cutoffTimestamp
+            }),
+            ...buildPlanOutputs([], directTargetRoots, planArtifacts)
+        };
+    }
+    getKeepNTaggedPlanWithCutoff(owner, packageName, keepCount, excludeTags, options) {
+        const scan = this.#untaggedTargets.getLatestCompletedScan(owner, packageName);
+        const directTargetRoots = this.#taggedTargets.listTaggedDirectTargetRoots(scan.scan_id, {
+            deleteTags: [],
+            excludeTags,
+            keepCount,
+            cutoffTimestamp: options?.cutoffTimestamp
+        });
+        const planArtifacts = this.#planArtifacts.build(scan.scan_id, directTargetRoots);
+        return {
+            owner: scan.owner,
+            packageName: scan.package_name,
+            scanCompletedAt: scan.scan_completed_at,
+            plannerInputs: _buildPlannerInputs({
+                excludeTags,
+                keepNTagged: keepCount,
+                olderThan: options?.olderThan,
+                cutoffTimestamp: options?.cutoffTimestamp
+            }),
+            ...buildPlanOutputs([], directTargetRoots, planArtifacts)
+        };
+    }
+    getDeleteTagsPlan(owner, packageName, deleteTags, excludeTags) {
+        return this.getDeleteTagsPlanWithCutoff(owner, packageName, deleteTags, excludeTags);
+    }
+    getDeleteTagsPlanWithCutoff(owner, packageName, deleteTags, excludeTags, options) {
+        const scan = this.#untaggedTargets.getLatestCompletedScan(owner, packageName);
+        const directTargetTags = this.#taggedTargets.listDeleteTagDirectTargetTags(scan.scan_id, deleteTags, excludeTags, options?.useRegex ?? false, options?.cutoffTimestamp);
+        const directTargetRoots = this.#taggedTargets.listTaggedDirectTargetRoots(scan.scan_id, {
+            deleteTags,
+            deleteTagsRequested: options?.deleteTagsRequested ?? true,
+            excludeTags,
+            keepCount: options?.keepNTagged,
+            useRegex: options?.useRegex ?? false,
+            cutoffTimestamp: options?.cutoffTimestamp
+        });
+        const planArtifacts = this.#planArtifacts.build(scan.scan_id, directTargetRoots);
+        return {
+            owner: scan.owner,
+            packageName: scan.package_name,
+            scanCompletedAt: scan.scan_completed_at,
+            plannerInputs: _buildPlannerInputs({
+                deleteGhostImages: options?.deleteGhostImages || undefined,
+                deletePartialImages: options?.deletePartialImages || undefined,
+                deleteOrphanedImages: options?.deleteOrphanedImages || undefined,
+                deleteTags,
+                excludeTags,
+                keepNTagged: options?.keepNTagged,
+                useRegex: options?.useRegex || undefined,
+                olderThan: options?.olderThan,
+                cutoffTimestamp: options?.cutoffTimestamp
+            }),
+            ...buildPlanOutputs(directTargetTags, directTargetRoots, planArtifacts)
+        };
+    }
+}
+function _buildPlannerInputs(inputs) {
+    return Object.fromEntries(Object.entries(inputs).filter(([, value]) => {
+        if (value === undefined) {
+            return false;
+        }
+        if (value === false) {
+            return false;
+        }
+        return !(Array.isArray(value) && value.length === 0);
+    }));
+}

package/dist/db/planner/_planner-sql.d.ts

@@ -0,0 +1,12 @@
+import type Database from "better-sqlite3";
+import { type PlannerLogger } from "./_planner-types.js";
+export declare class PlannerSql {
+    #private;
+    constructor(database: Database.Database, logger?: PlannerLogger);
+    get database(): Database.Database;
+    get logger(): PlannerLogger;
+    exec(sql: string, params?: Array<number | string | null>): void;
+    get<T>(sql: string, params: Array<number | string>): T | undefined;
+    all<T>(sql: string, params: Array<number | string>): T[];
+    traceSql(sql: string, params: Array<number | string | null>): void;
+}

package/dist/db/planner/_planner-sql.js

@@ -0,0 +1,35 @@
+import { silentPlannerLogger } from "./_planner-types.js";
+export class PlannerSql {
+    #database;
+    #logger;
+    constructor(database, logger = silentPlannerLogger) {
+        this.#database = database;
+        this.#logger = logger;
+    }
+    get database() {
+        return this.#database;
+    }
+    get logger() {
+        return this.#logger;
+    }
+    exec(sql, params = []) {
+        this.#traceSql(sql, params);
+        this.#database.prepare(sql).run(...params);
+    }
+    get(sql, params) {
+        this.#traceSql(sql, params);
+        return this.#database.prepare(sql).get(...params);
+    }
+    all(sql, params) {
+        this.#traceSql(sql, params);
+        const rows = this.#database.prepare(sql).all(...params);
+        this.#logger.debug(`SQL returned ${rows.length} row(s)`);
+        return rows;
+    }
+    traceSql(sql, params) {
+        this.#traceSql(sql, params);
+    }
+    #traceSql(sql, params) {
+        this.#logger.trace(`SQL:\n${sql.trim()}\nPARAMS: ${JSON.stringify(params)}`);
+    }
+}

package/dist/db/planner/_planner-tag-selectors.d.ts

@@ -0,0 +1,8 @@
+import type Database from "better-sqlite3";
+export interface PlannerTagSelectorPredicate {
+    sql: string;
+    params: string[];
+}
+export declare function buildTagSelectorPredicate(database: Database.Database, columnSql: string, selectors: string[], useRegex: boolean): PlannerTagSelectorPredicate;
+export declare function wildcardSelectorToSqlLike(selector: string): string;
+export declare function hasWildcard(selector: string): boolean;

package/dist/db/planner/_planner-tag-selectors.js

@@ -0,0 +1,57 @@
+export function buildTagSelectorPredicate(database, columnSql, selectors, useRegex) {
+    if (selectors.length === 0) {
+        throw new Error("selectors must not be empty");
+    }
+    if (useRegex) {
+        registerRegexFunction(database);
+    }
+    return {
+        sql: selectors
+            .map((selector) => {
+            if (useRegex) {
+                return `regexp(?, ${columnSql})`;
+            }
+            return hasWildcard(selector) ? `${columnSql} LIKE ? ESCAPE '\\'` : `${columnSql} = ?`;
+        })
+            .join(" OR "),
+        params: useRegex ? selectors : selectors.map((selector) => wildcardSelectorToSqlLike(selector))
+    };
+}
+export function wildcardSelectorToSqlLike(selector) {
+    if (!hasWildcard(selector)) {
+        return selector;
+    }
+    return selector.replaceAll(/[%_\\*?]/g, (character) => {
+        switch (character) {
+            case "%":
+            case "_":
+            case "\\":
+                return `\\${character}`;
+            case "*":
+                return "%";
+            case "?":
+                return "_";
+            default:
+                return character;
+        }
+    });
+}
+export function hasWildcard(selector) {
+    return selector.includes("*") || selector.includes("?");
+}
+function registerRegexFunction(database) {
+    const markedDatabase = database;
+    if (markedDatabase.__ghcrManagerRegexRegistered) {
+        return;
+    }
+    markedDatabase.__ghcrManagerRegexCache = new Map();
+    database.function("regexp", (pattern, value) => {
+        let compiled = markedDatabase.__ghcrManagerRegexCache?.get(pattern);
+        if (!compiled) {
+            compiled = new RegExp(pattern);
+            markedDatabase.__ghcrManagerRegexCache?.set(pattern, compiled);
+        }
+        return compiled.test(value) ? 1 : 0;
+    });
+    markedDatabase.__ghcrManagerRegexRegistered = true;
+}

package/dist/db/planner/_planner-tagged-root-targets.d.ts

@@ -0,0 +1,15 @@
+import { PlannerSql } from "./_planner-sql.js";
+import type { DeletePlanRoot } from "./_planner-types.js";
+export interface TaggedRootTargetOptions {
+    deleteTags: string[];
+    deleteTagsRequested?: boolean;
+    excludeTags: string[];
+    keepCount?: number;
+    useRegex?: boolean;
+    cutoffTimestamp?: string;
+}
+export declare class PlannerTaggedRootTargets {
+    #private;
+    constructor(sql: PlannerSql);
+    listTaggedDirectTargetRoots(scanId: number, options: TaggedRootTargetOptions): DeletePlanRoot[];
+}

package/dist/db/planner/_planner-tagged-root-targets.js

@@ -0,0 +1,19 @@
+import { PlannerDeleteTagRootTargets } from "./_planner-delete-tag-root-targets.js";
+import { PlannerKeepTaggedRootTargets } from "./_planner-keep-tagged-root-targets.js";
+export class PlannerTaggedRootTargets {
+    #deleteTagTargets;
+    #keepTaggedTargets;
+    constructor(sql) {
+        this.#deleteTagTargets = new PlannerDeleteTagRootTargets(sql);
+        this.#keepTaggedTargets = new PlannerKeepTaggedRootTargets(sql);
+    }
+    listTaggedDirectTargetRoots(scanId, options) {
+        if (options.deleteTagsRequested && options.deleteTags.length === 0) {
+            return [];
+        }
+        if (options.deleteTags.length === 0) {
+            return this.#keepTaggedTargets.list(scanId, options.excludeTags, options.useRegex ?? false, options.keepCount, options.cutoffTimestamp);
+        }
+        return this.#deleteTagTargets.list(scanId, options.deleteTags, options.excludeTags, options.useRegex ?? false, options.keepCount, options.cutoffTimestamp);
+    }
+}

package/dist/db/planner/_planner-tagged-targets.d.ts

@@ -0,0 +1,8 @@
+import { type TaggedRootTargetOptions } from "./_planner-tagged-root-targets.js";
+import { PlannerSql } from "./_planner-sql.js";
+export declare class PlannerTaggedTargets {
+    #private;
+    constructor(sql: PlannerSql);
+    listDeleteTagDirectTargetTags(scanId: number, deleteTags: string[], excludeTags: string[], useRegex: boolean, cutoffTimestamp?: string): string[];
+    listTaggedDirectTargetRoots(scanId: number, options: TaggedRootTargetOptions): import("./_planner-types.js").DeletePlanRoot[];
+}

package/dist/db/planner/_planner-tagged-targets.js

@@ -0,0 +1,16 @@
+import { PlannerDirectTargetTags } from "./_planner-direct-target-tags.js";
+import { PlannerTaggedRootTargets } from "./_planner-tagged-root-targets.js";
+export class PlannerTaggedTargets {
+    #directTargetTags;
+    #rootTargets;
+    constructor(sql) {
+        this.#directTargetTags = new PlannerDirectTargetTags(sql);
+        this.#rootTargets = new PlannerTaggedRootTargets(sql);
+    }
+    listDeleteTagDirectTargetTags(scanId, deleteTags, excludeTags, useRegex, cutoffTimestamp) {
+        return this.#directTargetTags.listDeleteTagDirectTargetTags(scanId, deleteTags, excludeTags, useRegex, cutoffTimestamp);
+    }
+    listTaggedDirectTargetRoots(scanId, options) {
+        return this.#rootTargets.listTaggedDirectTargetRoots(scanId, options);
+    }
+}

package/dist/db/planner/_planner-types.d.ts

@@ -0,0 +1,135 @@
+interface _PlanRootRow {
+    version_id: number;
+    root_digest: string;
+    root_manifest_kind: string | null;
+    direct_target_reason: string;
+    selection_mode: string;
+}
+interface _PlanTagRow {
+    target_tag: string;
+}
+interface _ClosureManifestRow {
+    source_version_id: number;
+    source_digest: string;
+    member_version_id: number;
+    member_digest: string;
+    member_manifest_kind: string | null;
+    hops_from_root: number;
+    member_role: string;
+}
+interface _BlockedRootRow {
+    blocked_version_id: number;
+    blocked_digest: string;
+    blocking_version_id: number;
+    blocking_digest: string;
+    overlap_digest: string;
+    overlap_manifest_kind: string | null;
+    block_reason: string;
+}
+export interface PlannerLogger {
+    trace(message: string): void;
+    debug(message: string): void;
+    warn?(message: string): void;
+}
+export interface ScanRow {
+    scan_id: number;
+    owner: string;
+    package_name: string;
+    scan_completed_at: string;
+}
+export interface DeletePlanRoot {
+    versionId: number;
+    digest: string;
+    manifestKind?: string;
+    reason: string;
+    selectionMode: string;
+}
+export interface DeletePlanClosureManifest {
+    sourceVersionId: number;
+    sourceDigest: string;
+    memberVersionId: number;
+    memberDigest: string;
+    memberManifestKind?: string;
+    hopsFromRoot: number;
+    memberRole: string;
+}
+export interface DeletePlanBlockedRoot {
+    blockedVersionId: number;
+    blockedDigest: string;
+    blockingVersionId: number;
+    blockingDigest: string;
+    overlapDigest: string;
+    overlapManifestKind?: string;
+    reason: string;
+}
+export interface DeletePlanRootDecision {
+    versionId: number;
+    digest: string;
+    manifestKind?: string;
+    selectionMode: string;
+    selectionReason: string;
+    validationStatus: "fully-deletable" | "blocked" | "untag-only";
+    validationReasonCode: "untag-only-partial-tag-match" | "fully-deletable-no-retained-overlap" | "blocked-overlap-with-retained-root";
+    validationReason: string;
+    blockingVersionId?: number;
+    blockingDigest?: string;
+    overlapDigest?: string;
+    overlapManifestKind?: string;
+}
+export interface DeletePlanProtectedRoot {
+    versionId: number;
+    digest: string;
+    blocks: Array<{
+        blockedVersionId: number;
+        blockedDigest: string;
+        blockReasonCode: string;
+        overlapDigest: string;
+        overlapManifestKind?: string;
+    }>;
+}
+export interface PlanArtifacts {
+    closureManifests: DeletePlanClosureManifest[];
+    blockedRoots: DeletePlanBlockedRoot[];
+    fullyDeletableRoots: DeletePlanRoot[];
+}
+export interface DeletePlan {
+    owner: string;
+    packageName: string;
+    scanCompletedAt: string;
+    plannerInputs: {
+        deleteUntagged?: boolean;
+        deleteGhostImages?: boolean;
+        deletePartialImages?: boolean;
+        deleteOrphanedImages?: boolean;
+        deleteTags?: string[];
+        excludeTags?: string[];
+        keepNTagged?: number;
+        keepNUntagged?: number;
+        useRegex?: boolean;
+        olderThan?: string;
+        cutoffTimestamp?: string;
+    };
+    validationSummary: {
+        directTargetTagCount: number;
+        directTargetRootCount: number;
+        deleteRootCandidateCount: number;
+        untagOnlyRootCount: number;
+        fullyDeletableRootCount: number;
+        blockedDeleteRootCount: number;
+        protectedRootCount: number;
+    };
+    directTargetTags: string[];
+    directTargetRoots: DeletePlanRoot[];
+    rootDecisions: DeletePlanRootDecision[];
+    protectedRoots: DeletePlanProtectedRoot[];
+    closureManifests: DeletePlanClosureManifest[];
+    blockedRoots: DeletePlanBlockedRoot[];
+    fullyDeletableRoots: DeletePlanRoot[];
+    collateralTags: string[];
+}
+export declare const silentPlannerLogger: PlannerLogger;
+export declare function mapPlanRootRow(row: _PlanRootRow): DeletePlanRoot;
+export declare function mapPlanTagRows(rows: _PlanTagRow[]): string[];
+export declare function mapClosureManifestRow(row: _ClosureManifestRow): DeletePlanClosureManifest;
+export declare function mapBlockedRootRow(row: _BlockedRootRow): DeletePlanBlockedRoot;
+export {};