ghcr-cleanup-manager 1.1.0

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

@@ -0,0 +1,46 @@
+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);
+        const startedAt = Date.now();
+        this.#database.prepare(sql).run(...params);
+        this.#logger.trace(`SQL exec completed in ${Date.now() - startedAt} ms`);
+    }
+    get(sql, params) {
+        this.#debugSql(sql, params);
+        this.#traceSql(sql, params);
+        const startedAt = Date.now();
+        const row = this.#database.prepare(sql).get(...params);
+        this.#logger.debug(`SQL returned ${row === undefined ? "0" : "1"} row(s) in ${Date.now() - startedAt} ms`);
+        return row;
+    }
+    all(sql, params) {
+        this.#debugSql(sql, params);
+        this.#traceSql(sql, params);
+        const startedAt = Date.now();
+        const rows = this.#database.prepare(sql).all(...params);
+        this.#logger.debug(`SQL returned ${rows.length} row(s) in ${Date.now() - startedAt} ms`);
+        return rows;
+    }
+    traceSql(sql, params) {
+        this.#traceSql(sql, params);
+    }
+    #traceSql(sql, params) {
+        this.#logger.trace(`SQL:\n${sql.trim()}\nPARAMS: ${JSON.stringify(params)}`);
+    }
+    #debugSql(sql, params) {
+        this.#logger.debug(`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-types.d.ts

@@ -0,0 +1,144 @@
+interface _PlanRootRow {
+    version_id: number;
+    root_digest: string;
+    root_manifest_kind: string | null;
+    direct_target_reason: DeletePlanSelectionReason;
+    selection_mode: DeletePlanSelectionMode;
+}
+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: DeletePlanBlockReasonCode;
+}
+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 type DeletePlanSelectionMode = "delete-root" | "untag-only";
+export type DeletePlanSelectionReason = "delete-tags-all-tags-selected" | "delete-tags-partial-tag-match" | "delete-untagged" | "keep-n-tagged-overflow" | "keep-n-untagged-overflow";
+export type DeletePlanBlockReasonCode = "overlap-with-retained-root";
+export declare const DeletePlanValidationStatuses: {
+    readonly fullyDeletable: "fully-deletable";
+    readonly blocked: "blocked";
+    readonly untagOnly: "untag-only";
+};
+export type DeletePlanValidationStatus = (typeof DeletePlanValidationStatuses)[keyof typeof DeletePlanValidationStatuses];
+export declare const DeletePlanValidationReasonCodes: {
+    readonly untagOnlyPartialTagMatch: "untag-only-partial-tag-match";
+    readonly untagOnlyRetainedManifest: "untag-only-retained-manifest";
+    readonly fullyDeletableNoRetainedOverlap: "fully-deletable-no-retained-overlap";
+    readonly blockedOverlapWithRetainedRoot: "blocked-overlap-with-retained-root";
+};
+export type DeletePlanValidationReasonCode = (typeof DeletePlanValidationReasonCodes)[keyof typeof DeletePlanValidationReasonCodes];
+export interface DeletePlanRoot {
+    versionId: number;
+    digest: string;
+    manifestKind?: ManifestKind;
+    reason: DeletePlanSelectionReason;
+    selectionMode: DeletePlanSelectionMode;
+}
+export interface DeletePlanClosureManifest {
+    sourceVersionId: number;
+    sourceDigest: string;
+    memberVersionId: number;
+    memberDigest: string;
+    memberManifestKind?: ManifestKind;
+    hopsFromRoot: number;
+    memberRole: string;
+}
+export interface DeletePlanBlockedRoot {
+    blockedVersionId: number;
+    blockedDigest: string;
+    blockingVersionId: number;
+    blockingDigest: string;
+    overlapDigest: string;
+    overlapManifestKind?: ManifestKind;
+    reason: DeletePlanBlockReasonCode;
+}
+export interface DeletePlanRootDecision {
+    versionId: number;
+    digest: string;
+    manifestKind?: ManifestKind;
+    selectionMode: DeletePlanSelectionMode;
+    selectionReason: DeletePlanSelectionReason;
+    validationStatus: DeletePlanValidationStatus;
+    validationReasonCode: DeletePlanValidationReasonCode;
+    validationReason: string;
+    blockingVersionId?: number;
+    blockingDigest?: string;
+    overlapDigest?: string;
+    overlapManifestKind?: ManifestKind;
+}
+export interface DeletePlanProtectedRoot {
+    versionId: number;
+    digest: string;
+    blocks: Array<{
+        blockedVersionId: number;
+        blockedDigest: string;
+        blockReasonCode: DeletePlanBlockReasonCode;
+        overlapDigest: string;
+        overlapManifestKind?: ManifestKind;
+    }>;
+}
+export interface PlanArtifacts {
+    closureManifests: DeletePlanClosureManifest[];
+    blockedRoots: DeletePlanBlockedRoot[];
+    fullyDeletableRoots: DeletePlanRoot[];
+    supportedUntagOnlyRootDigests: Set<string>;
+}
+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;
+    };
+    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;
+import type { ManifestKind } from "../../core/index.js";
+export {};

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

@@ -0,0 +1,49 @@
+export const DeletePlanValidationStatuses = {
+    fullyDeletable: "fully-deletable",
+    blocked: "blocked",
+    untagOnly: "untag-only"
+};
+export const DeletePlanValidationReasonCodes = {
+    untagOnlyPartialTagMatch: "untag-only-partial-tag-match",
+    untagOnlyRetainedManifest: "untag-only-retained-manifest",
+    fullyDeletableNoRetainedOverlap: "fully-deletable-no-retained-overlap",
+    blockedOverlapWithRetainedRoot: "blocked-overlap-with-retained-root"
+};
+export const silentPlannerLogger = {
+    trace() { },
+    debug() { }
+};
+export function mapPlanRootRow(row) {
+    return {
+        versionId: row.version_id,
+        digest: row.root_digest,
+        manifestKind: (row.root_manifest_kind ?? undefined),
+        reason: row.direct_target_reason,
+        selectionMode: row.selection_mode
+    };
+}
+export function mapPlanTagRows(rows) {
+    return rows.map((row) => row.target_tag);
+}
+export function mapClosureManifestRow(row) {
+    return {
+        sourceVersionId: row.source_version_id,
+        sourceDigest: row.source_digest,
+        memberVersionId: row.member_version_id,
+        memberDigest: row.member_digest,
+        memberManifestKind: (row.member_manifest_kind ?? undefined),
+        hopsFromRoot: row.hops_from_root,
+        memberRole: row.member_role
+    };
+}
+export function mapBlockedRootRow(row) {
+    return {
+        blockedVersionId: row.blocked_version_id,
+        blockedDigest: row.blocked_digest,
+        blockingVersionId: row.blocking_version_id,
+        blockingDigest: row.blocking_digest,
+        overlapDigest: row.overlap_digest,
+        overlapManifestKind: (row.overlap_manifest_kind ?? undefined),
+        reason: row.block_reason
+    };
+}

package/dist/db/planner/index.d.ts

@@ -0,0 +1,3 @@
+export { PlannerRepository } from "./_planner-repository.js";
+export { DeletePlanValidationReasonCodes, DeletePlanValidationStatuses } from "./_planner-repository.js";
+export type { DeletePlan, DeletePlanBlockReasonCode, DeletePlanBlockedRoot, DeletePlanClosureManifest, DeletePlanProtectedRoot, DeletePlanRoot, DeletePlanRootDecision, DeletePlanSelectionMode, DeletePlanSelectionReason, DeletePlanValidationReasonCode, DeletePlanValidationStatus } from "./_planner-repository.js";

package/dist/db/planner/index.js

@@ -0,0 +1,2 @@
+export { PlannerRepository } from "./_planner-repository.js";
+export { DeletePlanValidationReasonCodes, DeletePlanValidationStatuses } from "./_planner-repository.js";

package/dist/execute/_http.d.ts

@@ -0,0 +1,7 @@
+import type { DeleteExecutionLogger, GitHubPackageFetch, GitHubPackageFetchResponse } from "./_types.js";
+export { buildHttpErrorMessage } from "../core/index.js";
+export declare function runWithRetry<T>(label: string, logger: DeleteExecutionLogger, run: () => Promise<T>): Promise<T>;
+export declare function isRetryableStatus(status: number): boolean;
+export declare function buildTransportErrorMessage(error: unknown, fallback: string): string;
+export declare function resolveFetch(fetchImpl?: GitHubPackageFetch): GitHubPackageFetch;
+export declare function resolveJsonHeaders(response: GitHubPackageFetchResponse): string | undefined;

package/dist/execute/_http.js

@@ -0,0 +1,48 @@
+import { executeRequestRetryCount, executeRequestRetryDelayMs } from "../config/index.js";
+export { buildHttpErrorMessage } from "../core/index.js";
+const _RETRYABLE_STATUS_CODES = new Set([429, 502, 503, 504]);
+export async function runWithRetry(label, logger, run) {
+    let attempt = 0;
+    for (;;) {
+        try {
+            return await run();
+        }
+        catch (error) {
+            attempt += 1;
+            if (attempt > executeRequestRetryCount || !_shouldRetryError(error)) {
+                throw error;
+            }
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.warn(`${label} failed on attempt ${attempt}/${executeRequestRetryCount + 1}; retrying in ${executeRequestRetryDelayMs}ms - ${errorMessage}`);
+            await sleep(executeRequestRetryDelayMs);
+        }
+    }
+}
+export function isRetryableStatus(status) {
+    return _RETRYABLE_STATUS_CODES.has(status);
+}
+export function buildTransportErrorMessage(error, fallback) {
+    const details = [fallback];
+    if (error instanceof Error && error.message) {
+        details.push(error.message);
+    }
+    else {
+        details.push(String(error));
+    }
+    return details.join(" - ");
+}
+export function resolveFetch(fetchImpl) {
+    return fetchImpl ?? fetch;
+}
+export function resolveJsonHeaders(response) {
+    return response.headers.get("content-type")?.split(";")[0];
+}
+function _shouldRetryError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return /fetch failed|status 429|status 502|status 503|status 504/.test(error.message);
+}
+function sleep(delayMs) {
+    return new Promise((resolve) => setTimeout(resolve, delayMs));
+}

package/dist/execute/_manifest-detach.d.ts

@@ -0,0 +1,4 @@
+export declare function buildDetachedManifestClone(rawManifestJson: string, mediaType: string, options: {
+    detachedTag: string;
+    sourceDigest: string;
+}): string;

package/dist/execute/_manifest-detach.js

@@ -0,0 +1,31 @@
+const _OCI_MEDIA_TYPES = new Set([
+    "application/vnd.oci.artifact.manifest.v1+json",
+    "application/vnd.oci.image.index.v1+json",
+    "application/vnd.oci.image.manifest.v1+json"
+]);
+const _DETACH_ANNOTATION_KEY = "io.github.ghcr-cleanup-manager.detached-tag";
+export function buildDetachedManifestClone(rawManifestJson, mediaType, options) {
+    const parsed = JSON.parse(rawManifestJson);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`manifest ${options.sourceDigest} is not a JSON object`);
+    }
+    const clone = structuredClone(parsed);
+    if (_OCI_MEDIA_TYPES.has(mediaType)) {
+        const annotations = _cloneAnnotations(clone.annotations);
+        annotations[_DETACH_ANNOTATION_KEY] = `${options.detachedTag} ${options.sourceDigest}`;
+        clone.annotations = annotations;
+    }
+    return `${JSON.stringify(clone, null, 2)}\n`;
+}
+function _cloneAnnotations(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {};
+    }
+    const annotations = {};
+    for (const [key, annotationValue] of Object.entries(value)) {
+        if (typeof annotationValue === "string") {
+            annotations[key] = annotationValue;
+        }
+    }
+    return annotations;
+}

package/dist/execute/_package-version-delete-client.d.ts

@@ -0,0 +1,4 @@
+import type { DeleteExecutionLogger, GitHubPackageFetch } from "./_types.js";
+export declare function deletePackageVersion(owner: string, packageName: string, versionId: number, token: string, logger: DeleteExecutionLogger, runtime?: {
+    fetchImpl?: GitHubPackageFetch;
+}): Promise<void>;

package/dist/execute/_package-version-delete-client.js

@@ -0,0 +1,34 @@
+import { githubApiBaseUrl, githubApiVersion } from "../config/index.js";
+import { getOwnerURIComponent } from "../core/index.js";
+import { buildHttpErrorMessage, buildTransportErrorMessage, isRetryableStatus, resolveFetch, runWithRetry } from "./_http.js";
+export async function deletePackageVersion(owner, packageName, versionId, token, logger, runtime) {
+    const fetchImpl = resolveFetch(runtime?.fetchImpl);
+    const ownerURIComponent = await getOwnerURIComponent(fetchImpl, owner, token, logger);
+    const url = new URL(`/${ownerURIComponent}/packages/container/${encodeURIComponent(packageName)}/versions/${versionId}`, githubApiBaseUrl).toString();
+    let response;
+    try {
+        response = await runWithRetry(`GitHub package delete request for version ${versionId}`, logger, async () => {
+            const deleteResponse = await fetchImpl(url, {
+                method: "DELETE",
+                headers: {
+                    Accept: "application/vnd.github+json",
+                    Authorization: `Bearer ${token}`,
+                    "User-Agent": "ghcr-cleanup-manager",
+                    "X-GitHub-Api-Version": githubApiVersion
+                }
+            });
+            if (!deleteResponse.ok && isRetryableStatus(deleteResponse.status)) {
+                throw new Error(await buildHttpErrorMessage(deleteResponse, `GitHub package delete request failed for version ${versionId}`));
+            }
+            return deleteResponse;
+        });
+    }
+    catch (error) {
+        throw new Error(buildTransportErrorMessage(error, `GitHub package delete request failed for version ${versionId}`), {
+            cause: error
+        });
+    }
+    if (!response.ok) {
+        throw new Error(await buildHttpErrorMessage(response, `GitHub package delete request failed for version ${versionId}`));
+    }
+}

package/dist/execute/_package-version-page-client.d.ts

@@ -0,0 +1,14 @@
+import type { DeleteExecutionLogger, GitHubPackageFetch } from "./_types.js";
+export interface GitHubPackageVersionPageItem {
+    id: number;
+    name?: string;
+    metadata?: {
+        container?: {
+            tags?: string[];
+        };
+    };
+}
+export declare function findPackageVersionByDigestAndTag(owner: string, packageName: string, digest: string, tag: string, token: string, logger: DeleteExecutionLogger, runtime?: {
+    fetchImpl?: GitHubPackageFetch;
+}): Promise<number>;
+export declare function loadPackageVersionPage(owner: string, packageName: string, page: number, token: string, logger: DeleteExecutionLogger, fetchImpl: GitHubPackageFetch): Promise<GitHubPackageVersionPageItem[]>;

package/dist/execute/_package-version-page-client.js

@@ -0,0 +1,64 @@
+import { githubApiBaseUrl, githubApiVersion } from "../config/index.js";
+import { getOwnerURIComponent } from "../core/index.js";
+import { buildHttpErrorMessage, buildTransportErrorMessage, isRetryableStatus, resolveFetch, runWithRetry } from "./_http.js";
+export async function findPackageVersionByDigestAndTag(owner, packageName, digest, tag, token, logger, runtime) {
+    const fetchImpl = resolveFetch(runtime?.fetchImpl);
+    for (let attempt = 1; attempt <= 5; attempt += 1) {
+        const versionId = await _findPackageVersionByDigestAndTagOnce(owner, packageName, digest, tag, token, logger, fetchImpl);
+        if (versionId !== undefined) {
+            return versionId;
+        }
+        if (attempt < 5) {
+            logger.warn(`Temporary package version for ${owner}/${packageName}:${tag} (${digest}) not visible yet; retrying lookup ${attempt}/5`);
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+    }
+    throw new Error(`could not find temporary package version for ${owner}/${packageName}:${tag} (${digest})`);
+}
+export async function loadPackageVersionPage(owner, packageName, page, token, logger, fetchImpl) {
+    const ownerURIComponent = await getOwnerURIComponent(fetchImpl, owner, token, logger);
+    const url = new URL(`/${ownerURIComponent}/packages/container/${encodeURIComponent(packageName)}/versions`, githubApiBaseUrl);
+    url.searchParams.set("per_page", "100");
+    url.searchParams.set("page", String(page));
+    let response;
+    try {
+        response = await runWithRetry(`GitHub Packages request for page ${page}`, logger, async () => {
+            const pageResponse = await fetchImpl(url.toString(), {
+                headers: {
+                    Accept: "application/vnd.github+json",
+                    Authorization: `Bearer ${token}`,
+                    "User-Agent": "ghcr-cleanup-manager",
+                    "X-GitHub-Api-Version": githubApiVersion
+                }
+            });
+            if (!pageResponse.ok && isRetryableStatus(pageResponse.status)) {
+                throw new Error(await buildHttpErrorMessage(pageResponse, `GitHub Packages request for page ${page} failed`));
+            }
+            return pageResponse;
+        });
+    }
+    catch (error) {
+        throw new Error(buildTransportErrorMessage(error, `GitHub Packages request for page ${page} failed`), {
+            cause: error
+        });
+    }
+    if (!response.ok) {
+        throw new Error(await buildHttpErrorMessage(response, `GitHub Packages request for page ${page} failed`));
+    }
+    return (await response.json());
+}
+async function _findPackageVersionByDigestAndTagOnce(owner, packageName, digest, tag, token, logger, fetchImpl) {
+    for (let page = 1;; page += 1) {
+        const items = await loadPackageVersionPage(owner, packageName, page, token, logger, fetchImpl);
+        if (items.length === 0) {
+            return undefined;
+        }
+        const match = items.find((item) => item.name === digest && item.metadata?.container?.tags?.includes(tag));
+        if (match) {
+            return match.id;
+        }
+        if (items.length < 100) {
+            return undefined;
+        }
+    }
+}

package/dist/execute/_package-version-tag-source-client.d.ts

@@ -0,0 +1,12 @@
+import type { DeleteExecutionLogger, GitHubPackageFetch } from "./_types.js";
+export interface GitHubPackageVersionTagSource {
+    tag: string;
+    sourceVersionId: number;
+    sourceDigest: string;
+}
+export declare function listPresentPackageVersionIds(owner: string, packageName: string, versionIds: number[], token: string, logger: DeleteExecutionLogger, runtime?: {
+    fetchImpl?: GitHubPackageFetch;
+}): Promise<number[]>;
+export declare function listPackageVersionTagSources(owner: string, packageName: string, tags: string[], token: string, logger: DeleteExecutionLogger, runtime?: {
+    fetchImpl?: GitHubPackageFetch;
+}): Promise<GitHubPackageVersionTagSource[]>;

package/dist/execute/_package-version-tag-source-client.js

@@ -0,0 +1,65 @@
+import { resolveFetch } from "./_http.js";
+import { loadPackageVersionPage } from "./_package-version-page-client.js";
+export async function listPresentPackageVersionIds(owner, packageName, versionIds, token, logger, runtime) {
+    const fetchImpl = resolveFetch(runtime?.fetchImpl);
+    const requestedVersionIds = [...new Set(versionIds)];
+    if (requestedVersionIds.length === 0) {
+        return [];
+    }
+    const requestedVersionIdSet = new Set(requestedVersionIds);
+    const matches = new Set();
+    for (let page = 1;; page += 1) {
+        const items = await loadPackageVersionPage(owner, packageName, page, token, logger, fetchImpl);
+        if (items.length === 0) {
+            break;
+        }
+        for (const item of items) {
+            if (!requestedVersionIdSet.has(item.id)) {
+                continue;
+            }
+            matches.add(item.id);
+        }
+        if (matches.size === requestedVersionIds.length || items.length < 100) {
+            break;
+        }
+    }
+    return requestedVersionIds.filter((versionId) => matches.has(versionId));
+}
+export async function listPackageVersionTagSources(owner, packageName, tags, token, logger, runtime) {
+    const fetchImpl = resolveFetch(runtime?.fetchImpl);
+    const requestedTags = [...new Set(tags)];
+    if (requestedTags.length === 0) {
+        return [];
+    }
+    const requestedTagSet = new Set(requestedTags);
+    const matches = new Map();
+    for (let page = 1;; page += 1) {
+        const items = await loadPackageVersionPage(owner, packageName, page, token, logger, fetchImpl);
+        if (items.length === 0) {
+            break;
+        }
+        for (const item of items) {
+            const itemTags = item.metadata?.container?.tags;
+            if (!Array.isArray(itemTags) || typeof item.name !== "string") {
+                continue;
+            }
+            for (const tag of itemTags) {
+                if (!requestedTagSet.has(tag) || matches.has(tag)) {
+                    continue;
+                }
+                matches.set(tag, {
+                    tag,
+                    sourceVersionId: item.id,
+                    sourceDigest: item.name
+                });
+            }
+        }
+        if (matches.size === requestedTags.length || items.length < 100) {
+            break;
+        }
+    }
+    return requestedTags.flatMap((tag) => {
+        const match = matches.get(tag);
+        return match ? [match] : [];
+    });
+}

package/dist/execute/_plan-executor.d.ts

@@ -0,0 +1,3 @@
+import { type DeletePlan } from "../db/index.js";
+import { type DeleteExecutionOptions, type DeleteExecutionSummary } from "./_types.js";
+export declare function executeDeletePlan(plan: DeletePlan, options: DeleteExecutionOptions): Promise<DeleteExecutionSummary>;