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

package/dist/types.d.ts

@@ -55,6 +55,11 @@ export interface BuildConfigManifestOverrides {
 export interface BuildConfigRuntimeExport {
     name: string;
     source: string;
+    requires: {
+        aw: {
+            capabilities: string[];
+        };
+    };
 }
 export interface BuildConfigImportReference {
     plugin: string;
@@ -250,6 +255,8 @@ export interface ArtifactRuntimeImportDefinition extends BuildConfigImportRefere
         providerPluginId: PluginId;
         providerVersion: PluginVersion;
         source: string;
+        requiredCapabilities: string[];
+        capabilitySetDigest: string;
     };
 }
 export interface PluginArtifactTargetDefinition {
@@ -331,7 +338,7 @@ export interface CatalogManifestEntry {
     artifactDigest: string;
     manifestDigest: string;
 }
-export interface CatalogManifestV5Entry extends CatalogManifestEntry {
+export interface CatalogManifestV6Entry extends CatalogManifestEntry {
     name: PluginId;
     contentDigest: string;
 }
@@ -339,23 +346,20 @@ export interface CatalogMarketplaceIdentity {
     owner: MarketplaceOwner;
     interface: MarketplaceInterfaceMeta;
 }
-export type CatalogManifestV5Release = {
+export type CatalogManifestV6Release = {
     state: 'development';
 } | {
     state: 'published';
-    targetVersion: string;
-    planId: string;
     sourceHead: string;
-    contentDigest: string;
 };
-export interface CatalogManifestV5 {
-    schemaVersion: 5;
+export interface CatalogManifestV6 {
+    schemaVersion: 6;
     catalogVersion: string;
     channel: CatalogChannel;
     requires: PluginRequirements;
     marketplace: CatalogMarketplaceIdentity;
-    release: CatalogManifestV5Release;
-    entries: CatalogManifestV5Entry[];
+    release: CatalogManifestV6Release;
+    entries: CatalogManifestV6Entry[];
 }
 export interface PlatformPluginManifest {
     name: string;

package/dist/workspace.d.ts

@@ -1,6 +1,5 @@
-import { type PluginReleaseLedger } from './plugin-release.js';
 import type { ReservedImportRegistry } from './manifest-contract.js';
-import type { CatalogChannel, CatalogManifestV5, MarketplaceSourceMeta, PluginMeta } from './types.js';
+import type { CatalogChannel, CatalogManifestV6, MarketplaceSourceMeta, PluginMeta } from './types.js';
 export declare const DEFAULT_CATALOG_WORKSPACE_VERSION = "0.1.0";
 export declare const DEFAULT_CATALOG_OUTPUT_PATH: string;
 export declare const DEFAULT_PUBLISHED_CATALOG_OUTPUT_PATH: string;
@@ -50,6 +49,10 @@ export declare function resolveCatalogWorkspaceOutputPath(options: {
     workspaceRoot: string;
     outputRoot: string;
 }>;
+export declare function readCatalogWorkspaceMarker(workspaceRoot: string): Promise<{
+    markerPath: string;
+    workspaceIdentity: string;
+}>;
 export declare function initializeCatalogWorkspace(options: CatalogWorkspaceInitOptions): Promise<{
     workspaceRoot: string;
     markerPath: string;
@@ -76,8 +79,7 @@ export declare function buildCatalogWorkspace(options: {
 }>;
 export declare function validatePublishedCatalogSnapshot(snapshotDirectory: string): Promise<{
     rootDir: string;
-    manifest: CatalogManifestV5;
-    ledger: PluginReleaseLedger;
+    manifest: CatalogManifestV6;
     snapshotDigest: string;
 }>;
 export declare function preparePublishedCatalogWorkspace(options: {
@@ -93,8 +95,6 @@ export declare function preparePublishedCatalogWorkspace(options: {
     channel: CatalogChannel;
     pluginNames: string[];
     snapshotDigest: string;
-    contentDigest: string;
-    planId: string;
 }>;
 export declare function buildCatalogWorkspacePlugin(options: {
     workspaceRoot: string;
@@ -111,20 +111,12 @@ export declare function buildCatalogWorkspacePlugin(options: {
 }>;
 export declare function validateCatalogSnapshotTransport(snapshotDirectory: string): Promise<{
     rootDir: string;
-    manifest: CatalogManifestV5;
-    ledger?: PluginReleaseLedger;
-    snapshotDigest: string;
-}>;
-export declare function validatePublishedCatalogPublicationParent(snapshotDirectory: string): Promise<{
-    rootDir: string;
-    catalogVersion: string;
-    ledger: PluginReleaseLedger;
+    manifest: CatalogManifestV6;
     snapshotDigest: string;
 }>;
 type CatalogSnapshotValidationResult = {
     rootDir: string;
-    manifest: CatalogManifestV5;
-    ledger?: PluginReleaseLedger;
+    manifest: CatalogManifestV6;
     snapshotDigest: string;
 };
 export declare function validateCatalogSnapshotPluginEntriesComplete(snapshotDirectory: string, pluginNames: readonly string[]): Promise<CatalogSnapshotValidationResult>;

package/dist/workspace.js

@@ -2,10 +2,9 @@ import crypto from 'node:crypto';
 import path from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import fs from 'fs-extra';
-import { assertCatalogVersion, assertStrictSemVer, compareStrictSemVer, MARKETPLACE_SOURCE_PATH, SOURCE_MANIFEST_PATH, createMarketplaceManifest, createMarketplaceManifestEntry, normalizeCatalogManifestBase, normalizeCatalogMarketplaceIdentity, normalizeCatalogManifestEntries, normalizeManifestDigestInput, readMarketplaceSourceMeta, readPluginManifest, validatePlatformManifestProjection, } from './manifest-contract.js';
+import { assertCatalogVersion, assertStrictSemVer, compareStrictSemVer, parseStrictSemVer, MARKETPLACE_SOURCE_PATH, SOURCE_MANIFEST_PATH, createMarketplaceManifest, createMarketplaceManifestEntry, normalizeCatalogManifestBase, normalizeCatalogMarketplaceIdentity, normalizeCatalogManifestEntries, normalizeManifestDigestInput, readMarketplaceSourceMeta, readPluginManifest, validatePlatformManifestProjection, } from './manifest-contract.js';
 import { resolveSupportedPlatforms } from './platform-support.js';
 import { createAwPluginRequirementsReceipt, normalizeAwCapabilities, parseAwPluginRequirementsReceipt, } from './aw-capabilities.js';
-import { appendCatalogToPluginReleaseLedger, assertStablePluginVersion, PLUGIN_RELEASE_LEDGER_FILENAME, PLUGIN_RELEASE_LEDGER_SCHEMA_VERSION, resolveBetaPluginVersionOverrides, validatePluginReleaseLedgerAgainstManifest, } from './plugin-release.js';
 export const DEFAULT_CATALOG_WORKSPACE_VERSION = '0.1.0';
 export const DEFAULT_CATALOG_OUTPUT_PATH = path.join('.aw', 'catalog');
 export const DEFAULT_PUBLISHED_CATALOG_OUTPUT_PATH = path.join('.aw', 'publish', 'catalog');
@@ -140,9 +139,18 @@ function validateCatalogWorkspaceMarker(value) {
     }
     return { workspaceIdentity: marker.workspaceIdentity };
 }
-async function readCatalogWorkspaceMarker(workspaceRoot) {
+export async function readCatalogWorkspaceMarker(workspaceRoot) {
     const markerPath = path.join(workspaceRoot, CATALOG_WORKSPACE_MARKER_FILENAME);
-    const marker = validateCatalogWorkspaceMarker(await readRegularJson(markerPath, 'Catalog Workspace marker'));
+    let value;
+    try {
+        value = await readRegularJson(markerPath, 'Catalog Workspace marker');
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            throw new Error('Invalid Catalog Workspace marker.');
+        throw error;
+    }
+    const marker = validateCatalogWorkspaceMarker(value);
     return { markerPath, workspaceIdentity: marker.workspaceIdentity };
 }
 async function readRegularJson(filePath, label) {
@@ -400,22 +408,6 @@ function stableStringify(value) {
 function sha256(value) {
     return `sha256:${crypto.createHash('sha256').update(value).digest('hex')}`;
 }
-function publishedContentDigest(manifest) {
-    return sha256(stableStringify({
-        schemaIdentity: { schemaVersion: manifest.schemaVersion },
-        marketplaceMetadata: {
-            name: 'aw',
-            owner: manifest.marketplace.owner,
-            interface: manifest.marketplace.interface,
-        },
-        requires: manifest.requires,
-        plugins: manifest.entries.map((entry) => ({
-            name: entry.name,
-            targetVersion: entry.version.replace(/-beta\.[1-9]\d*$/u, ''),
-            contentDigest: entry.contentDigest,
-        })).sort((left, right) => left.name.localeCompare(right.name)),
-    }));
-}
 const SOURCE_IDENTITY_EXCLUDED_DIRECTORIES = new Set([
     '.git', '.aw', 'node_modules', 'evals', 'reports',
 ]);
@@ -558,7 +550,7 @@ async function validateBundleRuntimeRequirementsReceipts(plugin, pluginRoot) {
         }
     }
 }
-function normalizeCatalogRelease(raw, catalogVersion) {
+function normalizeCatalogRelease(raw) {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
         throw new Error('Invalid catalog manifest release: expected an object.');
     }
@@ -569,33 +561,16 @@ function normalizeCatalogRelease(raw, catalogVersion) {
         }
         return { state: 'development' };
     }
-    const allowed = new Set(['state', 'targetVersion', 'planId', 'sourceHead', 'contentDigest']);
+    const allowed = new Set(['state', 'sourceHead']);
     if (release.state !== 'published' || Object.keys(release).some((key) => !allowed.has(key))) {
         throw new Error('Invalid published catalog release.');
     }
-    const targetVersion = assertStrictSemVer(release.targetVersion, 'catalog release targetVersion');
-    if (targetVersion.includes('-') || targetVersion.includes('+')) {
-        throw new Error('Invalid catalog release targetVersion: expected a stable version.');
-    }
-    if (targetVersion !== catalogVersion.replace(/-beta\.[1-9]\d*$/u, '')) {
-        throw new Error('Invalid catalog release targetVersion: must match catalogVersion.');
-    }
-    const digestPattern = /^sha256:[0-9a-f]{64}$/u;
-    if (typeof release.planId !== 'string' || !digestPattern.test(release.planId)) {
-        throw new Error('Invalid catalog release planId.');
-    }
-    if (typeof release.contentDigest !== 'string' || !digestPattern.test(release.contentDigest)) {
-        throw new Error('Invalid catalog release contentDigest.');
-    }
     if (typeof release.sourceHead !== 'string' || !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u.test(release.sourceHead)) {
         throw new Error('Invalid catalog release sourceHead.');
     }
     return {
         state: 'published',
-        targetVersion,
-        planId: release.planId,
         sourceHead: release.sourceHead,
-        contentDigest: release.contentDigest,
     };
 }
 export async function buildCatalogWorkspace(options) {
@@ -643,10 +618,10 @@ export async function buildCatalogWorkspace(options) {
                 .sort((left, right) => left.manifest.name.localeCompare(right.manifest.name))
                 .map((plugin) => expectedCatalogEntry(plugin, plugin.rootDir)));
             const manifest = {
-                schemaVersion: 5,
+                schemaVersion: 6,
                 catalogVersion,
                 channel,
-                requires: { aw: { capabilities: ['aw.catalog-snapshot.v5'] } },
+                requires: { aw: { capabilities: ['aw.catalog-snapshot.v6'] } },
                 marketplace: {
                     owner: catalogWorkspace.metadata.owner,
                     interface: catalogWorkspace.metadata.interface,
@@ -692,14 +667,77 @@ async function rewritePublishedPluginVersions(snapshotRoot, overrides) {
         }
     }
 }
+function assertStablePluginVersion(version, fieldName) {
+    const parsed = parseStrictSemVer(version, fieldName);
+    if (parsed.prerelease.length > 0 || parsed.build.length > 0) {
+        throw new Error(`Invalid ${fieldName}: expected a stable SemVer without prerelease or build metadata.`);
+    }
+    return version;
+}
+function stableVersionBase(version, fieldName) {
+    const parsed = parseStrictSemVer(version, fieldName);
+    return `${parsed.major}.${parsed.minor}.${parsed.patch}`;
+}
+function resolvePublishedPluginVersions(options) {
+    const previousEntries = new Map(options.previous?.entries.map((entry) => [entry.name, entry]) ?? []);
+    const versions = {};
+    for (const plugin of options.plugins) {
+        const name = plugin.manifest.name;
+        const sourceVersion = assertStablePluginVersion(plugin.manifest.version, `${name} source version`);
+        const contentDigest = options.contentDigests.get(name);
+        if (!contentDigest)
+            throw new Error(`Missing release content digest for plugin ${JSON.stringify(name)}.`);
+        const previous = previousEntries.get(name);
+        if (!previous) {
+            versions[name] = options.channel === 'beta' ? `${sourceVersion}-beta.1` : sourceVersion;
+            continue;
+        }
+        const previousVersion = assertStrictSemVer(previous.version, `${name} previous published version`);
+        if (options.channel === 'latest') {
+            const comparison = compareStrictSemVer(sourceVersion, previousVersion);
+            if (comparison < 0) {
+                throw new Error(`Plugin ${name} source version ${sourceVersion} must not be lower than previous ${previousVersion}.`);
+            }
+            if (comparison === 0 && previous.contentDigest !== contentDigest) {
+                throw new Error(`Plugin ${name} version ${sourceVersion} maps to different content. Increase the source plugin version.`);
+            }
+            versions[name] = sourceVersion;
+            continue;
+        }
+        const previousBase = stableVersionBase(previousVersion, `${name} previous published version`);
+        const baseComparison = compareStrictSemVer(sourceVersion, previousBase);
+        if (baseComparison < 0) {
+            throw new Error(`Plugin ${name} source version ${sourceVersion} must not be lower than previous base ${previousBase}.`);
+        }
+        if (baseComparison > 0) {
+            versions[name] = `${sourceVersion}-beta.1`;
+            continue;
+        }
+        const parsedPrevious = parseStrictSemVer(previousVersion, `${name} previous published version`);
+        if (parsedPrevious.prerelease.length === 0) {
+            if (previous.contentDigest !== contentDigest) {
+                throw new Error(`Plugin ${name} stable version ${sourceVersion} maps to different content. Increase the source plugin version.`);
+            }
+            versions[name] = previousVersion;
+            continue;
+        }
+        if (parsedPrevious.prerelease.length !== 2
+            || parsedPrevious.prerelease[0] !== 'beta'
+            || !/^[1-9]\d*$/u.test(parsedPrevious.prerelease[1])) {
+            throw new Error(`Plugin ${name} previous version ${previousVersion} is not a stable or beta publication version.`);
+        }
+        versions[name] = previous.contentDigest === contentDigest
+            ? previousVersion
+            : `${sourceVersion}-beta.${Number(parsedPrevious.prerelease[1]) + 1}`;
+    }
+    return versions;
+}
 export async function validatePublishedCatalogSnapshot(snapshotDirectory) {
     const validation = await validateCatalogSnapshotComplete(snapshotDirectory);
     if (validation.manifest.release.state !== 'published') {
         throw new Error('Published Catalog snapshot must have release.state published.');
     }
-    if (!validation.ledger)
-        throw new Error('Published Catalog snapshot must include a plugin release ledger.');
-    return { ...validation, ledger: validation.ledger };
+    return validation;
 }
 export async function preparePublishedCatalogWorkspace(options) {
     if (!/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u.test(options.sourceHead)) {
@@ -712,15 +750,11 @@ export async function preparePublishedCatalogWorkspace(options) {
     const catalogVersion = catalogWorkspace.metadata.catalog.version;
     const channel = deriveCatalogChannel(catalogVersion);
     const previous = options.previousSnapshotRoot
-        ? await validatePublishedCatalogPublicationParent(options.previousSnapshotRoot)
+        ? await validatePublishedCatalogSnapshot(options.previousSnapshotRoot)
         : null;
-    if (previous && compareStrictSemVer(catalogVersion, previous.catalogVersion) <= 0) {
-        throw new Error(`Catalog version ${catalogVersion} must be higher than published ${previous.catalogVersion}.`);
+    if (previous && compareStrictSemVer(catalogVersion, previous.manifest.catalogVersion) <= 0) {
+        throw new Error(`Catalog version ${catalogVersion} must be higher than published ${previous.manifest.catalogVersion}.`);
     }
-    const previousLedger = previous?.ledger ?? {
-        schemaVersion: PLUGIN_RELEASE_LEDGER_SCHEMA_VERSION,
-        records: [],
-    };
     const temporaryRelative = path.join('.aw', 'publish', `.catalog-preparation-${crypto.randomUUID()}`);
     const finalRelative = options.outputPath
         ?? `${DEFAULT_PUBLISHED_CATALOG_OUTPUT_PATH}-v${catalogVersion}`;
@@ -735,13 +769,12 @@ export async function preparePublishedCatalogWorkspace(options) {
         temporaryRoot = built.outputRoot;
         const development = await validateCatalogSnapshotComplete(temporaryRoot);
         const contentDigests = new Map(development.manifest.entries.map((entry) => [entry.name, entry.contentDigest]));
-        const overrides = channel === 'beta'
-            ? resolveBetaPluginVersionOverrides({
-                plugins: catalogWorkspace.plugins,
-                contentDigests,
-                ledger: previousLedger,
-            })
-            : Object.fromEntries(catalogWorkspace.plugins.map((plugin) => [plugin.manifest.name, plugin.manifest.version]));
+        const overrides = resolvePublishedPluginVersions({
+            channel,
+            plugins: catalogWorkspace.plugins,
+            contentDigests,
+            previous: previous?.manifest ?? null,
+        });
         await rewritePublishedPluginVersions(temporaryRoot, overrides);
         const bundledPlugins = await Promise.all(catalogWorkspace.plugins.map((plugin) => readPluginManifest(path.join(temporaryRoot, 'plugins', plugin.manifest.name), { mode: 'bundle' })));
         const entries = await Promise.all(bundledPlugins.sort((left, right) => left.manifest.name.localeCompare(right.manifest.name))
@@ -752,26 +785,14 @@ export async function preparePublishedCatalogWorkspace(options) {
             channel,
             entries,
         };
-        const contentDigest = publishedContentDigest(manifestWithoutRelease);
         const manifest = {
             ...manifestWithoutRelease,
             release: {
                 state: 'published',
-                targetVersion: catalogVersion.replace(/-beta\.[1-9]\d*$/u, ''),
-                planId: contentDigest,
                 sourceHead: options.sourceHead,
-                contentDigest,
             },
         };
-        const ledger = appendCatalogToPluginReleaseLedger({
-            previous: previousLedger,
-            manifest,
-            contentDigests,
-        });
-        await Promise.all([
-            fs.writeFile(path.join(temporaryRoot, CATALOG_MANIFEST_FILENAME), `${JSON.stringify(manifest, null, 2)}\n`),
-            fs.writeFile(path.join(temporaryRoot, PLUGIN_RELEASE_LEDGER_FILENAME), `${JSON.stringify(ledger, null, 2)}\n`),
-        ]);
+        await fs.writeFile(path.join(temporaryRoot, CATALOG_MANIFEST_FILENAME), `${JSON.stringify(manifest, null, 2)}\n`);
         const prepared = await validatePublishedCatalogSnapshot(temporaryRoot);
         const resolved = await resolveCatalogWorkspaceOutputPath({
             workspaceRoot: catalogWorkspace.workspaceRoot,
@@ -795,8 +816,6 @@ export async function preparePublishedCatalogWorkspace(options) {
             channel,
             pluginNames: built.pluginNames,
             snapshotDigest: prepared.snapshotDigest,
-            contentDigest,
-            planId: contentDigest,
         };
     }
     finally {
@@ -922,7 +941,7 @@ async function digestDirectory(root) {
     await walk(root);
     return `sha256:${crypto.createHash('sha256').update(entries.join('\n')).digest('hex')}`;
 }
-async function validateCatalogSnapshotTransportInternal(snapshotDirectory, options = {}) {
+async function validateCatalogSnapshotTransportInternal(snapshotDirectory) {
     const rootDir = await assertDirectoryWithoutSymlinks(snapshotDirectory, 'Catalog snapshot');
     const allowed = new Set([
         CATALOG_MANIFEST_FILENAME,
@@ -930,7 +949,6 @@ async function validateCatalogSnapshotTransportInternal(snapshotDirectory, optio
         '.agents',
         '.claude-plugin',
         'plugins',
-        'plugin-release-ledger.json',
     ]);
     const entries = await fs.readdir(rootDir);
     const unexpected = entries.filter((entry) => !allowed.has(entry));
@@ -970,19 +988,18 @@ async function validateCatalogSnapshotTransportInternal(snapshotDirectory, optio
     await readRegularJson(path.join(rootDir, '.agents', 'plugins', 'marketplace.json'), 'Codex marketplace');
     await readRegularJson(path.join(rootDir, '.claude-plugin', 'marketplace.json'), 'Claude marketplace');
     const snapshotDigest = await digestDirectory(rootDir);
-    const raw = options.rawManifest
-        ?? await fs.readJson(path.join(rootDir, CATALOG_MANIFEST_FILENAME));
+    const raw = await fs.readJson(path.join(rootDir, CATALOG_MANIFEST_FILENAME));
     const allowedManifestKeys = new Set([
         'schemaVersion', 'catalogVersion', 'channel', 'requires', 'marketplace', 'release', 'entries',
     ]);
     for (const key of Object.keys(raw))
         if (!allowedManifestKeys.has(key))
             throw new Error(`Invalid catalog manifest: unknown field ${JSON.stringify(key)}.`);
-    if (raw.schemaVersion !== 5)
-        throw new Error('Invalid catalog manifest schemaVersion: expected 5.');
-    const base = normalizeCatalogManifestBase(raw, 'catalog manifest v5');
-    if (!(base.requires.aw.capabilities ?? []).includes('aw.catalog-snapshot.v5')) {
-        throw new Error('Invalid catalog manifest requires.aw.capabilities: expected aw.catalog-snapshot.v5.');
+    if (raw.schemaVersion !== 6)
+        throw new Error('Invalid catalog manifest schemaVersion: expected 6.');
+    const base = normalizeCatalogManifestBase(raw, 'catalog manifest v6');
+    if (!(base.requires.aw.capabilities ?? []).includes('aw.catalog-snapshot.v6')) {
+        throw new Error('Invalid catalog manifest requires.aw.capabilities: expected aw.catalog-snapshot.v6.');
     }
     const marketplaceIdentity = normalizeCatalogMarketplaceIdentity(raw.marketplace);
     if (!Array.isArray(raw.entries))
@@ -999,7 +1016,7 @@ async function validateCatalogSnapshotTransportInternal(snapshotDirectory, optio
         delete copy.contentDigest;
         return copy;
     });
-    const normalizedEntries = normalizeCatalogManifestEntries(entriesWithoutContentDigest, base, 'catalog manifest v5')
+    const normalizedEntries = normalizeCatalogManifestEntries(entriesWithoutContentDigest, base, 'catalog manifest v6')
         .map((entry, index) => ({ ...entry, contentDigest: contentDigests[index] }));
     const pluginNames = normalizedEntries.map((entry, index) => {
         if (typeof entry.name !== 'string')
@@ -1031,10 +1048,6 @@ async function validateCatalogSnapshotTransportInternal(snapshotDirectory, optio
             contentDigest: await calculateEntryDigest(pluginRoot, true),
         };
         for (const field of Object.keys(expectedDigests)) {
-            // V4 used a normalized Manifest v1 digest. The artifact digest still binds the raw manifest bytes,
-            // and the release ledger must still match the preserved v4 manifestDigest.
-            if (field === 'manifestDigest' && options.legacyV4PublicationParent)
-                continue;
             if (entry[field] !== expectedDigests[field]) {
                 throw new Error(`Catalog entry ${field} for ${JSON.stringify(name)} does not match its plugin bundle.`);
             }
@@ -1083,9 +1096,9 @@ async function validateCatalogSnapshotTransportInternal(snapshotDirectory, optio
     if (!isDeepStrictEqual(normalizeMarketplaceOrder(claudeMarketplace), normalizeMarketplaceOrder(expectedClaude))) {
         throw new Error('Claude marketplace metadata or plugin inventory does not match the snapshot bundles.');
     }
-    const release = normalizeCatalogRelease(raw.release, base.catalogVersion);
+    const release = normalizeCatalogRelease(raw.release);
     const manifest = {
-        schemaVersion: 5,
+        schemaVersion: 6,
         catalogVersion: base.catalogVersion,
         channel: base.channel,
         requires: base.requires,
@@ -1093,157 +1106,11 @@ async function validateCatalogSnapshotTransportInternal(snapshotDirectory, optio
         release,
         entries: normalizedEntries,
     };
-    if (release.state === 'published') {
-        const contentDigest = publishedContentDigest(manifest);
-        if (release.contentDigest !== contentDigest) {
-            throw new Error('Published catalog release contentDigest does not match the snapshot.');
-        }
-    }
-    const hasLedger = entries.includes(PLUGIN_RELEASE_LEDGER_FILENAME);
-    if (release.state === 'published' && !hasLedger) {
-        throw new Error('Published Catalog snapshot must include plugin-release-ledger.json.');
-    }
-    if (release.state === 'development' && hasLedger) {
-        throw new Error('Development Catalog snapshot must not include plugin-release-ledger.json.');
-    }
-    const ledger = hasLedger
-        ? validatePluginReleaseLedgerAgainstManifest(await readRegularJson(path.join(rootDir, PLUGIN_RELEASE_LEDGER_FILENAME), 'Plugin release ledger'), manifest)
-        : undefined;
-    return { rootDir, manifest, ...(ledger ? { ledger } : {}), snapshotDigest };
+    return { rootDir, manifest, snapshotDigest };
 }
 export async function validateCatalogSnapshotTransport(snapshotDirectory) {
     return validateCatalogSnapshotTransportInternal(snapshotDirectory);
 }
-function normalizeLegacyCatalogCompatibility(value, fieldName) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new Error(`Invalid ${fieldName}: expected an object.`);
-    }
-    const compatibility = value;
-    if (!isDeepStrictEqual(Object.keys(compatibility), ['aw'])) {
-        throw new Error(`Invalid ${fieldName}: unknown field.`);
-    }
-    if (!compatibility.aw || typeof compatibility.aw !== 'object' || Array.isArray(compatibility.aw)) {
-        throw new Error(`Invalid ${fieldName}.aw: expected an object.`);
-    }
-    const aw = compatibility.aw;
-    if (!isDeepStrictEqual(Object.keys(aw), ['minVersion'])) {
-        throw new Error(`Invalid ${fieldName}.aw: unknown field.`);
-    }
-    return { aw: { minVersion: assertStrictSemVer(aw.minVersion, `${fieldName}.aw.minVersion`) } };
-}
-function normalizeLegacyPublishedCatalogManifestV4(raw) {
-    const allowedManifestKeys = new Set([
-        'schemaVersion', 'catalogVersion', 'channel', 'compatibility', 'marketplace', 'release', 'entries',
-    ]);
-    for (const key of Object.keys(raw)) {
-        if (!allowedManifestKeys.has(key))
-            throw new Error(`Invalid legacy catalog manifest: unknown field ${JSON.stringify(key)}.`);
-    }
-    if (raw.schemaVersion !== 4)
-        throw new Error('Invalid legacy catalog manifest schemaVersion: expected 4.');
-    const catalogVersion = assertCatalogVersion(raw.catalogVersion, 'legacy catalog manifest v4.catalogVersion');
-    if (raw.channel !== 'latest' && raw.channel !== 'beta') {
-        throw new Error('Invalid legacy catalog manifest v4.channel: expected "latest" or "beta".');
-    }
-    const channel = raw.channel;
-    const isBetaVersion = catalogVersion.includes('-beta.');
-    if ((channel === 'latest' && isBetaVersion) || (channel === 'beta' && !isBetaVersion)) {
-        throw new Error('Invalid legacy catalog manifest v4 catalogVersion channel.');
-    }
-    const compatibility = normalizeLegacyCatalogCompatibility(raw.compatibility, 'legacy catalog manifest v4.compatibility');
-    const marketplace = normalizeCatalogMarketplaceIdentity(raw.marketplace, 'legacy catalog manifest v4.marketplace');
-    if (!Array.isArray(raw.entries))
-        throw new Error('Invalid legacy catalog manifest v4.entries: expected an array.');
-    const allowedEntryKeys = new Set([
-        'name', 'version', 'description', 'interface', 'category', 'tags', 'strict', 'policy',
-        'compatibility', 'source', 'artifactDigest', 'manifestDigest', 'contentDigest',
-    ]);
-    const translatedEntryInputs = raw.entries.map((value, index) => {
-        if (!value || typeof value !== 'object' || Array.isArray(value)) {
-            throw new Error(`Invalid legacy catalog manifest v4.entries[${index}]: expected an object.`);
-        }
-        const entry = value;
-        for (const key of Object.keys(entry)) {
-            if (!allowedEntryKeys.has(key)) {
-                throw new Error(`Invalid legacy catalog manifest v4.entries[${index}]: unknown field ${JSON.stringify(key)}.`);
-            }
-        }
-        const entryCompatibility = normalizeLegacyCatalogCompatibility(entry.compatibility, `legacy catalog manifest v4.entries[${index}].compatibility`);
-        if (compareStrictSemVer(entryCompatibility.aw.minVersion, compatibility.aw.minVersion) < 0) {
-            throw new Error(`Invalid legacy catalog manifest v4.entries[${index}].compatibility.aw.minVersion.`);
-        }
-        const translated = { ...entry };
-        delete translated.compatibility;
-        delete translated.contentDigest;
-        return {
-            ...translated,
-            dependencies: [],
-            requires: { aw: { capabilities: [] } },
-        };
-    });
-    const translatedBase = normalizeCatalogManifestBase({
-        catalogVersion,
-        channel,
-        requires: { aw: { capabilities: ['aw.catalog-snapshot.v5'] } },
-    }, 'legacy catalog manifest v4 translation');
-    const normalizedEntries = normalizeCatalogManifestEntries(translatedEntryInputs, translatedBase, 'legacy catalog manifest v4 translation').map((entry, index) => {
-        const contentDigest = raw.entries[index].contentDigest;
-        if (typeof contentDigest !== 'string' || !/^sha256:[0-9a-f]{64}$/u.test(contentDigest)) {
-            throw new Error(`Invalid legacy catalog manifest v4.entries[${index}].contentDigest.`);
-        }
-        return { ...entry, contentDigest };
-    });
-    const release = normalizeCatalogRelease(raw.release, catalogVersion);
-    if (release.state !== 'published') {
-        throw new Error('Legacy Catalog publication parent must have release.state published.');
-    }
-    const legacyContentDigest = sha256(stableStringify({
-        schemaIdentity: { schemaVersion: 4 },
-        marketplaceMetadata: { name: 'aw', owner: marketplace.owner, interface: marketplace.interface },
-        compatibility,
-        plugins: normalizedEntries.map((entry) => ({
-            name: entry.name,
-            targetVersion: entry.version.replace(/-beta\.[1-9]\d*$/u, ''),
-            contentDigest: entry.contentDigest,
-        })).sort((left, right) => left.name.localeCompare(right.name)),
-    }));
-    if (release.contentDigest !== legacyContentDigest) {
-        throw new Error('Published legacy catalog release contentDigest does not match the snapshot.');
-    }
-    const translatedManifest = {
-        schemaVersion: 5,
-        catalogVersion,
-        channel,
-        requires: translatedBase.requires,
-        marketplace,
-        release,
-        entries: normalizedEntries,
-    };
-    return {
-        ...translatedManifest,
-        release: { ...release, contentDigest: publishedContentDigest(translatedManifest) },
-    };
-}
-export async function validatePublishedCatalogPublicationParent(snapshotDirectory) {
-    const raw = await readRegularJson(path.join(snapshotDirectory, CATALOG_MANIFEST_FILENAME), 'Catalog publication parent manifest');
-    const validation = raw.schemaVersion === 4
-        ? await validateCatalogSnapshotTransportInternal(snapshotDirectory, {
-            rawManifest: normalizeLegacyPublishedCatalogManifestV4(raw),
-            legacyV4PublicationParent: true,
-        })
-        : await validatePublishedCatalogSnapshot(snapshotDirectory);
-    if (validation.manifest.release.state !== 'published') {
-        throw new Error('Catalog publication parent must have release.state published.');
-    }
-    if (!validation.ledger)
-        throw new Error('Catalog publication parent must include a plugin release ledger.');
-    return {
-        rootDir: validation.rootDir,
-        catalogVersion: validation.manifest.catalogVersion,
-        ledger: validation.ledger,
-        snapshotDigest: validation.snapshotDigest,
-    };
-}
 async function validateCatalogPluginEntriesComplete(validation, pluginNames) {
     const entriesByName = new Map(validation.manifest.entries.map((entry) => [entry.name, entry]));
     const plugins = [];