@lesliechan721/aw 0.1.0-beta.8 → 0.1.0-beta.9

package/dist/src/utils/catalog-generation-service.js

@@ -1,620 +1,306 @@
-import { IMPLEMENTED_AW_CAPABILITIES } from '../commands/aw-capabilities.js';
-import { withAwHomeMutationLock, } from './aw-home-mutation-lock.js';
-import { CatalogGenerationError } from './catalog-generation-error.js';
-import { CatalogProviderCompatibilityError } from './catalog-public-error.js';
+import { CatalogGenerationError, catalogGenerationErrorCode } from './catalog-generation-error.js';
+import { readCatalogGenerationControlSnapshot } from './catalog-generation-control-snapshot.js';
+import { createCatalogStoreKey, publishCatalogStoreEntry, readCatalogSnapshotLogicalIdentity, readCatalogStoreEntry, } from './catalog-generation-store.js';
 import { readCatalogGenerationState, withCatalogGenerationStateTransaction, } from './catalog-generation-state.js';
-import { discardPreparedCatalogGeneration, listCatalogGenerationsForIdentity, prepareCatalogGeneration, publishPreparedCatalogGeneration, readCatalogGeneration, } from './catalog-generation-store.js';
-import { calculateCatalogSourceConfigFingerprint } from './catalog-source-identity.js';
+export { removeCatalogSourceGenerationState } from './catalog-generation-state.js';
+import { calculateCatalogSourceConfigFingerprint, calculateCatalogSourceIdentity, } from './catalog-source-identity.js';
 import { readCatalogSourcesConfigSnapshot } from './catalog-sources.js';
 import { catalogGitProviderInternal } from './git-catalog-provider.js';
-import { checkAwCapabilitySupport, compareStrictSemVer } from './manifest.js';
 import { catalogPathProviderInternal } from './path-catalog-provider.js';
-function defaultProviders() {
-    return {
+function now(runtime) {
+    return (runtime?.now?.() ?? new Date()).toISOString();
+}
+async function resolveProvider(options) {
+    const providers = options.runtime?.providers ?? {
         git: catalogGitProviderInternal.resolve,
         path: catalogPathProviderInternal.resolve,
     };
+    return providers[options.source.type](options.source, {
+        cliVersion: options.cliVersion,
+        env: options.env,
+        signal: options.signal,
+    });
 }
-async function resolveSourceForRefresh(options) {
-    const providers = options.providers ?? defaultProviders();
-    try {
-        return options.source.type === 'git'
-            ? await providers.git(options.source, {
-                cliVersion: options.cliVersion,
-                freshnessPolicy: 'forceRemote',
-                env: options.env,
-                signal: options.signal,
-            })
-            : await providers.path(options.source, {
-                cliVersion: options.cliVersion,
-                freshnessPolicy: 'forceRemote',
-                env: options.env,
-                signal: options.signal,
-            });
-    }
-    catch (error) {
-        if (error instanceof CatalogGenerationError)
-            throw error;
-        throw new CatalogGenerationError({
-            code: 'catalogGenerationRefreshFailed',
-            sourceId: options.source.id,
-            message: `Cannot refresh Catalog source "${options.source.id}". The previous Active generation is unchanged.`,
-            cause: error,
-        });
-    }
-}
-function pointerFromGeneration(options) {
+function evidence(resolution, logicalIdentity) {
     return {
-        sourceConfigFingerprint: options.sourceConfigFingerprint,
-        catalogVersion: options.generation.metadata.catalogVersion,
-        channel: options.generation.metadata.channel,
-        requestedRef: options.resolution.requestedRef,
-        resolvedCommit: options.resolution.resolvedCommit,
-        manifestDigest: options.generation.metadata.manifestDigest,
-        snapshotDigest: options.generation.metadata.snapshotDigest,
-        generationKey: options.generation.metadata.generationKey,
-        ...(options.activatedAt ? { activatedAt: options.activatedAt } : {}),
+        sourceIdentity: resolution.sourceIdentity,
+        logicalIdentity,
+        catalogVersion: resolution.manifest.catalogVersion,
+        channel: resolution.manifest.channel,
+        requestedRef: resolution.requestedRef,
+        resolvedCommit: resolution.resolvedCommit,
+        manifestDigest: resolution.manifestDigest,
+        snapshotDigest: resolution.snapshotDigest,
     };
 }
-function candidateFromGeneration(options) {
-    return {
-        ...pointerFromGeneration(options),
-        candidateKind: options.candidateKind,
-        downloadedAt: options.downloadedAt,
-    };
+function sameActive(active, next) {
+    return Boolean(active)
+        && active.sourceConfigFingerprint === next.sourceConfigFingerprint
+        && active.sourceIdentity === next.sourceIdentity
+        && active.requestedRef === next.requestedRef
+        && active.resolvedCommit === next.resolvedCommit
+        && active.logicalIdentity === next.logicalIdentity
+        && active.manifestDigest === next.manifestDigest
+        && active.snapshotDigest === next.snapshotDigest;
 }
-function checked(options) {
-    return {
-        checkedAt: options.checkedAt,
-        state: options.state,
-        remoteCommit: options.resolution.resolvedCommit,
-        ...(options.errorCode ? { errorCode: options.errorCode } : {}),
-    };
+async function assertCurrentSource(options) {
+    const current = await readCatalogSourcesConfigSnapshot(options.env);
+    const source = current.config.sources.find((entry) => entry.id === options.sourceId);
+    if (!source)
+        throw new CatalogGenerationError({
+            code: 'catalogGenerationSourceMissing',
+            sourceId: options.sourceId,
+            message: `Catalog source "${options.sourceId}" was removed during sync.`,
+        });
+    if (calculateCatalogSourceConfigFingerprint(source) !== options.fingerprint) {
+        throw new CatalogGenerationError({
+            code: 'catalogGenerationIdentityMismatch',
+            sourceId: options.sourceId,
+            message: `Catalog source "${options.sourceId}" changed during sync. Run sync again.`,
+        });
+    }
 }
-async function recordRefreshFailure(options) {
-    await withAwHomeMutationLock({
-        env: options.env,
-        token: options.awHomeMutationToken,
-        action: async () => {
-            const config = await readCatalogSourcesConfigSnapshot(options.env);
-            const configured = config.config.sources.find((source) => source.id === options.sourceId);
-            if (!configured
-                || calculateCatalogSourceConfigFingerprint(configured) !== options.sourceConfigFingerprint)
-                return;
-            await withCatalogGenerationStateTransaction({
-                env: options.env,
-                action: async (current) => {
-                    const source = current.sources[options.sourceId];
-                    if (!source)
-                        return { state: current, result: undefined };
-                    return {
-                        state: {
-                            ...current,
-                            sources: {
-                                ...current.sources,
-                                [options.sourceId]: {
-                                    ...source,
-                                    lastCheck: {
-                                        checkedAt: options.checkedAt,
-                                        state: 'failed',
-                                        errorCode: options.errorCode,
-                                    },
-                                },
-                            },
+async function recordFailure(options) {
+    try {
+        await assertCurrentSource(options);
+        const lastSync = {
+            syncedAt: now(options.runtime),
+            mode: options.mode,
+            state: 'failed',
+            errorCode: options.errorCode,
+        };
+        await withCatalogGenerationStateTransaction({
+            env: options.env,
+            beforeReplace: () => assertCurrentSource(options),
+            action: async (current) => ({
+                state: {
+                    schemaVersion: 1,
+                    sources: {
+                        ...current.sources,
+                        [options.sourceId]: {
+                            ...current.sources[options.sourceId],
+                            lastSync,
                         },
-                        result: undefined,
-                    };
+                    },
                 },
-            });
-        },
-    });
+                result: undefined,
+            }),
+        });
+    }
+    catch {
+        // A concurrent source update or removal must not be undone by failure diagnostics.
+    }
 }
-function sameGeneration(pointer, generation, sourceConfigFingerprint) {
-    return pointer?.sourceConfigFingerprint === sourceConfigFingerprint
-        && pointer.catalogVersion === generation.metadata.catalogVersion
-        && pointer.snapshotDigest === generation.metadata.snapshotDigest;
+function warnCleanupFailure(sourceId) {
+    try {
+        process.emitWarning(`Catalog provider staging cleanup failed for source "${sourceId}".`, { code: 'AW_CATALOG_PROVIDER_CLEANUP_FAILED' });
+    }
+    catch {
+        // Cleanup diagnostics cannot replace the sync result.
+    }
 }
-export async function refreshCatalogSourceGeneration(options) {
+export async function syncCatalogSourceGeneration(options) {
     const env = options.env ?? process.env;
-    const config = await readCatalogSourcesConfigSnapshot(env);
-    const source = config.config.sources.find((entry) => entry.id === options.sourceId);
-    if (!source) {
+    const mode = options.check ? 'check' : 'sync';
+    const control = await readCatalogGenerationControlSnapshot({ env });
+    const source = control.configSnapshot.config.sources.find((entry) => entry.id === options.sourceId);
+    if (!source)
         throw new CatalogGenerationError({
             code: 'catalogGenerationSourceMissing',
             sourceId: options.sourceId,
             message: `Catalog source "${options.sourceId}" is not configured.`,
         });
-    }
-    const sourceConfigFingerprint = calculateCatalogSourceConfigFingerprint(source);
-    const checkedAt = (options.runtime?.now?.() ?? new Date()).toISOString();
+    const fingerprint = calculateCatalogSourceConfigFingerprint(source);
     let resolution;
     try {
-        await options.runtime?.onProgress?.({ sourceId: source.id, state: 'checking' });
-        options.signal?.throwIfAborted();
-        resolution = await resolveSourceForRefresh({
+        resolution = await resolveProvider({
             source,
             cliVersion: options.cliVersion,
             env,
             signal: options.signal,
-            providers: options.runtime?.providers,
-        });
-    }
-    catch (error) {
-        options.signal?.throwIfAborted();
-        await recordRefreshFailure({
-            sourceId: source.id,
-            sourceConfigFingerprint,
-            env,
-            checkedAt,
-            errorCode: error instanceof CatalogGenerationError
-                ? error.code
-                : 'catalogGenerationRefreshFailed',
-            ...(options.awHomeMutationToken
-                ? { awHomeMutationToken: options.awHomeMutationToken }
-                : {}),
+            runtime: options.runtime,
         });
-        throw error;
-    }
-    let prepared;
-    try {
-        await options.runtime?.onProgress?.({ sourceId: source.id, state: 'validating' });
-        options.signal?.throwIfAborted();
-        prepared = await prepareCatalogGeneration({
-            resolution,
-            cliVersion: options.cliVersion,
+        const expectedIdentity = await calculateCatalogSourceIdentity(source);
+        if (resolution.sourceId !== source.id || resolution.sourceIdentity !== expectedIdentity) {
+            throw new CatalogGenerationError({
+                code: 'catalogGenerationIdentityMismatch',
+                sourceId: source.id,
+                message: `Catalog provider returned mismatched identity for source "${source.id}".`,
+            });
+        }
+        const logicalIdentity = await readCatalogSnapshotLogicalIdentity(resolution.rootDir);
+        const syncEvidence = evidence(resolution, logicalIdentity);
+        if (options.check) {
+            await assertCurrentSource({ sourceId: source.id, fingerprint, env });
+            const lastSync = {
+                syncedAt: now(options.runtime),
+                mode,
+                state: 'succeeded',
+                resolvedCommit: resolution.resolvedCommit,
+            };
+            await withCatalogGenerationStateTransaction({
+                env,
+                beforeReplace: () => assertCurrentSource({ sourceId: source.id, fingerprint, env }),
+                action: async (current) => ({
+                    state: {
+                        schemaVersion: 1,
+                        sources: {
+                            ...current.sources,
+                            [source.id]: { ...current.sources[source.id], lastSync },
+                        },
+                    },
+                    result: undefined,
+                }),
+            });
+            return {
+                catalogGenerationSchemaVersion: 1,
+                sourceId: source.id,
+                mode,
+                outcome: 'checked',
+                activeChanged: false,
+                resolution: syncEvidence,
+                ...(control.generationState.sources[source.id]?.active
+                    ? { active: control.generationState.sources[source.id].active }
+                    : {}),
+                lastSync,
+            };
+        }
+        const store = await publishCatalogStoreEntry({ resolution, env, signal: options.signal });
+        const activeInput = {
+            sourceConfigFingerprint: fingerprint,
+            sourceIdentity: resolution.sourceIdentity,
+            requestedRef: resolution.requestedRef,
+            resolvedCommit: resolution.resolvedCommit,
+            logicalIdentity: store.metadata.logicalIdentity,
+            manifestDigest: store.metadata.manifestDigest,
+            snapshotDigest: store.metadata.snapshotDigest,
+        };
+        await assertCurrentSource({ sourceId: source.id, fingerprint, env });
+        const syncedAt = now(options.runtime);
+        return await withCatalogGenerationStateTransaction({
             env,
-            now: options.runtime?.now,
-            signal: options.signal,
+            beforeReplace: () => assertCurrentSource({ sourceId: source.id, fingerprint, env }),
+            action: async (current) => {
+                const previous = current.sources[source.id]?.active;
+                const unchanged = sameActive(previous, activeInput);
+                const active = unchanged
+                    ? previous
+                    : { ...activeInput, activatedAt: syncedAt };
+                const lastSync = {
+                    syncedAt,
+                    mode,
+                    state: 'succeeded',
+                    resolvedCommit: resolution.resolvedCommit,
+                };
+                return {
+                    state: {
+                        schemaVersion: 1,
+                        sources: { ...current.sources, [source.id]: { active, lastSync } },
+                    },
+                    result: {
+                        catalogGenerationSchemaVersion: 1,
+                        sourceId: source.id,
+                        mode,
+                        outcome: unchanged ? 'unchanged' : 'activated',
+                        activeChanged: !unchanged,
+                        resolution: syncEvidence,
+                        active,
+                        lastSync,
+                    },
+                };
+            },
         });
     }
     catch (error) {
-        options.signal?.throwIfAborted();
-        await recordRefreshFailure({
+        const code = error instanceof CatalogGenerationError
+            ? error.code
+            : 'catalogGenerationRefreshFailed';
+        await recordFailure({
             sourceId: source.id,
-            sourceConfigFingerprint,
-            env,
-            checkedAt,
-            errorCode: error instanceof CatalogGenerationError
-                ? error.code
-                : 'catalogGenerationPublishFailed',
-            ...(options.awHomeMutationToken
-                ? { awHomeMutationToken: options.awHomeMutationToken }
-                : {}),
-        });
-        throw error;
-    }
-    try {
-        options.signal?.throwIfAborted();
-        const transaction = await withAwHomeMutationLock({
+            fingerprint,
+            mode,
+            errorCode: code,
             env,
-            signal: options.signal,
-            token: options.awHomeMutationToken,
-            action: async () => {
-                options.signal?.throwIfAborted();
-                const currentConfig = await readCatalogSourcesConfigSnapshot(env);
-                const currentConfiguredSource = currentConfig.config.sources
-                    .find((entry) => entry.id === source.id);
-                if (!currentConfiguredSource) {
-                    throw new CatalogGenerationError({
-                        code: 'catalogGenerationSourceMissing',
-                        sourceId: source.id,
-                        message: `Catalog source "${source.id}" was removed while refresh was in progress. The prepared generation was discarded.`,
-                    });
-                }
-                if (calculateCatalogSourceConfigFingerprint(currentConfiguredSource)
-                    !== sourceConfigFingerprint) {
-                    throw new CatalogGenerationError({
-                        code: 'catalogGenerationIdentityMismatch',
-                        sourceId: source.id,
-                        message: `Catalog source "${source.id}" changed while refresh was in progress. The prepared generation was discarded.`,
-                    });
-                }
-                return withCatalogGenerationStateTransaction({
-                    env,
-                    beforeReplace: () => options.signal?.throwIfAborted(),
-                    action: async (current) => {
-                        options.signal?.throwIfAborted();
-                        const previous = current.sources[source.id];
-                        if (source.type === 'git'
-                            && previous?.active
-                            && previous.logicalIdentity !== prepared.metadata.logicalIdentity) {
-                            return {
-                                state: current,
-                                result: {
-                                    error: new CatalogGenerationError({
-                                        code: 'catalogGenerationIdentityMismatch',
-                                        sourceId: source.id,
-                                        message: `Catalog source "${source.id}" returned a different workspace identity. Active and Candidate are unchanged; update the source configuration explicitly before adopting another Catalog identity.`,
-                                    }),
-                                },
-                            };
-                        }
-                        const currentSource = previous?.logicalIdentity === prepared.metadata.logicalIdentity
-                            ? previous
-                            : undefined;
-                        const refreshPolicy = currentSource?.refreshPolicy
-                            ?? (source.type === 'path' ? 'manual' : 'startup');
-                        if (source.type === 'git') {
-                            const generations = await listCatalogGenerationsForIdentity({
-                                logicalIdentity: prepared.metadata.logicalIdentity,
-                                env,
-                            });
-                            const violation = generations.find((generation) => generation.metadata.catalogVersion === prepared.metadata.catalogVersion
-                                && generation.metadata.snapshotDigest !== prepared.metadata.snapshotDigest);
-                            if (violation) {
-                                const lastCheck = checked({
-                                    checkedAt,
-                                    state: 'immutableViolation',
-                                    resolution,
-                                    errorCode: 'catalogImmutableVersionViolation',
-                                });
-                                const nextSource = currentSource
-                                    ? { ...currentSource, lastCheck }
-                                    : {
-                                        logicalIdentity: prepared.metadata.logicalIdentity,
-                                        refreshPolicy,
-                                        lastCheck,
-                                    };
-                                return {
-                                    state: {
-                                        ...current,
-                                        sources: { ...current.sources, [source.id]: nextSource },
-                                    },
-                                    result: {
-                                        error: new CatalogGenerationError({
-                                            code: 'catalogImmutableVersionViolation',
-                                            sourceId: source.id,
-                                            message: `Catalog source "${source.id}" reused version ${prepared.metadata.catalogVersion} with different content. Active and Candidate are unchanged; publish a higher Catalog version and refresh again.`,
-                                        }),
-                                    },
-                                };
-                            }
-                        }
-                        options.signal?.throwIfAborted();
-                        const published = await publishPreparedCatalogGeneration(prepared);
-                        options.signal?.throwIfAborted();
-                        if (source.type === 'path' || !currentSource?.active) {
-                            const active = pointerFromGeneration({
-                                generation: published,
-                                resolution,
-                                sourceConfigFingerprint,
-                                activatedAt: checkedAt,
-                            });
-                            const lastCheck = checked({ checkedAt, state: 'activeReady', resolution });
-                            const nextSource = {
-                                logicalIdentity: published.metadata.logicalIdentity,
-                                refreshPolicy,
-                                active,
-                                lastCheck,
-                            };
-                            return {
-                                state: {
-                                    ...current,
-                                    sources: { ...current.sources, [source.id]: nextSource },
-                                },
-                                result: {
-                                    value: {
-                                        catalogGenerationSchemaVersion: 1,
-                                        sourceId: source.id,
-                                        sourceIdentity: resolution.sourceIdentity,
-                                        logicalIdentity: published.metadata.logicalIdentity,
-                                        outcome: 'activeReady',
-                                        active,
-                                        lastCheck,
-                                    },
-                                },
-                            };
-                        }
-                        if (sameGeneration(currentSource.active, published, sourceConfigFingerprint)) {
-                            const lastCheck = checked({ checkedAt, state: 'upToDate', resolution });
-                            return {
-                                state: {
-                                    ...current,
-                                    sources: {
-                                        ...current.sources,
-                                        [source.id]: { ...currentSource, lastCheck },
-                                    },
-                                },
-                                result: {
-                                    value: {
-                                        catalogGenerationSchemaVersion: 1,
-                                        sourceId: source.id,
-                                        sourceIdentity: resolution.sourceIdentity,
-                                        logicalIdentity: published.metadata.logicalIdentity,
-                                        outcome: 'upToDate',
-                                        active: currentSource.active,
-                                        ...(currentSource.candidate ? { candidate: currentSource.candidate } : {}),
-                                        lastCheck,
-                                    },
-                                },
-                            };
-                        }
-                        const comparison = compareStrictSemVer(published.metadata.catalogVersion, currentSource.active.catalogVersion);
-                        const explicitRefChange = source.refPolicy.type === 'explicit'
-                            && currentSource.active.requestedRef !== resolution.requestedRef;
-                        if (comparison < 0 && !explicitRefChange) {
-                            const lastCheck = checked({ checkedAt, state: 'channelRollback', resolution });
-                            return {
-                                state: {
-                                    ...current,
-                                    sources: {
-                                        ...current.sources,
-                                        [source.id]: { ...currentSource, lastCheck },
-                                    },
-                                },
-                                result: {
-                                    value: {
-                                        catalogGenerationSchemaVersion: 1,
-                                        sourceId: source.id,
-                                        sourceIdentity: resolution.sourceIdentity,
-                                        logicalIdentity: published.metadata.logicalIdentity,
-                                        outcome: 'channelRollback',
-                                        active: currentSource.active,
-                                        ...(currentSource.candidate ? { candidate: currentSource.candidate } : {}),
-                                        lastCheck,
-                                    },
-                                },
-                            };
-                        }
-                        const candidateKind = explicitRefChange
-                            ? 'refChange'
-                            : 'upgrade';
-                        const candidate = sameGeneration(currentSource.candidate, published, sourceConfigFingerprint)
-                            ? currentSource.candidate
-                            : candidateFromGeneration({
-                                generation: published,
-                                resolution,
-                                sourceConfigFingerprint,
-                                candidateKind,
-                                downloadedAt: checkedAt,
-                            });
-                        const lastCheck = checked({ checkedAt, state: 'candidateReady', resolution });
-                        return {
-                            state: {
-                                ...current,
-                                sources: {
-                                    ...current.sources,
-                                    [source.id]: { ...currentSource, candidate, lastCheck },
-                                },
-                            },
-                            result: {
-                                value: {
-                                    catalogGenerationSchemaVersion: 1,
-                                    sourceId: source.id,
-                                    sourceIdentity: resolution.sourceIdentity,
-                                    logicalIdentity: published.metadata.logicalIdentity,
-                                    outcome: 'candidateReady',
-                                    active: currentSource.active,
-                                    candidate,
-                                    lastCheck,
-                                },
-                            },
-                        };
-                    },
-                });
-            },
+            runtime: options.runtime,
         });
-        if ('error' in transaction)
-            throw transaction.error;
-        return transaction.value;
-    }
-    finally {
-        await discardPreparedCatalogGeneration(prepared);
-    }
-}
-async function assertPointerMatchesGeneration(options) {
-    if (options.sourceConfigFingerprint !== undefined
-        && options.pointer.sourceConfigFingerprint !== options.sourceConfigFingerprint) {
+        if (error instanceof CatalogGenerationError)
+            throw error;
         throw new CatalogGenerationError({
-            code: 'catalogGenerationIdentityMismatch',
-            message: 'Catalog generation pointer does not match the current source configuration. Refresh the configured source.',
+            code: 'catalogGenerationRefreshFailed',
+            sourceId: source.id,
+            message: `Cannot sync Catalog source "${source.id}". The previous Active snapshot is unchanged.`,
+            cause: error,
         });
     }
-    const generation = await readCatalogGeneration({
-        logicalIdentity: options.logicalIdentity,
-        snapshotDigest: options.pointer.snapshotDigest,
-        env: options.env,
-    });
-    if (generation.metadata.catalogVersion !== options.pointer.catalogVersion
-        || generation.metadata.channel !== options.pointer.channel
-        || generation.metadata.manifestDigest !== options.pointer.manifestDigest
-        || generation.metadata.generationKey !== options.pointer.generationKey) {
-        throw new CatalogGenerationError({
-            code: 'catalogGenerationIdentityMismatch',
-            message: 'Catalog generation pointer does not match immutable generation metadata. Refresh the source after repairing catalog-generations.json.',
-        });
+    finally {
+        if (resolution)
+            await resolution.cleanup().catch(() => warnCleanupFailure(source.id));
     }
-    return generation;
-}
-export async function activateCatalogSourceCandidate(options) {
-    const env = options.env ?? process.env;
-    return withAwHomeMutationLock({
-        env,
-        token: options.awHomeMutationToken,
-        action: async () => {
-            const config = await readCatalogSourcesConfigSnapshot(env);
-            const configuredSource = config.config.sources
-                .find((source) => source.id === options.sourceId);
-            if (!configuredSource) {
-                throw new CatalogGenerationError({
-                    code: 'catalogGenerationSourceMissing',
-                    sourceId: options.sourceId,
-                    message: `Catalog source "${options.sourceId}" is not configured.`,
-                });
-            }
-            return withCatalogGenerationStateTransaction({
-                env,
-                action: async (current) => {
-                    const source = current.sources[options.sourceId];
-                    if (!source?.candidate) {
-                        throw new CatalogGenerationError({
-                            code: 'catalogGenerationCandidateUnavailable',
-                            sourceId: options.sourceId,
-                            message: `Catalog source "${options.sourceId}" has no Candidate generation to activate.`,
-                        });
-                    }
-                    if (options.expectedCandidateGenerationKey
-                        && source.candidate.generationKey !== options.expectedCandidateGenerationKey) {
-                        throw new CatalogGenerationError({
-                            code: 'catalogGenerationCandidateChanged',
-                            sourceId: options.sourceId,
-                            message: `Catalog source "${options.sourceId}" Candidate changed after Review. Review the new Candidate before activation.`,
-                        });
-                    }
-                    const candidateGeneration = await assertPointerMatchesGeneration({
-                        logicalIdentity: source.logicalIdentity,
-                        pointer: source.candidate,
-                        sourceConfigFingerprint: calculateCatalogSourceConfigFingerprint(configuredSource),
-                        env,
-                    });
-                    const requiredCapabilities = candidateGeneration.metadata.requiredAwCapabilities;
-                    const support = checkAwCapabilitySupport(requiredCapabilities, IMPLEMENTED_AW_CAPABILITIES);
-                    if (!support.supported) {
-                        throw new CatalogProviderCompatibilityError({
-                            sourceId: options.sourceId,
-                            requiredCapabilities,
-                            missingCapabilities: support.missing,
-                            availableCapabilities: IMPLEMENTED_AW_CAPABILITIES,
-                        });
-                    }
-                    const active = {
-                        sourceConfigFingerprint: source.candidate.sourceConfigFingerprint,
-                        catalogVersion: source.candidate.catalogVersion,
-                        channel: source.candidate.channel,
-                        requestedRef: source.candidate.requestedRef,
-                        resolvedCommit: source.candidate.resolvedCommit,
-                        manifestDigest: source.candidate.manifestDigest,
-                        snapshotDigest: source.candidate.snapshotDigest,
-                        generationKey: source.candidate.generationKey,
-                        activatedAt: (options.runtime?.now?.() ?? new Date()).toISOString(),
-                    };
-                    const nextSource = {
-                        ...source,
-                        active,
-                    };
-                    delete nextSource.candidate;
-                    return {
-                        state: {
-                            ...current,
-                            sources: { ...current.sources, [options.sourceId]: nextSource },
-                        },
-                        result: {
-                            catalogGenerationSchemaVersion: 1,
-                            sourceId: options.sourceId,
-                            logicalIdentity: source.logicalIdentity,
-                            outcome: 'activated',
-                            active,
-                        },
-                    };
-                },
-            });
-        },
-    });
-}
-export async function setCatalogSourceRefreshPolicy(options) {
-    const env = options.env ?? process.env;
-    return withAwHomeMutationLock({
-        env,
-        action: async () => {
-            const config = await readCatalogSourcesConfigSnapshot(env);
-            const configuredSource = config.config.sources.find((source) => source.id === options.sourceId);
-            if (!configuredSource) {
-                throw new CatalogGenerationError({
-                    code: 'catalogGenerationSourceMissing',
-                    sourceId: options.sourceId,
-                    message: `Catalog source "${options.sourceId}" is not configured.`,
-                });
-            }
-            if (configuredSource.type === 'path' && options.refreshPolicy !== 'manual') {
-                throw new CatalogGenerationError({
-                    code: 'catalogGenerationRefreshPolicyInvalid',
-                    sourceId: options.sourceId,
-                    message: `Path Catalog source "${options.sourceId}" only supports manual refresh.`,
-                });
-            }
-            await withCatalogGenerationStateTransaction({
-                env,
-                action: async (current) => {
-                    const source = current.sources[options.sourceId];
-                    if (!source) {
-                        throw new CatalogGenerationError({
-                            code: 'catalogGenerationUnavailable',
-                            sourceId: options.sourceId,
-                            message: `Catalog source "${options.sourceId}" has no generation state. Refresh it before changing refresh policy.`,
-                        });
-                    }
-                    return {
-                        state: {
-                            ...current,
-                            sources: {
-                                ...current.sources,
-                                [options.sourceId]: { ...source, refreshPolicy: options.refreshPolicy },
-                            },
-                        },
-                        result: undefined,
-                    };
-                },
-            });
-            return (await readCatalogGenerationStatus({ sourceId: options.sourceId, env })).sources[0];
-        },
-    });
-}
-export async function removeCatalogSourceGenerationState(options) {
-    return withCatalogGenerationStateTransaction({
-        env: options.env,
-        action: async (current) => {
-            if (!current.sources[options.sourceId])
-                return { state: current, result: false };
-            const sources = { ...current.sources };
-            delete sources[options.sourceId];
-            return { state: { ...current, sources }, result: true };
-        },
-    });
 }
 export async function readCatalogGenerationStatus(options = {}) {
     const env = options.env ?? process.env;
-    const [config, state] = await Promise.all([
-        readCatalogSourcesConfigSnapshot(env),
-        readCatalogGenerationState(env),
-    ]);
-    const sources = config.config.sources
-        .filter((source) => options.sourceId === undefined || source.id === options.sourceId)
-        .sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0);
-    if (options.sourceId && sources.length === 0) {
+    const config = await readCatalogSourcesConfigSnapshot(env);
+    const state = await readCatalogGenerationState(env);
+    const selected = options.sourceId
+        ? config.config.sources.filter((source) => source.id === options.sourceId)
+        : config.config.sources;
+    if (options.sourceId && selected.length === 0)
         throw new CatalogGenerationError({
             code: 'catalogGenerationSourceMissing',
             sourceId: options.sourceId,
             message: `Catalog source "${options.sourceId}" is not configured.`,
         });
-    }
-    const entries = [];
-    for (const source of sources) {
-        const selected = state.sources[source.id];
-        const sourceConfigFingerprint = calculateCatalogSourceConfigFingerprint(source);
-        if (selected?.active)
-            await assertPointerMatchesGeneration({
-                logicalIdentity: selected.logicalIdentity,
-                pointer: selected.active,
-                ...(selected.candidate ? {} : { sourceConfigFingerprint }),
+    const sources = await Promise.all(selected.map(async (source) => {
+        const configuredSourceIdentity = await calculateCatalogSourceIdentity(source);
+        const sourceState = state.sources[source.id];
+        const active = sourceState?.active;
+        const configMatchesActive = Boolean(active)
+            && active.sourceIdentity === configuredSourceIdentity
+            && active.sourceConfigFingerprint === calculateCatalogSourceConfigFingerprint(source);
+        if (!active)
+            return {
+                sourceId: source.id,
+                configuredSourceIdentity,
+                activeReady: false,
+                configMatchesActive: false,
+                lastSync: sourceState?.lastSync,
+            };
+        try {
+            const entry = await readCatalogStoreEntry({
+                logicalIdentity: active.logicalIdentity,
+                snapshotDigest: active.snapshotDigest,
                 env,
             });
-        if (selected?.candidate)
-            await assertPointerMatchesGeneration({
-                logicalIdentity: selected.logicalIdentity,
-                pointer: selected.candidate,
-                sourceConfigFingerprint,
-                env,
-            });
-        entries.push({
-            sourceId: source.id,
-            sourceType: source.type,
-            refreshPolicy: selected?.refreshPolicy ?? (source.type === 'path' ? 'manual' : 'startup'),
-            ...(selected ? { logicalIdentity: selected.logicalIdentity } : {}),
-            ...(selected?.active ? { active: selected.active } : {}),
-            ...(selected?.candidate ? { candidate: selected.candidate } : {}),
-            ...(selected?.lastCheck ? { lastCheck: selected.lastCheck } : {}),
-        });
-    }
-    return { catalogGenerationStatusSchemaVersion: 1, sources: entries };
+            if (entry.metadata.manifestDigest !== active.manifestDigest) {
+                throw new CatalogGenerationError({
+                    code: 'catalogGenerationIdentityMismatch',
+                    message: 'Active does not match store metadata.',
+                });
+            }
+            return {
+                sourceId: source.id,
+                configuredSourceIdentity,
+                active,
+                activeReady: configMatchesActive,
+                configMatchesActive,
+                catalogVersion: entry.metadata.catalogVersion,
+                channel: entry.metadata.channel,
+                storeKey: createCatalogStoreKey(active.logicalIdentity, active.snapshotDigest),
+                lastSync: sourceState?.lastSync,
+            };
+        }
+        catch (error) {
+            return {
+                sourceId: source.id,
+                configuredSourceIdentity,
+                active,
+                activeReady: false,
+                configMatchesActive,
+                lastSync: sourceState?.lastSync,
+                errorCode: catalogGenerationErrorCode(error),
+            };
+        }
+    }));
+    return { catalogGenerationStatusSchemaVersion: 1, sources };
 }
 //# sourceMappingURL=catalog-generation-service.js.map