@lesliechan721/aw-plugin-core 0.1.0-beta.4 → 0.1.0-beta.6

package/dist/workspace.js

@@ -5,13 +5,13 @@ 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 { resolveSupportedPlatforms } from './platform-support.js';
 import { appendCatalogToPluginReleaseLedger, assertStablePluginVersion, PLUGIN_RELEASE_LEDGER_FILENAME, PLUGIN_RELEASE_LEDGER_SCHEMA_VERSION, resolveBetaPluginVersionOverrides, validatePluginReleaseLedgerAgainstManifest, } from './plugin-release.js';
-export const DEFAULT_WORKSPACE_CATALOG_VERSION = '0.1.0';
+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');
 export const DEFAULT_PLUGIN_OUTPUT_PATH = path.join('.aw', 'plugins');
 export const CATALOG_MANIFEST_FILENAME = 'catalog-manifest.json';
 export const GENERATED_OUTPUT_MARKER_FILENAME = '.aw-generated.json';
-export const WORKSPACE_MARKER_FILENAME = '.aw-workspace.json';
+export const CATALOG_WORKSPACE_MARKER_FILENAME = '.aw-workspace.json';
 function isInside(root, candidate) {
     const relative = path.relative(root, candidate);
     return relative === '' || (relative !== '..'
@@ -47,11 +47,11 @@ async function assertNoSymlinkPath(root, target) {
         }
     }
 }
-export async function resolveWorkspaceOutputPath(options) {
-    const workspaceRoot = await assertDirectoryWithoutSymlinks(options.workspaceRoot, 'Workspace root');
+export async function resolveCatalogWorkspaceOutputPath(options) {
+    const workspaceRoot = await assertDirectoryWithoutSymlinks(options.workspaceRoot, 'Catalog Workspace root');
     const outputRoot = path.resolve(workspaceRoot, options.outputPath);
     if (!isInside(workspaceRoot, outputRoot) || outputRoot === workspaceRoot) {
-        throw new Error(`Output must be inside the workspace: ${outputRoot}`);
+        throw new Error(`Output must be inside the Catalog Workspace: ${outputRoot}`);
     }
     await assertNoSymlinkPath(workspaceRoot, outputRoot);
     const protectedRoots = [
@@ -63,7 +63,7 @@ export async function resolveWorkspaceOutputPath(options) {
         if (protectedRoot.endsWith(`${path.sep}.aw`) && outputRoot !== protectedRoot)
             continue;
         if (isInside(protectedRoot, outputRoot) || isInside(outputRoot, protectedRoot)) {
-            throw new Error(`Output overlaps a protected workspace path: ${outputRoot}`);
+            throw new Error(`Output overlaps a protected Catalog Workspace path: ${outputRoot}`);
         }
     }
     const otherGeneratedRoot = path.join(workspaceRoot, options.kind === 'catalog' ? DEFAULT_PLUGIN_OUTPUT_PATH : DEFAULT_CATALOG_OUTPUT_PATH);
@@ -72,24 +72,24 @@ export async function resolveWorkspaceOutputPath(options) {
     }
     return { workspaceRoot, outputRoot };
 }
-function safeWorkspaceName(workspaceRoot) {
+function safeCatalogWorkspaceName(workspaceRoot) {
     const normalized = path.basename(workspaceRoot).toLowerCase()
         .replace(/[^a-z0-9]+/gu, '-')
         .replace(/^-+|-+$/gu, '');
     return normalized || 'aw-workspace';
 }
-function workspaceMetadata(options, workspaceRoot) {
-    const workspaceName = safeWorkspaceName(workspaceRoot);
+function catalogWorkspaceMetadata(options, workspaceRoot) {
+    const catalogWorkspaceName = safeCatalogWorkspaceName(workspaceRoot);
     return {
         owner: {
-            name: options.ownerName?.trim() || workspaceName,
-            url: options.ownerUrl?.trim() || `https://example.invalid/aw-workspaces/${workspaceName}`,
+            name: options.ownerName?.trim() || catalogWorkspaceName,
+            url: options.ownerUrl?.trim() || `https://example.invalid/aw-workspaces/${catalogWorkspaceName}`,
         },
         interface: {
-            displayName: options.displayName?.trim() || workspaceName,
+            displayName: options.displayName?.trim() || catalogWorkspaceName,
         },
         catalog: {
-            version: assertCatalogVersion(options.catalogVersion ?? DEFAULT_WORKSPACE_CATALOG_VERSION, 'catalog version'),
+            version: assertCatalogVersion(options.catalogVersion ?? DEFAULT_CATALOG_WORKSPACE_VERSION, 'catalog version'),
         },
     };
 }
@@ -115,41 +115,33 @@ async function writeTextAtomic(filePath, value) {
         throw error;
     }
 }
-function workspaceIdentity(workspaceRoot) {
-    return sha256(`aw-plugin-workspace-v1\0${path.resolve(workspaceRoot)}`);
-}
-function workspaceScaffoldMarker(metadata) {
+function catalogWorkspaceMarker() {
     return {
         schemaVersion: 1,
-        kind: 'aw-plugin-workspace',
+        kind: 'aw-catalog-workspace',
         workspaceIdentity: sha256(crypto.randomUUID()),
-        sourceIdentity: sha256(stableStringify(metadata)),
     };
 }
-function validateWorkspaceScaffoldMarker(value) {
+function validateCatalogWorkspaceMarker(value) {
     const marker = value;
-    const digestPattern = /^sha256:[0-9a-f]{64}$/u;
     if (!marker
         || typeof marker !== 'object'
         || Array.isArray(marker)
         || !isDeepStrictEqual(Object.keys(marker).sort(), [
-            'kind', 'schemaVersion', 'sourceIdentity', 'workspaceIdentity',
+            'kind', 'schemaVersion', 'workspaceIdentity',
         ])
         || marker.schemaVersion !== 1
-        || marker.kind !== 'aw-plugin-workspace'
+        || marker.kind !== 'aw-catalog-workspace'
         || typeof marker.workspaceIdentity !== 'string'
-        || !digestPattern.test(marker.workspaceIdentity)
-        || typeof marker.sourceIdentity !== 'string'
-        || !digestPattern.test(marker.sourceIdentity)) {
-        throw new Error('Invalid workspace scaffold marker.');
+        || marker.workspaceIdentity.trim().length === 0) {
+        throw new Error('Invalid Catalog Workspace marker.');
     }
     return { workspaceIdentity: marker.workspaceIdentity };
 }
-async function readWorkspaceOwnershipIdentity(workspaceRoot) {
-    const markerPath = path.join(workspaceRoot, WORKSPACE_MARKER_FILENAME);
-    if (!await fs.pathExists(markerPath))
-        return workspaceIdentity(workspaceRoot);
-    return validateWorkspaceScaffoldMarker(await readRegularJson(markerPath, 'Workspace marker')).workspaceIdentity;
+async function readCatalogWorkspaceMarker(workspaceRoot) {
+    const markerPath = path.join(workspaceRoot, CATALOG_WORKSPACE_MARKER_FILENAME);
+    const marker = validateCatalogWorkspaceMarker(await readRegularJson(markerPath, 'Catalog Workspace marker'));
+    return { markerPath, workspaceIdentity: marker.workspaceIdentity };
 }
 async function readRegularJson(filePath, label) {
     const stat = await fs.lstat(filePath).catch((error) => {
@@ -162,21 +154,24 @@ async function readRegularJson(filePath, label) {
     }
     return fs.readJson(filePath);
 }
-export async function initializePluginWorkspace(options) {
-    const workspaceRoot = await assertDirectoryWithoutSymlinks(options.workspaceRoot, 'Workspace root');
+export async function initializeCatalogWorkspace(options) {
+    const workspaceRoot = await assertDirectoryWithoutSymlinks(options.workspaceRoot, 'Catalog Workspace root');
     const pluginsRoot = path.join(workspaceRoot, 'plugins');
     const metadataPath = path.join(workspaceRoot, MARKETPLACE_SOURCE_PATH);
-    const markerPath = path.join(workspaceRoot, WORKSPACE_MARKER_FILENAME);
-    const metadata = workspaceMetadata(options, workspaceRoot);
+    const markerPath = path.join(workspaceRoot, CATALOG_WORKSPACE_MARKER_FILENAME);
+    const metadata = catalogWorkspaceMetadata(options, workspaceRoot);
     const existingMetadata = await fs.pathExists(metadataPath);
     const existingMarker = await fs.pathExists(markerPath);
     if ((existingMetadata || existingMarker) && !options.force) {
-        throw new Error(`Workspace catalog scaffold already exists: ${workspaceRoot}`);
+        throw new Error(`Catalog Workspace scaffold already exists: ${workspaceRoot}`);
+    }
+    if (existingMetadata && !existingMarker) {
+        throw new Error(`Refusing to adopt Catalog Workspace metadata without a valid marker: ${metadataPath}`);
     }
     if (await fs.pathExists(pluginsRoot)) {
         const stat = await fs.lstat(pluginsRoot);
         if (!stat.isDirectory() || stat.isSymbolicLink()) {
-            throw new Error(`Workspace plugins path must be a regular directory: ${pluginsRoot}`);
+            throw new Error(`Catalog Workspace plugins path must be a regular directory: ${pluginsRoot}`);
         }
         const entries = (await fs.readdir(pluginsRoot)).filter((entry) => entry !== path.basename(metadataPath));
         if (entries.length > 0 && !existingMarker) {
@@ -186,17 +181,18 @@ export async function initializePluginWorkspace(options) {
     if (existingMetadata) {
         const current = await readMarketplaceSourceMeta(workspaceRoot);
         if (!isDeepStrictEqual(current, metadata)) {
-            throw new Error(`Refusing to replace different workspace catalog metadata: ${metadataPath}`);
+            throw new Error(`Refusing to replace different Catalog Workspace metadata: ${metadataPath}`);
         }
     }
-    const expectedMarker = workspaceScaffoldMarker(metadata);
+    const expectedMarker = catalogWorkspaceMarker();
+    let workspaceIdentity = expectedMarker.workspaceIdentity;
     if (existingMarker) {
-        const currentMarker = await readRegularJson(markerPath, 'Workspace marker');
+        const currentMarker = await readRegularJson(markerPath, 'Catalog Workspace marker');
         try {
-            validateWorkspaceScaffoldMarker(currentMarker);
+            workspaceIdentity = validateCatalogWorkspaceMarker(currentMarker).workspaceIdentity;
         }
         catch {
-            throw new Error(`Refusing to replace a workspace scaffold with a different identity: ${workspaceRoot}`);
+            throw new Error(`Refusing to replace a Catalog Workspace marker with a different identity: ${workspaceRoot}`);
         }
     }
     const gitignorePath = path.join(workspaceRoot, '.gitignore');
@@ -205,7 +201,7 @@ export async function initializePluginWorkspace(options) {
     if (gitignoreExists) {
         const stat = await fs.lstat(gitignorePath);
         if (!stat.isFile() || stat.isSymbolicLink()) {
-            throw new Error(`Workspace .gitignore must be a regular file: ${gitignorePath}`);
+            throw new Error(`Catalog Workspace .gitignore must be a regular file: ${gitignorePath}`);
         }
         previousGitignore = await fs.readFile(gitignorePath, 'utf8');
     }
@@ -236,49 +232,82 @@ export async function initializePluginWorkspace(options) {
             await fs.remove(pluginsRoot);
         throw error;
     }
-    return { workspaceRoot, metadataPath, metadata };
+    return { workspaceRoot, markerPath, workspaceIdentity, metadataPath, metadata };
 }
-export async function readPluginWorkspace(workspaceRoot, options = {}) {
-    const root = await assertDirectoryWithoutSymlinks(workspaceRoot, 'Workspace root');
+export async function readCatalogWorkspace(workspaceRoot, options = {}) {
+    const root = await assertDirectoryWithoutSymlinks(workspaceRoot, 'Catalog Workspace root');
+    const marker = await readCatalogWorkspaceMarker(root);
     const metadataPath = path.join(root, MARKETPLACE_SOURCE_PATH);
-    await readRegularJson(metadataPath, 'Workspace catalog metadata');
+    await readRegularJson(metadataPath, 'Catalog Workspace metadata');
     if (!isInside(root, await fs.realpath(metadataPath)))
-        throw new Error('Workspace catalog metadata resolves outside the workspace.');
+        throw new Error('Catalog Workspace metadata resolves outside the workspace.');
     const metadata = await readMarketplaceSourceMeta(root);
-    const pluginsRoot = await assertDirectoryWithoutSymlinks(path.join(root, 'plugins'), 'Workspace plugins directory');
+    const pluginsRoot = await assertDirectoryWithoutSymlinks(path.join(root, 'plugins'), 'Catalog Workspace plugins directory');
     if (!isInside(root, pluginsRoot))
-        throw new Error('Workspace plugins directory resolves outside the workspace.');
+        throw new Error('Catalog Workspace plugins directory resolves outside the workspace.');
     const plugins = [];
     for (const entry of (await fs.readdir(pluginsRoot, { withFileTypes: true })).sort((left, right) => left.name.localeCompare(right.name))) {
         if (entry.name === path.basename(metadataPath) || !entry.isDirectory()) {
             if (entry.isSymbolicLink())
-                throw new Error(`Workspace plugin source must not be a symbolic link: ${entry.name}`);
+                throw new Error(`Catalog Workspace plugin source must not be a symbolic link: ${entry.name}`);
             continue;
         }
         const pluginRoot = path.join(pluginsRoot, entry.name);
         const pluginStat = await fs.lstat(pluginRoot);
         if (!pluginStat.isDirectory() || pluginStat.isSymbolicLink() || !isInside(root, await fs.realpath(pluginRoot))) {
-            throw new Error(`Workspace plugin source must be a regular in-workspace directory: ${pluginRoot}`);
+            throw new Error(`Catalog Workspace plugin source must be a regular in-workspace directory: ${pluginRoot}`);
         }
         const manifestDir = path.join(pluginRoot, path.dirname(SOURCE_MANIFEST_PATH));
         const manifestPath = path.join(pluginRoot, SOURCE_MANIFEST_PATH);
         await assertDirectoryWithoutSymlinks(manifestDir, 'Plugin manifest directory');
         await readRegularJson(manifestPath, 'Plugin manifest');
         if (!isInside(root, await fs.realpath(manifestPath)))
-            throw new Error(`Plugin manifest resolves outside the workspace: ${manifestPath}`);
+            throw new Error(`Plugin manifest resolves outside the Catalog Workspace: ${manifestPath}`);
         const plugin = await readPluginManifest(pluginRoot, { mode: 'source', reservedImports: options.reservedImports });
         if (plugin.manifest.name !== entry.name) {
             throw new Error(`Plugin directory name ${JSON.stringify(entry.name)} must match manifest name ${JSON.stringify(plugin.manifest.name)}.`);
         }
         plugins.push(plugin);
     }
-    return { workspaceRoot: root, metadataPath, metadata, plugins };
+    return {
+        workspaceRoot: root,
+        markerPath: marker.markerPath,
+        workspaceIdentity: marker.workspaceIdentity,
+        metadataPath,
+        metadata,
+        plugins,
+    };
 }
-export async function setWorkspaceCatalogVersion(workspaceRoot, version, options = {}) {
-    const current = await readPluginWorkspace(workspaceRoot, options);
+export function resolveCatalogVersionMutation(currentVersion, mutation) {
+    const current = assertCatalogVersion(currentVersion, 'current catalog version');
+    const hasVersion = mutation.version !== undefined;
+    const hasBump = mutation.bump !== undefined;
+    if (hasVersion === hasBump) {
+        throw new Error('Catalog version mutation requires exactly one of version or bump.');
+    }
+    if (mutation.version !== undefined) {
+        return assertCatalogVersion(mutation.version, 'catalog version');
+    }
+    if (!['major', 'minor', 'patch'].includes(mutation.bump)) {
+        throw new Error('Catalog version bump must be major, minor, or patch.');
+    }
+    const [major, minor, patch] = current.split('-', 1)[0].split('.').map(BigInt);
+    if (mutation.bump === 'major')
+        return `${major + 1n}.0.0`;
+    if (mutation.bump === 'minor')
+        return `${major}.${minor + 1n}.0`;
+    return `${major}.${minor}.${patch + 1n}`;
+}
+export async function mutateCatalogWorkspaceVersion(workspaceRoot, mutation, options = {}) {
+    const current = await readCatalogWorkspace(workspaceRoot, options);
+    const version = resolveCatalogVersionMutation(current.metadata.catalog.version, mutation);
+    if (version === current.metadata.catalog.version)
+        return current.metadata;
     const metadata = {
         ...current.metadata,
-        catalog: { version: assertCatalogVersion(version, 'catalog version') },
+        catalog: {
+            version,
+        },
     };
     await writeJsonAtomic(current.metadataPath, metadata);
     return metadata;
@@ -481,21 +510,21 @@ function normalizeCatalogRelease(raw, catalogVersion) {
         contentDigest: release.contentDigest,
     };
 }
-export async function buildWorkspaceCatalog(options) {
-    const workspace = await readPluginWorkspace(options.workspaceRoot, { reservedImports: options.reservedImports });
-    const plugins = orderPlugins(workspace.plugins);
-    const resolved = await resolveWorkspaceOutputPath({
-        workspaceRoot: workspace.workspaceRoot,
+export async function buildCatalogWorkspace(options) {
+    const catalogWorkspace = await readCatalogWorkspace(options.workspaceRoot, { reservedImports: options.reservedImports });
+    const plugins = orderPlugins(catalogWorkspace.plugins);
+    const resolved = await resolveCatalogWorkspaceOutputPath({
+        workspaceRoot: catalogWorkspace.workspaceRoot,
         outputPath: options.outputPath ?? DEFAULT_CATALOG_OUTPUT_PATH,
         kind: 'catalog',
     });
-    const catalogVersion = workspace.metadata.catalog.version;
+    const catalogVersion = catalogWorkspace.metadata.catalog.version;
     const channel = deriveCatalogChannel(catalogVersion);
     const pluginNames = plugins.map((plugin) => plugin.manifest.name).sort();
-    const identity = sourceIdentity(workspace.metadata, plugins);
+    const identity = sourceIdentity(catalogWorkspace.metadata, plugins);
     const marker = generatedOutputMarker({
         kind: 'catalog',
-        workspaceIdentity: await readWorkspaceOwnershipIdentity(workspace.workspaceRoot),
+        workspaceIdentity: catalogWorkspace.workspaceIdentity,
         sourceIdentity: identity,
     });
     await replaceGeneratedOutput({
@@ -508,7 +537,7 @@ export async function buildWorkspaceCatalog(options) {
                 const outputRoot = path.join(stagingRoot, 'plugins', plugin.manifest.name);
                 await fs.ensureDir(outputRoot);
                 await options.adapter.build({
-                    workspaceRoot: workspace.workspaceRoot,
+                    workspaceRoot: catalogWorkspace.workspaceRoot,
                     plugin,
                     plugins,
                     dependencies: closure.slice(0, -1),
@@ -519,8 +548,8 @@ export async function buildWorkspaceCatalog(options) {
             const byPlatform = (platform) => bundledPlugins
                 .filter((plugin) => resolveSupportedPlatforms(plugin.manifest).has(platform))
                 .sort((left, right) => left.manifest.name.localeCompare(right.manifest.name));
-            await fs.outputJson(path.join(stagingRoot, '.agents', 'plugins', 'marketplace.json'), createMarketplaceManifest(workspace.metadata, byPlatform('codex')), { spaces: 2 });
-            await fs.outputJson(path.join(stagingRoot, '.claude-plugin', 'marketplace.json'), createMarketplaceManifest(workspace.metadata, byPlatform('claude')), { spaces: 2 });
+            await fs.outputJson(path.join(stagingRoot, '.agents', 'plugins', 'marketplace.json'), createMarketplaceManifest(catalogWorkspace.metadata, byPlatform('codex')), { spaces: 2 });
+            await fs.outputJson(path.join(stagingRoot, '.claude-plugin', 'marketplace.json'), createMarketplaceManifest(catalogWorkspace.metadata, byPlatform('claude')), { spaces: 2 });
             let minVersion = '0.0.0';
             for (const plugin of bundledPlugins) {
                 const candidate = plugin.manifest.compatibility.aw.minVersion;
@@ -536,8 +565,8 @@ export async function buildWorkspaceCatalog(options) {
                 channel,
                 compatibility: { aw: { minVersion } },
                 marketplace: {
-                    owner: workspace.metadata.owner,
-                    interface: workspace.metadata.interface,
+                    owner: catalogWorkspace.metadata.owner,
+                    interface: catalogWorkspace.metadata.interface,
                 },
                 release: { state: 'development' },
                 entries,
@@ -578,15 +607,15 @@ export async function validatePublishedCatalogSnapshot(snapshotDirectory) {
         throw new Error('Published Catalog snapshot must include a plugin release ledger.');
     return { ...validation, ledger: validation.ledger };
 }
-export async function preparePublishedWorkspaceCatalog(options) {
+export async function preparePublishedCatalogWorkspace(options) {
     if (!/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u.test(options.sourceHead)) {
         throw new Error('Published Catalog sourceHead must be a committed Git object ID.');
     }
-    const workspace = await readPluginWorkspace(options.workspaceRoot, { reservedImports: options.reservedImports });
-    for (const plugin of workspace.plugins) {
+    const catalogWorkspace = await readCatalogWorkspace(options.workspaceRoot, { reservedImports: options.reservedImports });
+    for (const plugin of catalogWorkspace.plugins) {
         assertStablePluginVersion(plugin.manifest.version, `${plugin.manifest.name} source version`);
     }
-    const catalogVersion = workspace.metadata.catalog.version;
+    const catalogVersion = catalogWorkspace.metadata.catalog.version;
     const channel = deriveCatalogChannel(catalogVersion);
     const previous = options.previousSnapshotRoot
         ? await validatePublishedCatalogSnapshot(options.previousSnapshotRoot)
@@ -601,10 +630,10 @@ export async function preparePublishedWorkspaceCatalog(options) {
     const temporaryRelative = path.join('.aw', 'publish', `.catalog-preparation-${crypto.randomUUID()}`);
     const finalRelative = options.outputPath
         ?? `${DEFAULT_PUBLISHED_CATALOG_OUTPUT_PATH}-v${catalogVersion}`;
-    let temporaryRoot = path.resolve(workspace.workspaceRoot, temporaryRelative);
+    let temporaryRoot = path.resolve(catalogWorkspace.workspaceRoot, temporaryRelative);
     try {
-        const built = await buildWorkspaceCatalog({
-            workspaceRoot: workspace.workspaceRoot,
+        const built = await buildCatalogWorkspace({
+            workspaceRoot: catalogWorkspace.workspaceRoot,
             outputPath: temporaryRelative,
             adapter: options.adapter,
             reservedImports: options.reservedImports,
@@ -614,17 +643,19 @@ export async function preparePublishedWorkspaceCatalog(options) {
         const contentDigests = new Map(development.manifest.entries.map((entry) => [entry.name, entry.contentDigest]));
         const overrides = channel === 'beta'
             ? resolveBetaPluginVersionOverrides({
-                plugins: workspace.plugins,
+                plugins: catalogWorkspace.plugins,
                 contentDigests,
                 ledger: previousLedger,
             })
-            : Object.fromEntries(workspace.plugins.map((plugin) => [plugin.manifest.name, plugin.manifest.version]));
+            : Object.fromEntries(catalogWorkspace.plugins.map((plugin) => [plugin.manifest.name, plugin.manifest.version]));
         await rewritePublishedPluginVersions(temporaryRoot, overrides);
-        const bundledPlugins = await Promise.all(workspace.plugins.map((plugin) => readPluginManifest(path.join(temporaryRoot, 'plugins', plugin.manifest.name), { mode: 'bundle' })));
+        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))
             .map((plugin) => expectedCatalogEntry(plugin, plugin.rootDir)));
         const manifestWithoutRelease = {
             ...development.manifest,
+            catalogVersion,
+            channel,
             entries,
         };
         const contentDigest = publishedContentDigest(manifestWithoutRelease);
@@ -648,8 +679,8 @@ export async function preparePublishedWorkspaceCatalog(options) {
             fs.writeFile(path.join(temporaryRoot, PLUGIN_RELEASE_LEDGER_FILENAME), `${JSON.stringify(ledger, null, 2)}\n`),
         ]);
         const prepared = await validatePublishedCatalogSnapshot(temporaryRoot);
-        const resolved = await resolveWorkspaceOutputPath({
-            workspaceRoot: workspace.workspaceRoot,
+        const resolved = await resolveCatalogWorkspaceOutputPath({
+            workspaceRoot: catalogWorkspace.workspaceRoot,
             outputPath: finalRelative,
             kind: 'catalog',
         });
@@ -697,27 +728,27 @@ function dependencyClosure(plugin, all) {
     visit(plugin);
     return result;
 }
-export async function buildWorkspacePlugin(options) {
-    const workspace = await readPluginWorkspace(options.workspaceRoot, { reservedImports: options.reservedImports });
-    assertDependencyGraph(workspace.plugins);
-    const requestedPluginRoot = path.resolve(workspace.workspaceRoot, options.pluginDirectory);
+export async function buildCatalogWorkspacePlugin(options) {
+    const catalogWorkspace = await readCatalogWorkspace(options.workspaceRoot, { reservedImports: options.reservedImports });
+    assertDependencyGraph(catalogWorkspace.plugins);
+    const requestedPluginRoot = path.resolve(catalogWorkspace.workspaceRoot, options.pluginDirectory);
     const pluginRoot = await fs.realpath(requestedPluginRoot);
-    if (!isInside(workspace.workspaceRoot, pluginRoot))
-        throw new Error('Plugin directory must stay inside the workspace.');
-    const plugin = workspace.plugins.find((entry) => entry.rootDir === pluginRoot);
+    if (!isInside(catalogWorkspace.workspaceRoot, pluginRoot))
+        throw new Error('Plugin directory must stay inside the Catalog Workspace.');
+    const plugin = catalogWorkspace.plugins.find((entry) => entry.rootDir === pluginRoot);
     if (!plugin) {
-        throw new Error(`Plugin directory is not part of this workspace source: ${pluginRoot}`);
+        throw new Error(`Plugin directory is not part of this Catalog Workspace source: ${pluginRoot}`);
     }
-    const closure = dependencyClosure(plugin, workspace.plugins);
+    const closure = dependencyClosure(plugin, catalogWorkspace.plugins);
     const identity = sha256(normalizeManifestDigestInput(plugin.manifest));
     const marker = generatedOutputMarker({
         kind: 'plugin',
-        workspaceIdentity: await readWorkspaceOwnershipIdentity(workspace.workspaceRoot),
+        workspaceIdentity: catalogWorkspace.workspaceIdentity,
         sourceIdentity: identity,
         sourceName: plugin.manifest.name,
     });
-    const resolved = await resolveWorkspaceOutputPath({
-        workspaceRoot: workspace.workspaceRoot,
+    const resolved = await resolveCatalogWorkspaceOutputPath({
+        workspaceRoot: catalogWorkspace.workspaceRoot,
         outputPath: options.outputPath ?? path.join(DEFAULT_PLUGIN_OUTPUT_PATH, plugin.manifest.name),
         kind: 'plugin',
     });
@@ -725,9 +756,9 @@ export async function buildWorkspacePlugin(options) {
         outputRoot: resolved.outputRoot,
         force: options.force === true,
         build: (stagingRoot) => options.adapter.build({
-            workspaceRoot: workspace.workspaceRoot,
+            workspaceRoot: catalogWorkspace.workspaceRoot,
             plugin,
-            plugins: workspace.plugins,
+            plugins: catalogWorkspace.plugins,
             dependencies: closure.slice(0, -1),
             outputRoot: stagingRoot,
         }).then(() => fs.writeJson(path.join(stagingRoot, GENERATED_OUTPUT_MARKER_FILENAME), marker, { spaces: 2 })),
@@ -765,7 +796,7 @@ async function assertGeneratedOutput(root, expected) {
     if (!isDeepStrictEqual(Object.keys(marker).sort(), expectedKeys)
         || marker.schemaVersion !== 1
         || typeof marker.workspaceIdentity !== 'string'
-        || !digestPattern.test(marker.workspaceIdentity)
+        || marker.workspaceIdentity.trim().length === 0
         || typeof marker.sourceIdentity !== 'string'
         || !digestPattern.test(marker.sourceIdentity)) {
         throw new Error(`Refusing to replace foreign plugin output: ${root}`);
@@ -823,7 +854,7 @@ export async function validateCatalogSnapshot(snapshotDirectory) {
             || marker.schemaVersion !== 1
             || marker.kind !== 'catalog'
             || typeof marker.workspaceIdentity !== 'string'
-            || !digestPattern.test(marker.workspaceIdentity)
+            || marker.workspaceIdentity.trim().length === 0
             || typeof marker.sourceIdentity !== 'string'
             || !digestPattern.test(marker.sourceIdentity)) {
             throw new Error('Invalid catalog generated output marker.');