@lesliechan721/aw 0.1.0-beta.10 → 0.1.0-beta.11

package/dist/src/commands/catalog-store.js

@@ -4,12 +4,29 @@ import fs from 'fs-extra';
 import { CATALOG_STORE_DIRECTORY } from '../constants.js';
 import { withAwHomeMutationLock } from '../utils/aw-home-mutation-lock.js';
 import { createCatalogStoreKey, readCatalogStoreEntry } from '../utils/catalog-generation-store.js';
+import { catalogGenerationErrorCode } from '../utils/catalog-generation-error.js';
 import { readCatalogGenerationState } from '../utils/catalog-generation-state.js';
+import { readCatalogSourcesConfig } from '../utils/catalog-sources.js';
 import { resolveAwHome } from '../utils/state-paths.js';
 const FORMAL_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
 const TEMP_RETENTION_MS = 24 * 60 * 60 * 1000;
 const HEX_SEGMENT = /^[0-9a-f]{64}$/u;
 const TEMP_SEGMENT = /^\.(staging|replacement|quarantine)-[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.tmp$/u;
+const DELETE_CLAIM_SEGMENT = /^\.delete-[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.tmp$/u;
+const CATALOG_STORE_APPLICATION_ERROR_CODES = new Set([
+    'invalidArguments',
+    'catalogStoreInspectionFailed',
+    'catalogStoreDeleteFailed',
+]);
+export function catalogStoreErrorCode(error) {
+    const generationCode = catalogGenerationErrorCode(error);
+    if (generationCode !== 'catalogGenerationFailed')
+        return generationCode;
+    const explicitCode = error?.code;
+    return typeof explicitCode === 'string' && CATALOG_STORE_APPLICATION_ERROR_CODES.has(explicitCode)
+        ? explicitCode
+        : 'catalogStoreInspectionFailed';
+}
 function opaqueForeignKey(parent, name) {
     const digest = crypto.createHash('sha256').update(name).digest('hex').slice(0, 12);
     return `${parent === '' ? '' : `${parent}/`}<foreign-${digest}>`;
@@ -17,21 +34,29 @@ function opaqueForeignKey(parent, name) {
 async function inspectTree(root, nowMs) {
     let newestMtimeMs = Number.NEGATIVE_INFINITY;
     let bytes = 0;
+    let rootIdentity = null;
     const pending = [root];
     try {
         while (pending.length > 0) {
             const current = pending.pop();
             const stat = await fs.lstat(current);
+            if (current === root)
+                rootIdentity = {
+                    device: stat.dev,
+                    inode: stat.ino,
+                    mode: stat.mode,
+                    birthtimeMs: stat.birthtimeMs,
+                };
             newestMtimeMs = Math.max(newestMtimeMs, stat.mtimeMs);
             if (stat.isSymbolicLink()) {
-                return { ageMs: null, bytes: null, safe: false, reason: 'unsafeSymlink' };
+                return { ageMs: null, bytes: null, safe: false, reason: 'unsafeSymlink', rootIdentity };
             }
             if (stat.isFile()) {
                 bytes += stat.size;
                 continue;
             }
             if (!stat.isDirectory()) {
-                return { ageMs: null, bytes: null, safe: false, reason: 'unsafeNode' };
+                return { ageMs: null, bytes: null, safe: false, reason: 'unsafeNode', rootIdentity };
             }
             const children = await fs.readdir(current);
             for (const child of children)
@@ -41,10 +66,11 @@ async function inspectTree(root, nowMs) {
             ageMs: Math.max(0, nowMs - newestMtimeMs),
             bytes,
             safe: true,
+            rootIdentity,
         };
     }
     catch {
-        return { ageMs: null, bytes: null, safe: false, reason: 'unreadable' };
+        return { ageMs: null, bytes: null, safe: false, reason: 'unreadable', rootIdentity };
     }
 }
 async function readEntryIdentity(entryDir) {
@@ -65,24 +91,29 @@ function retainedEntry(options) {
         storeKey: options.storeKey,
         category: options.category,
         status: options.evidence.safe ? 'retained' : 'error',
+        generationReference: options.generationReference ?? 'none',
         ageMs: options.evidence.ageMs,
         reclaimableBytes: null,
         reason: options.evidence.reason ?? options.reason,
         absolutePath: options.absolutePath,
+        rootIdentity: options.evidence.rootIdentity,
     };
 }
 async function inspectFormalEntry(options) {
     const storeKey = `${options.identitySegment}/${options.digestSegment}`;
+    const generationReference = options.activeKeys.has(storeKey)
+        ? 'active'
+        : options.orphanKeys.has(storeKey) ? 'orphan' : 'none';
     if (!options.evidence.safe)
         return retainedEntry({
             storeKey, category: 'entry', absolutePath: options.entryDir,
-            evidence: options.evidence, reason: 'unsafeEntry',
+            evidence: options.evidence, reason: 'unsafeEntry', generationReference,
         });
     const identity = await readEntryIdentity(options.entryDir);
     if (!identity)
         return retainedEntry({
             storeKey, category: 'entry', absolutePath: options.entryDir,
-            evidence: options.evidence, reason: 'validationFailed',
+            evidence: options.evidence, reason: 'validationFailed', generationReference,
         });
     try {
         if (createCatalogStoreKey(identity.logicalIdentity, identity.snapshotDigest) !== storeKey) {
@@ -93,7 +124,7 @@ async function inspectFormalEntry(options) {
     catch {
         return retainedEntry({
             storeKey, category: 'entry', absolutePath: options.entryDir,
-            evidence: options.evidence, reason: 'validationFailed',
+            evidence: options.evidence, reason: 'validationFailed', generationReference,
         });
     }
     if (options.activeKeys.has(storeKey))
@@ -101,20 +132,24 @@ async function inspectFormalEntry(options) {
             storeKey,
             category: 'entry',
             status: 'active',
+            generationReference,
             ageMs: options.evidence.ageMs,
             reclaimableBytes: null,
             reason: 'active',
             absolutePath: options.entryDir,
+            rootIdentity: options.evidence.rootIdentity,
         };
     const reclaimable = options.evidence.ageMs !== null && options.evidence.ageMs > FORMAL_RETENTION_MS;
     return {
         storeKey,
         category: 'entry',
         status: reclaimable ? 'reclaimable' : 'retained',
+        generationReference,
         ageMs: options.evidence.ageMs,
         reclaimableBytes: reclaimable ? options.evidence.bytes : null,
         reason: reclaimable ? 'inactiveOlderThan30Days' : 'inactiveWithin30Days',
         absolutePath: options.entryDir,
+        rootIdentity: options.evidence.rootIdentity,
     };
 }
 async function inspectTempEntry(options) {
@@ -163,21 +198,104 @@ async function inspectTempEntry(options) {
         storeKey,
         category,
         status: 'reclaimable',
+        generationReference: 'none',
         ageMs: options.evidence.ageMs,
         reclaimableBytes: options.evidence.bytes,
         reason: 'temporaryOlderThan24Hours',
         absolutePath: options.entryDir,
+        rootIdentity: options.evidence.rootIdentity,
+    };
+}
+async function inspectDeleteClaim(options) {
+    const storeKey = `${options.identitySegment}/${options.name}`;
+    const rootStat = await fs.lstat(options.entryDir).catch(() => null);
+    if (!rootStat?.isDirectory() || rootStat.isSymbolicLink())
+        return retainedEntry({
+            storeKey, category: 'deleteClaim', absolutePath: options.entryDir,
+            evidence: { ...options.evidence, safe: false, reason: 'unsafeDeleteClaimRoot' },
+            reason: 'unsafeDeleteClaimRoot',
+        });
+    if (!options.evidence.safe)
+        return retainedEntry({
+            storeKey, category: 'deleteClaim', absolutePath: options.entryDir,
+            evidence: options.evidence, reason: 'unsafeDeleteClaim',
+        });
+    const reclaimable = options.evidence.ageMs !== null && options.evidence.ageMs > TEMP_RETENTION_MS;
+    return {
+        storeKey,
+        category: 'deleteClaim',
+        status: reclaimable ? 'reclaimable' : 'retained',
+        generationReference: 'none',
+        ageMs: options.evidence.ageMs,
+        reclaimableBytes: reclaimable ? options.evidence.bytes : null,
+        reason: reclaimable ? 'deleteClaimOlderThan24Hours' : 'deleteClaimWithin24Hours',
+        absolutePath: options.entryDir,
+        rootIdentity: options.evidence.rootIdentity,
     };
 }
-async function activeStoreKeys(env) {
-    const state = await readCatalogGenerationState(env);
-    return new Set(Object.values(state.sources)
-        .flatMap((source) => source.active
-        ? [createCatalogStoreKey(source.active.logicalIdentity, source.active.snapshotDigest)]
-        : []));
+async function generationReferenceKeys(env) {
+    const [config, state] = await Promise.all([
+        readCatalogSourcesConfig(env),
+        readCatalogGenerationState(env),
+    ]);
+    const configuredSourceIds = new Set(config.sources.map((source) => source.id));
+    const activeKeys = new Set();
+    const orphanKeys = new Set();
+    for (const [sourceId, source] of Object.entries(state.sources)) {
+        if (!source.active)
+            continue;
+        const storeKey = createCatalogStoreKey(source.active.logicalIdentity, source.active.snapshotDigest);
+        if (configuredSourceIds.has(sourceId))
+            activeKeys.add(storeKey);
+        else
+            orphanKeys.add(storeKey);
+    }
+    for (const storeKey of activeKeys)
+        orphanKeys.delete(storeKey);
+    return { activeKeys, orphanKeys };
+}
+async function reinspectCandidate(options) {
+    const identityDir = path.dirname(options.initial.absolutePath);
+    const storeRoot = path.dirname(identityDir);
+    const identitySegment = path.basename(identityDir);
+    const name = path.basename(options.initial.absolutePath);
+    const [storeRootStat, identityStat] = await Promise.all([
+        fs.lstat(storeRoot).catch(() => null),
+        fs.lstat(identityDir).catch(() => null),
+    ]);
+    if (!storeRootStat?.isDirectory() || storeRootStat.isSymbolicLink()
+        || !identityStat?.isDirectory() || identityStat.isSymbolicLink()
+        || !HEX_SEGMENT.test(identitySegment)) {
+        return failedReinspectionEntry(options.initial);
+    }
+    const evidence = await inspectTree(options.initial.absolutePath, options.nowMs);
+    if (options.initial.category === 'entry')
+        return inspectFormalEntry({
+            identitySegment,
+            digestSegment: name,
+            entryDir: options.initial.absolutePath,
+            activeKeys: options.references.activeKeys,
+            orphanKeys: options.references.orphanKeys,
+            evidence,
+            env: options.env,
+        });
+    if (options.initial.category === 'deleteClaim')
+        return inspectDeleteClaim({
+            identitySegment,
+            name,
+            entryDir: options.initial.absolutePath,
+            evidence,
+        });
+    return inspectTempEntry({
+        identitySegment,
+        name,
+        entryDir: options.initial.absolutePath,
+        evidence,
+        env: options.env,
+    });
 }
 async function inspectCatalogStore(options) {
-    const activeKeys = await activeStoreKeys(options.env);
+    const { activeKeys, orphanKeys } = await generationReferenceKeys(options.env);
     const storeRoot = path.join(resolveAwHome(options.env), CATALOG_STORE_DIRECTORY);
     const rootStat = await fs.lstat(storeRoot).catch((error) => {
         if (error.code === 'ENOENT')
@@ -189,18 +307,14 @@ async function inspectCatalogStore(options) {
     if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
         return [retainedEntry({
                 storeKey: '.', category: 'foreign', absolutePath: storeRoot,
-                evidence: { ageMs: null, bytes: null, safe: false, reason: 'unsafeStoreRoot' },
+                evidence: {
+                    ageMs: null, bytes: null, safe: false, reason: 'unsafeStoreRoot', rootIdentity: null,
+                },
                 reason: 'unsafeStoreRoot',
             })];
     }
     const entries = [];
-    const identityNames = await fs.readdir(storeRoot).then((names) => names.sort()).catch(() => null);
-    if (!identityNames)
-        return [retainedEntry({
-                storeKey: '.', category: 'foreign', absolutePath: storeRoot,
-                evidence: { ageMs: null, bytes: null, safe: false, reason: 'unreadableStoreRoot' },
-                reason: 'unreadableStoreRoot',
-            })];
+    const identityNames = await fs.readdir(storeRoot).then((names) => names.sort());
     for (const identityName of identityNames) {
         const identityDir = path.join(storeRoot, identityName);
         const identityStat = await fs.lstat(identityDir).catch(() => null);
@@ -216,7 +330,18 @@ async function inspectCatalogStore(options) {
         if (!childNames) {
             entries.push(retainedEntry({
                 storeKey: `${identityName}/<unreadable>`, category: 'foreign', absolutePath: identityDir,
-                evidence: { ageMs: null, bytes: null, safe: false, reason: 'unreadableIdentityDirectory' },
+                evidence: {
+                    ageMs: null,
+                    bytes: null,
+                    safe: false,
+                    reason: 'unreadableIdentityDirectory',
+                    rootIdentity: identityStat ? {
+                        device: identityStat.dev,
+                        inode: identityStat.ino,
+                        mode: identityStat.mode,
+                        birthtimeMs: identityStat.birthtimeMs,
+                    } : null,
+                },
                 reason: 'unreadableIdentityDirectory',
             }));
             continue;
@@ -230,6 +355,7 @@ async function inspectCatalogStore(options) {
                     digestSegment: childName,
                     entryDir,
                     activeKeys,
+                    orphanKeys,
                     evidence,
                     env: options.env,
                 }));
@@ -243,6 +369,14 @@ async function inspectCatalogStore(options) {
                     env: options.env,
                 }));
             }
+            else if (DELETE_CLAIM_SEGMENT.test(childName)) {
+                entries.push(await inspectDeleteClaim({
+                    identitySegment: identityName,
+                    name: childName,
+                    entryDir,
+                    evidence,
+                }));
+            }
             else {
                 entries.push(retainedEntry({
                     storeKey: opaqueForeignKey(identityName, childName), category: 'foreign', absolutePath: entryDir,
@@ -254,7 +388,7 @@ async function inspectCatalogStore(options) {
     return entries;
 }
 function publicEntries(entries) {
-    return entries.map(({ absolutePath: _absolutePath, ...entry }) => entry);
+    return entries.map(({ absolutePath: _absolutePath, rootIdentity: _rootIdentity, ...entry }) => entry);
 }
 function reclaimableTotal(entries) {
     if (entries.some((entry) => entry.status === 'error'))
@@ -264,61 +398,245 @@ function reclaimableTotal(entries) {
         return null;
     return reclaimable.reduce((sum, entry) => sum + entry.reclaimableBytes, 0);
 }
+function inspectionErrors(entries) {
+    return entries
+        .filter((entry) => entry.status === 'error')
+        .map((entry) => ({
+        storeKey: entry.storeKey,
+        code: 'catalogStoreInspectionFailed',
+        message: `Could not fully inspect Catalog store item ${entry.storeKey}: ${entry.reason}.`,
+    }));
+}
+function sameNodeIdentity(left, right) {
+    return left !== null
+        && right !== null
+        && left.device === right.device
+        && left.inode === right.inode
+        && left.mode === right.mode
+        && Object.is(left.birthtimeMs, right.birthtimeMs);
+}
+function sameDeletionEvidence(initial, current) {
+    return current.status === 'reclaimable'
+        && current.storeKey === initial.storeKey
+        && current.category === initial.category
+        && current.generationReference === initial.generationReference
+        && current.absolutePath === initial.absolutePath
+        && current.ageMs === initial.ageMs
+        && current.reclaimableBytes === initial.reclaimableBytes
+        && current.reason === initial.reason
+        && sameNodeIdentity(current.rootIdentity, initial.rootIdentity);
+}
+function staleInspectionEntry(initial, current) {
+    if (current?.status === 'active' || current?.status === 'error')
+        return current;
+    return {
+        ...(current ?? initial),
+        status: 'retained',
+        ageMs: current?.ageMs ?? null,
+        reclaimableBytes: null,
+        reason: 'staleBeforeDelete',
+        rootIdentity: current?.rootIdentity ?? null,
+    };
+}
+function failedReinspectionEntry(initial) {
+    return {
+        ...initial,
+        status: 'error',
+        ageMs: null,
+        reclaimableBytes: null,
+        reason: 'reinspectionFailed',
+    };
+}
+async function readNodeIdentity(target) {
+    const stat = await fs.lstat(target).catch(() => null);
+    if (!stat)
+        return null;
+    return {
+        device: stat.dev,
+        inode: stat.ino,
+        mode: stat.mode,
+        birthtimeMs: stat.birthtimeMs,
+    };
+}
+async function readDirectoryIdentity(target) {
+    const stat = await fs.lstat(target).catch(() => null);
+    if (!stat?.isDirectory() || stat.isSymbolicLink())
+        return null;
+    return {
+        device: stat.dev,
+        inode: stat.ino,
+        mode: stat.mode,
+        birthtimeMs: stat.birthtimeMs,
+    };
+}
+async function restoreStaleClaim(claimPath, originalPath) {
+    const originalExists = await fs.lstat(originalPath)
+        .then(() => true)
+        .catch(() => false);
+    if (originalExists)
+        return false;
+    return fs.rename(claimPath, originalPath)
+        .then(() => true)
+        .catch(() => false);
+}
+async function inspectDeleteClaimAfterFailure(options) {
+    const exists = await fs.lstat(options.claimPath)
+        .then(() => true)
+        .catch((error) => error.code === 'ENOENT' ? false : true);
+    if (!exists)
+        return null;
+    return inspectDeleteClaim({
+        identitySegment: path.basename(path.dirname(options.claimPath)),
+        name: path.basename(options.claimPath),
+        entryDir: options.claimPath,
+        evidence: await inspectTree(options.claimPath, options.nowMs),
+    });
+}
 export async function catalogStoreStatus(options = {}) {
     const entries = publicEntries(await inspectCatalogStore({
         env: options.env ?? process.env,
         nowMs: (options.now ?? new Date()).getTime(),
     }));
+    const errors = inspectionErrors(entries);
     return {
-        catalogStoreSchemaVersion: 1,
+        catalogStoreSchemaVersion: 2,
         command: 'catalog:store:status',
-        ok: true,
+        ok: errors.length === 0,
         entries,
         totals: {
             entries: entries.length,
             reclaimableEntries: entries.filter((entry) => entry.status === 'reclaimable').length,
             reclaimableBytes: reclaimableTotal(entries),
         },
+        errors,
     };
 }
 async function executePrune(options) {
     const inspected = await inspectCatalogStore({ env: options.env, nowMs: options.nowMs });
     const deleted = [];
-    const errors = [];
+    const deleteErrors = [];
     const retainedAfterError = new Set();
+    const retainedReasons = new Map();
     if (!options.dryRun) {
-        for (const entry of inspected.filter((candidate) => candidate.status === 'reclaimable')) {
+        const candidates = inspected
+            .map((entry, index) => ({ entry, index }))
+            .filter(({ entry }) => entry.status === 'reclaimable');
+        await options.runtime?.afterInitialInspection?.(publicEntries(inspected));
+        for (const { entry: initial, index } of candidates) {
+            let current;
+            try {
+                const references = await generationReferenceKeys(options.env);
+                current = await reinspectCandidate({
+                    initial,
+                    references,
+                    env: options.env,
+                    nowMs: options.nowMs,
+                });
+            }
+            catch {
+                inspected[index] = failedReinspectionEntry(initial);
+                retainedReasons.set(initial.storeKey, 'reinspectionFailed');
+                continue;
+            }
+            if (!current || !sameDeletionEvidence(initial, current)) {
+                inspected[index] = staleInspectionEntry(initial, current);
+                retainedReasons.set(initial.storeKey, current?.status === 'active'
+                    ? 'active'
+                    : current?.status === 'error' ? current.reason : 'staleBeforeDelete');
+                continue;
+            }
+            inspected[index] = current;
+            const parentPath = path.dirname(current.absolutePath);
+            const parentIdentity = await readDirectoryIdentity(parentPath);
+            if (!parentIdentity) {
+                inspected[index] = staleInspectionEntry(initial, current);
+                retainedReasons.set(initial.storeKey, 'staleBeforeDelete');
+                continue;
+            }
+            const claimPath = path.join(parentPath, `.delete-${crypto.randomUUID()}.tmp`);
             try {
-                await options.remove(entry.absolutePath);
-                deleted.push({ storeKey: entry.storeKey, bytes: entry.reclaimableBytes });
+                await fs.rename(current.absolutePath, claimPath);
             }
             catch {
-                const stillExists = await fs.lstat(entry.absolutePath)
-                    .then(() => true)
-                    .catch(() => false);
-                if (stillExists)
-                    retainedAfterError.add(entry.storeKey);
-                errors.push({
-                    storeKey: entry.storeKey,
+                inspected[index] = staleInspectionEntry(initial, current);
+                retainedReasons.set(initial.storeKey, 'staleBeforeDelete');
+                continue;
+            }
+            try {
+                const claimTime = new Date(options.nowMs);
+                if (options.runtime?.updateDeleteClaimTime) {
+                    await options.runtime.updateDeleteClaimTime(claimPath, claimTime);
+                }
+                else {
+                    await fs.utimes(claimPath, claimTime, claimTime);
+                }
+            }
+            catch {
+                const restored = await restoreStaleClaim(claimPath, current.absolutePath);
+                if (restored) {
+                    inspected[index] = staleInspectionEntry(initial, current);
+                    retainedReasons.set(initial.storeKey, 'staleBeforeDelete');
+                }
+                else {
+                    const failedClaim = await inspectDeleteClaimAfterFailure({
+                        claimPath,
+                        nowMs: options.nowMs,
+                    });
+                    inspected[index] = staleInspectionEntry(initial, failedClaim ?? undefined);
+                    retainedReasons.set(inspected[index].storeKey, 'staleBeforeDelete');
+                }
+                continue;
+            }
+            await options.runtime?.afterDeleteClaim?.({ storeKey: initial.storeKey, claimPath });
+            const [claimedIdentity, currentParentIdentity] = await Promise.all([
+                readNodeIdentity(claimPath),
+                readDirectoryIdentity(parentPath),
+            ]);
+            if (!sameNodeIdentity(current.rootIdentity, claimedIdentity)
+                || !sameNodeIdentity(parentIdentity, currentParentIdentity)) {
+                await restoreStaleClaim(claimPath, current.absolutePath);
+                inspected[index] = staleInspectionEntry(initial, current);
+                retainedReasons.set(initial.storeKey, 'staleBeforeDelete');
+                continue;
+            }
+            try {
+                await options.remove(claimPath);
+                deleted.push({ storeKey: initial.storeKey, bytes: current.reclaimableBytes });
+            }
+            catch {
+                const failedClaim = await inspectDeleteClaimAfterFailure({
+                    claimPath,
+                    nowMs: options.nowMs,
+                });
+                if (!failedClaim) {
+                    deleted.push({ storeKey: initial.storeKey, bytes: current.reclaimableBytes });
+                    continue;
+                }
+                inspected[index] = failedClaim;
+                retainedAfterError.add(failedClaim.storeKey);
+                deleteErrors.push({
+                    storeKey: failedClaim.storeKey,
                     code: 'catalogStoreDeleteFailed',
-                    message: `Could not safely complete deletion of Catalog store item ${entry.storeKey}. Retry prune.`,
+                    message: `Could not safely complete deletion of Catalog store item ${failedClaim.storeKey}. Retry prune.`,
                 });
             }
         }
     }
     const entries = publicEntries(inspected);
+    const errors = [...inspectionErrors(entries), ...deleteErrors];
     const deletedKeys = new Set(deleted.map((entry) => entry.storeKey));
     const retained = entries
         .filter((entry) => !deletedKeys.has(entry.storeKey)
-        && (options.dryRun || entry.status !== 'reclaimable' || retainedAfterError.has(entry.storeKey)))
+        && (options.dryRun
+            || entry.status !== 'reclaimable'
+            || retainedAfterError.has(entry.storeKey)
+            || retainedReasons.has(entry.storeKey)))
         .map((entry) => ({
         storeKey: entry.storeKey,
-        reason: errors.some((error) => error.storeKey === entry.storeKey)
-            ? 'deleteFailed'
-            : entry.reason,
+        reason: retainedReasons.get(entry.storeKey) ?? entry.reason,
     }));
     return {
-        catalogStoreSchemaVersion: 1,
+        catalogStoreSchemaVersion: 2,
         command: 'catalog:store:prune',
         ok: errors.length === 0,
         overallState: errors.length === 0 ? 'succeeded' : 'partial',
@@ -340,6 +658,7 @@ export async function catalogStorePrune(options = {}) {
         nowMs,
         dryRun,
         remove: options.remove ?? ((target) => fs.remove(target)),
+        runtime: options.runtime,
     });
     if (dryRun)
         return action();