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

package/dist/types.d.ts

@@ -1,4 +1,5 @@
-import type { PluginManifestSourceV1 } from './generated/plugin-manifest-v1.js';
+import type { PluginManifestSourceV3 } from './generated/plugin-manifest-v3.js';
+import type { ManagedCommands, ManagedCommandPermission, PermissionCommand } from './managed-commands.js';
 export type PlatformName = 'codex' | 'claude';
 export type DistributionName = 'agent-skills';
 export type Scope = 'project' | 'user';
@@ -10,7 +11,7 @@ export type CatalogSourceId = string;
 export type SourceIdentity = string;
 export type SupportedPlatformSet = ReadonlySet<PlatformName>;
 export type CodexProjectManagedKind = 'skill' | 'mcpServer' | 'instruction' | 'permission' | 'hook' | 'agent';
-export type PluginInterfaceMeta = NonNullable<PluginManifestSourceV1['interface']>;
+export type PluginInterfaceMeta = NonNullable<PluginManifestSourceV3['interface']>;
 export interface MarketplaceOwner {
     name: string;
     url: string;
@@ -25,9 +26,9 @@ export interface MarketplaceSourceMeta {
         version: string;
     };
 }
-export type MarketplacePolicy = PluginManifestSourceV1['marketplace']['policy'];
+export type MarketplacePolicy = PluginManifestSourceV3['marketplace']['policy'];
 export type MarketplaceAuthenticationPolicy = MarketplacePolicy['authentication'];
-export type PluginMarketplaceMeta = PluginManifestSourceV1['marketplace'];
+export type PluginMarketplaceMeta = PluginManifestSourceV3['marketplace'];
 export type TemplateValue = string | boolean;
 export interface TemplateVarByPlatform {
     claude: TemplateValue;
@@ -55,6 +56,11 @@ export interface BuildConfigManifestOverrides {
 export interface BuildConfigRuntimeExport {
     name: string;
     source: string;
+    requires: {
+        aw: {
+            capabilities: string[];
+        };
+    };
 }
 export interface BuildConfigImportReference {
     plugin: string;
@@ -86,18 +92,10 @@ export interface BuildConfig {
     skillRuntimeFiles?: BuildConfigSkillRuntimeFile[];
     generatedSkillRuntimeFiles?: BuildConfigGeneratedSkillRuntimeFile[];
 }
-export type PluginLifecycleEvent = 'install' | 'upgrade' | 'uninstall';
-export type PluginLifecycleOsSelector = 'default' | 'unix' | 'windows' | 'linux' | 'darwin' | 'win32';
-export type PluginLifecycleRuntimeOs = 'linux' | 'darwin' | 'win32';
-export type PluginLifecycleScriptRunner = 'node' | 'sh' | 'bash' | 'pwsh' | 'powershell' | 'cmd' | 'auto';
-export interface PluginLifecycleScriptEntry {
-    runner: PluginLifecycleScriptRunner;
+export interface PluginPreApplyScript {
     path: string;
-    args?: string[];
+    timeoutMs?: number;
 }
-export type PluginLifecycleScriptSelector = Partial<Record<PluginLifecycleOsSelector, PluginLifecycleScriptEntry>>;
-export type PluginLifecycleScriptDefinition = string | PluginLifecycleScriptSelector;
-export type PluginLifecycleScripts = Partial<Record<PluginLifecycleEvent, PluginLifecycleScriptSelector>>;
 export interface PluginScriptHelpersConfig {
     config: string;
 }
@@ -122,26 +120,159 @@ export interface PluginArtifactScriptsConfig {
     render?: PluginArtifactRenderScriptEntry;
 }
 export interface PluginScriptsConfig {
-    timeoutMs?: number;
-    lifecycle?: PluginLifecycleScripts;
+    preApply?: PluginPreApplyScript;
     helpers?: PluginScriptHelpersConfig;
     node?: PluginNodeScriptsConfig;
     artifacts?: PluginArtifactScriptsConfig;
     tests?: PluginScriptTestsConfig;
 }
-export type PluginConfigFieldType = 'string' | 'number' | 'boolean' | 'enum' | 'file' | 'directory';
-export interface PluginConfigSchemaField {
-    type: PluginConfigFieldType;
+export type PluginConfigScalar = string | number | boolean;
+export type PluginConfigScalarArray = string[] | number[] | boolean[];
+export type PluginConfigScalarObject = Record<string, PluginConfigScalar>;
+export type PluginConfigObject = Record<string, PluginConfigScalar | PluginConfigScalarArray | PluginConfigScalarObject>;
+export type PluginConfigArray = PluginConfigScalarArray | PluginConfigObject[];
+export type PluginConfigValue = PluginConfigScalar | PluginConfigObject | PluginConfigArray;
+export type PluginConfigFieldType = 'string' | 'number' | 'boolean' | 'object' | 'array';
+export type PluginConfigStringFormat = 'identifier' | 'slug' | 'semver' | 'url' | 'hostname' | 'email';
+export interface PluginConfigPreset<Value extends PluginConfigValue = PluginConfigValue> {
+    id: string;
+    title: string;
+    description?: string;
+    value: Value;
+    recommended?: true;
+}
+export interface PluginConfigChoices<Value extends PluginConfigValue = PluginConfigValue> {
+    allowCustom: boolean;
+    presets: PluginConfigPreset<Value>[];
+}
+export interface PluginConfigStringValidation {
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: PluginConfigStringFormat;
+}
+export interface PluginConfigNumberValidation {
+    integer?: boolean;
+    minimum?: number;
+    maximum?: number;
+    multipleOf?: number;
+}
+export interface PluginConfigObjectValidation {
+    minProperties?: number;
+    maxProperties?: number;
+    key?: PluginConfigStringValidation;
+}
+export interface PluginConfigArrayValidation {
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    uniqueBy?: string;
+}
+export interface PluginConfigValueReference {
+    field: string;
+    key: string;
+    label?: string;
+    include?: PluginConfigScalar[];
+}
+export interface PluginConfigFieldBase<Value extends PluginConfigValue> {
     title?: string;
     description?: string;
-    default?: string | number | boolean;
+    default?: Value;
     required?: boolean;
-    sensitive?: boolean;
-    values?: string[];
-    min?: number;
-    max?: number;
+    sensitive?: never;
+}
+interface PluginConfigPlainStringField extends Omit<PluginConfigFieldBase<string>, 'sensitive'> {
+    type: 'string';
+    const?: string;
+    sensitive?: false;
+    valueRef?: PluginConfigValueReference;
+    choices?: PluginConfigChoices<string>;
+    validation?: PluginConfigStringValidation;
+}
+interface PluginConfigSensitiveStringField extends Omit<PluginConfigFieldBase<string>, 'default' | 'sensitive'> {
+    type: 'string';
+    sensitive: true;
+    default?: never;
+    choices?: never;
+    const?: never;
+    validation?: PluginConfigStringValidation;
+}
+export type PluginConfigStringField = PluginConfigPlainStringField | PluginConfigSensitiveStringField;
+export interface PluginConfigNumberField extends PluginConfigFieldBase<number> {
+    type: 'number';
+    const?: number;
+    valueRef?: PluginConfigValueReference;
+    choices?: PluginConfigChoices<number>;
+    validation?: PluginConfigNumberValidation;
+}
+export interface PluginConfigBooleanField extends PluginConfigFieldBase<boolean> {
+    type: 'boolean';
+    const?: boolean;
+    valueRef?: PluginConfigValueReference;
+    choices?: PluginConfigChoices<boolean>;
+}
+export type PluginConfigScalarField = PluginConfigStringField | PluginConfigNumberField | PluginConfigBooleanField;
+type DistributiveOmit<Value, Key extends PropertyKey> = Value extends unknown ? Omit<Value, Key> : never;
+type PluginConfigNonSensitiveScalarField = PluginConfigPlainStringField | PluginConfigNumberField | PluginConfigBooleanField;
+export type PluginConfigScalarPropertyField = DistributiveOmit<PluginConfigNonSensitiveScalarField, 'default' | 'sensitive'> & {
+    sensitive?: never;
+};
+export interface PluginConfigLeafArrayField extends Omit<PluginConfigFieldBase<PluginConfigScalarArray>, 'default'> {
+    type: 'array';
+    items: PluginConfigAdditionalPropertiesField;
+    choices?: PluginConfigChoices<PluginConfigScalarArray>;
+    validation?: Omit<PluginConfigArrayValidation, 'uniqueBy'>;
+}
+export interface PluginConfigLeafObjectField extends Omit<PluginConfigFieldBase<PluginConfigScalarObject>, 'default'> {
+    type: 'object';
+    properties?: never;
+    additionalProperties: PluginConfigAdditionalPropertiesField;
+    choices?: PluginConfigChoices<PluginConfigScalarObject>;
+    validation?: PluginConfigObjectValidation;
+}
+export type PluginConfigObjectPropertyField = PluginConfigScalarPropertyField | PluginConfigLeafArrayField | PluginConfigLeafObjectField;
+export type PluginConfigAdditionalPropertiesField = DistributiveOmit<PluginConfigNonSensitiveScalarField, 'default' | 'required' | 'sensitive'> & {
+    sensitive?: never;
+};
+interface PluginConfigObjectFieldBase extends PluginConfigFieldBase<PluginConfigObject> {
+    type: 'object';
+    choices?: PluginConfigChoices<PluginConfigObject>;
+    validation?: PluginConfigObjectValidation;
+}
+export interface PluginConfigFixedObjectField extends PluginConfigObjectFieldBase {
+    properties: Record<string, PluginConfigObjectPropertyField>;
+    additionalProperties?: false;
+    variants?: PluginConfigObjectVariants;
+}
+export interface PluginConfigObjectVariant {
+    properties: Record<string, PluginConfigObjectPropertyField>;
+}
+export interface PluginConfigObjectVariants {
+    discriminator: string;
+    cases: Record<string, PluginConfigObjectVariant>;
+    missing?: string;
+    otherwise?: PluginConfigObjectVariant;
+}
+export interface PluginConfigKeyValueObjectField extends PluginConfigObjectFieldBase {
+    default?: PluginConfigScalarObject;
+    choices?: PluginConfigChoices<PluginConfigScalarObject>;
+    properties?: never;
+    variants?: never;
+    additionalProperties: PluginConfigAdditionalPropertiesField;
+}
+export type PluginConfigObjectField = PluginConfigFixedObjectField | PluginConfigKeyValueObjectField;
+export type PluginConfigArrayItemField = DistributiveOmit<PluginConfigNonSensitiveScalarField | PluginConfigObjectField, 'default' | 'required' | 'sensitive'> & {
+    default?: never;
+    required?: never;
+    sensitive?: never;
+};
+export interface PluginConfigArrayField extends PluginConfigFieldBase<PluginConfigArray> {
+    type: 'array';
+    items: PluginConfigArrayItemField;
+    choices?: PluginConfigChoices<PluginConfigArray>;
+    validation?: PluginConfigArrayValidation;
 }
-export type PluginConfigPresentationValue = string | number | boolean;
+export type PluginConfigSchemaField = PluginConfigScalarField | PluginConfigObjectField | PluginConfigArrayField;
 export interface PluginConfigPresentationGroup {
     id: string;
     title: string;
@@ -149,27 +280,69 @@ export interface PluginConfigPresentationGroup {
     fields: string[];
     advanced?: boolean;
 }
-export interface PluginConfigPresentationField {
-    valueLabels?: Record<string, string>;
-    recommendedValue?: PluginConfigPresentationValue;
-    placeholder?: string;
-    unit?: string;
-    advanced?: boolean;
-}
-export interface PluginConfigPresentationPreset {
-    id: string;
-    title: string;
-    description?: string;
-    values: Record<string, PluginConfigPresentationValue>;
+export interface PluginConfigJoinSummary {
+    kind: 'join';
+    parts: Array<{
+        path: string;
+        format?: 'raw' | 'choiceTitle';
+    }>;
+    separator: string;
+    missing: string;
 }
 export interface PluginConfigPresentation {
+    summaries?: Record<string, PluginConfigJoinSummary>;
+    fieldViews?: Record<string, {
+        summary: string;
+        itemSummary?: never;
+    } | {
+        itemSummary: string;
+        summary?: never;
+    }>;
     groups?: PluginConfigPresentationGroup[];
-    fields?: Record<string, PluginConfigPresentationField>;
-    presets?: PluginConfigPresentationPreset[];
 }
-export interface PluginConfigSchema {
-    schema: Record<string, PluginConfigSchemaField>;
+type PluginConfigLegacyScalarField = DistributiveOmit<PluginConfigScalarField, 'const'>;
+type PluginConfigLegacyScalarPropertyField = DistributiveOmit<PluginConfigScalarPropertyField, 'const'>;
+type PluginConfigLegacyAdditionalPropertiesField = DistributiveOmit<PluginConfigAdditionalPropertiesField, 'const'>;
+type PluginConfigLegacyObjectField = (Omit<PluginConfigFixedObjectField, 'properties' | 'variants' | 'default' | 'choices'> & {
+    properties: Record<string, PluginConfigLegacyScalarPropertyField>;
+    default?: PluginConfigScalarObject;
+    choices?: PluginConfigChoices<PluginConfigScalarObject>;
+}) | (Omit<PluginConfigKeyValueObjectField, 'additionalProperties'> & {
+    additionalProperties: PluginConfigLegacyAdditionalPropertiesField;
+});
+type PluginConfigLegacyArray = PluginConfigScalarArray | PluginConfigScalarObject[];
+type PluginConfigLegacyArrayField = Omit<PluginConfigArrayField, 'default' | 'choices' | 'items'> & {
+    default?: PluginConfigLegacyArray;
+    choices?: PluginConfigChoices<PluginConfigLegacyArray>;
+    items: DistributiveOmit<PluginConfigLegacyScalarField | PluginConfigLegacyObjectField, 'default' | 'required' | 'sensitive'> & {
+        default?: never;
+        required?: never;
+        sensitive?: never;
+    };
+};
+export type PluginConfigDefinition = {
+    schemaVersion?: never;
+    fields: Record<string, PluginConfigLegacyScalarField | PluginConfigLegacyObjectField>;
+    presentation?: Pick<PluginConfigPresentation, 'groups'>;
+} | {
+    schemaVersion: 3;
+    fields: Record<string, PluginConfigLegacyScalarField | PluginConfigLegacyObjectField | PluginConfigLegacyArrayField>;
+    presentation?: PluginConfigPresentation;
+} | {
+    schemaVersion: 4;
+    fields: Record<string, PluginConfigSchemaField>;
     presentation?: PluginConfigPresentation;
+};
+export type PluginConfigSchema = PluginConfigDefinition;
+export interface PluginConfigValidationIssue {
+    code: string;
+    path: {
+        field: string;
+        property?: string;
+        segments?: Array<string | number>;
+    };
+    message: string;
+    recoverable: true;
 }
 export interface PlatformAgentOverrides<T> {
     claude?: Partial<T> | null;
@@ -189,15 +362,17 @@ export interface InstructionDefinition {
 }
 export interface PermissionDefinition {
     name: string;
-    allow?: string[];
-    ask?: string[];
-    deny?: string[];
-    agentOverrides?: PlatformAgentOverrides<{
-        name: string;
-        allow?: string[];
-        ask?: string[];
-        deny?: string[];
-    }>;
+    allow?: PermissionCommand[];
+    ask?: PermissionCommand[];
+    deny?: PermissionCommand[];
+    /** Present after resolving the Claude override; source declarations use agentOverrides.claude. */
+    sandbox?: {
+        excludedCommands: ManagedCommandPermission[];
+    };
+    agentOverrides?: {
+        claude?: Partial<Omit<PermissionDefinition, 'agentOverrides'>> | null;
+        codex?: Partial<Omit<PermissionDefinition, 'agentOverrides' | 'sandbox'>> | null;
+    };
 }
 export type HookEvent = 'before_tool' | 'after_tool' | 'session_start';
 export interface HookDefinition {
@@ -239,8 +414,17 @@ export interface PluginExtensions {
     agents?: AgentDefinition[];
 }
 export type ArtifactState = 'present' | 'disabled';
-export type ArtifactTarget = 'codex.developerInstructionsBlock' | 'codex.agentRole' | 'codex.skill' | 'claude.skill' | 'agent-skills.skill';
-export type DynamicArtifactKind = 'instruction' | 'codexRole' | 'skill';
+export interface CodexNativeSkillDelivery {
+    mode: 'codex-native';
+    identity: 'shared';
+    renderProfile: 'user';
+}
+export interface AwExtensionSkillDelivery {
+    mode: 'aw-extension';
+}
+export type CodexSkillDelivery = CodexNativeSkillDelivery | AwExtensionSkillDelivery;
+export type ArtifactTarget = 'codex.developerInstructionsBlock' | 'codex.agentRole' | 'codex.skill' | 'claude.skill' | 'agent-skills.skill' | 'aw.command-set' | 'aw.command-package';
+export type DynamicArtifactKind = 'instruction' | 'codexRole' | 'skill' | 'commandSet' | 'commandPackage';
 export type ManagedArtifactId = string;
 export interface ArtifactRuntimeImportDefinition extends BuildConfigImportReference {
     name: string;
@@ -250,15 +434,16 @@ export interface ArtifactRuntimeImportDefinition extends BuildConfigImportRefere
         providerPluginId: PluginId;
         providerVersion: PluginVersion;
         source: string;
+        requiredCapabilities: string[];
+        capabilitySetDigest: string;
     };
 }
-export interface PluginArtifactTargetDefinition {
+interface PluginArtifactTargetDefinitionBase {
     id: string;
     platform?: PlatformName;
     distribution?: DistributionName;
     scopes: Scope[];
-    target: ArtifactTarget;
-    kind?: DynamicArtifactKind;
+    kind?: Exclude<DynamicArtifactKind, 'commandSet' | 'commandPackage'>;
     projectManagedKind?: CodexProjectManagedKind;
     states: ArtifactState[];
     refreshKeys: string[];
@@ -267,7 +452,15 @@ export interface PluginArtifactTargetDefinition {
     skillKey?: string;
     sourceDirs?: string[];
     runtimeImports?: ArtifactRuntimeImportDefinition[];
+    runtimeConfig?: import('./runtime-config.js').PluginRuntimeConfigDeclaration;
 }
+export type PluginArtifactTargetDefinition = PluginArtifactTargetDefinitionBase & {
+    target: 'codex.skill';
+    delivery: CodexSkillDelivery;
+} | PluginArtifactTargetDefinitionBase & {
+    target: Exclude<ArtifactTarget, 'codex.skill' | 'aw.command-set' | 'aw.command-package'>;
+    delivery?: never;
+};
 export interface PluginArtifactsConfig {
     targets?: PluginArtifactTargetDefinition[];
 }
@@ -277,24 +470,26 @@ export interface PluginAgentSkillsDistribution {
 export interface PluginDistributionsConfig {
     agentSkills?: PluginAgentSkillsDistribution;
 }
-export interface PluginCompatibility {
+export interface PluginRequirements {
     aw: {
-        minVersion: CliVersion;
+        capabilities?: string[];
     };
 }
-export type PluginManifestSource = PluginManifestSourceV1;
-export type NormalizedPluginManifest = Omit<PluginManifestSourceV1, 'schemaVersion' | 'compatibility' | 'extensions' | 'artifacts' | 'buildConfig' | 'scripts' | 'config'> & {
-    schemaVersion: 1;
-    compatibility: PluginCompatibility;
+export type PluginManifestSource = PluginManifestSourceV3;
+export type NormalizedPluginManifest = Omit<PluginManifestSourceV3, 'requires' | 'extensions' | 'artifacts' | 'buildConfig' | 'scripts' | 'config' | 'managedCommands' | 'nativeTools'> & {
+    requires?: PluginRequirements;
     extensions?: PluginExtensions;
     artifacts?: PluginArtifactsConfig;
     buildConfig?: BuildConfig;
     scripts?: PluginScriptsConfig;
     config?: PluginConfigSchema;
+    managedCommands?: ManagedCommands;
+    nativeTools?: import('./native-tools.js').NativeTools;
 };
 export interface PluginMeta {
     sourceId?: CatalogSourceId;
     sourceIdentity?: SourceIdentity;
+    catalogLogicalIdentity?: string;
     pluginId?: PluginId;
     marketplaceName?: string;
     rootDir: string;
@@ -326,12 +521,13 @@ export interface CatalogManifestEntry {
     tags?: string[];
     strict: boolean;
     policy: MarketplacePolicy;
-    compatibility: PluginCompatibility;
+    dependencies: PluginId[];
+    requires: PluginRequirements;
     source: string;
     artifactDigest: string;
     manifestDigest: string;
 }
-export interface CatalogManifestV4Entry extends CatalogManifestEntry {
+export interface CatalogManifestV7Entry extends CatalogManifestEntry {
     name: PluginId;
     contentDigest: string;
 }
@@ -339,29 +535,25 @@ export interface CatalogMarketplaceIdentity {
     owner: MarketplaceOwner;
     interface: MarketplaceInterfaceMeta;
 }
-export type CatalogManifestV4Release = {
+export type CatalogManifestV7Release = {
     state: 'development';
 } | {
     state: 'published';
-    targetVersion: string;
-    planId: string;
     sourceHead: string;
-    contentDigest: string;
 };
-export interface CatalogManifestV4 {
-    schemaVersion: 4;
+export interface CatalogManifestV7 {
+    schemaVersion: 7;
     catalogVersion: string;
     channel: CatalogChannel;
-    compatibility: PluginCompatibility;
+    requires: PluginRequirements;
     marketplace: CatalogMarketplaceIdentity;
-    release: CatalogManifestV4Release;
-    entries: CatalogManifestV4Entry[];
+    release: CatalogManifestV7Release;
+    entries: CatalogManifestV7Entry[];
 }
 export interface PlatformPluginManifest {
     name: string;
     version: PluginVersion;
     description: string;
-    compatibility: PluginCompatibility;
     skills?: string;
     mcpServers?: string;
     apps?: string;
@@ -426,3 +618,4 @@ export interface ClaudeSkillArtifact extends ArtifactPlanArtifactBase {
         files?: Record<string, string>;
     };
 }
+export {};

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, CatalogManifestV4, MarketplaceSourceMeta, PluginMeta } from './types.js';
+import type { CatalogChannel, CatalogManifestV7, CatalogManifestV7Entry, 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;
@@ -61,6 +64,7 @@ export declare function readCatalogWorkspace(workspaceRoot: string, options?: Ca
 export declare function resolveCatalogVersionMutation(currentVersion: string, mutation: CatalogVersionMutation): string;
 export declare function mutateCatalogWorkspaceVersion(workspaceRoot: string, mutation: CatalogVersionMutation, options?: CatalogWorkspaceSourceOptions): Promise<MarketplaceSourceMeta>;
 export declare function deriveCatalogChannel(version: string): CatalogChannel;
+export declare function calculateCatalogWorkspaceSourceIdentity(workspace: Pick<CatalogWorkspace, 'workspaceRoot' | 'metadataPath' | 'plugins'>): Promise<string>;
 export declare function buildCatalogWorkspace(options: {
     workspaceRoot: string;
     outputPath?: string;
@@ -73,10 +77,21 @@ export declare function buildCatalogWorkspace(options: {
     channel: CatalogChannel;
     pluginNames: string[];
 }>;
+/**
+ * Assign versions for planning and snapshot preparation with the same content comparison.
+ * Official history includes removed Plugins. Baseline declarations come from main source,
+ * before generated candidate metadata changes.
+ */
+export declare function resolvePublishedPluginVersions(options: {
+    channel: CatalogChannel;
+    entries: readonly Pick<CatalogManifestV7Entry, 'name' | 'version' | 'contentDigest'>[];
+    previousPluginEntries?: readonly CatalogManifestV7Entry[];
+    officialPluginHistory?: readonly CatalogManifestV7Entry[];
+    sourcePluginVersionsAtBaseline?: Readonly<Record<string, string>>;
+}): Record<string, string>;
 export declare function validatePublishedCatalogSnapshot(snapshotDirectory: string): Promise<{
     rootDir: string;
-    manifest: CatalogManifestV4;
-    ledger: PluginReleaseLedger;
+    manifest: CatalogManifestV7;
     snapshotDigest: string;
 }>;
 export declare function preparePublishedCatalogWorkspace(options: {
@@ -84,6 +99,9 @@ export declare function preparePublishedCatalogWorkspace(options: {
     sourceHead: string;
     outputPath?: string;
     previousSnapshotRoot?: string;
+    historicalPluginEntries?: readonly CatalogManifestV7Entry[];
+    officialPluginHistory?: readonly CatalogManifestV7Entry[];
+    sourcePluginVersionsAtBaseline?: Readonly<Record<string, string>>;
     adapter: CatalogWorkspaceBuildAdapter;
     reservedImports?: ReservedImportRegistry;
 }): Promise<{
@@ -92,8 +110,6 @@ export declare function preparePublishedCatalogWorkspace(options: {
     channel: CatalogChannel;
     pluginNames: string[];
     snapshotDigest: string;
-    contentDigest: string;
-    planId: string;
 }>;
 export declare function buildCatalogWorkspacePlugin(options: {
     workspaceRoot: string;
@@ -108,9 +124,21 @@ export declare function buildCatalogWorkspacePlugin(options: {
     dependencies: string[];
     digest: string;
 }>;
-export declare function validateCatalogSnapshot(snapshotDirectory: string): Promise<{
+export declare function validatePublishedCatalogSnapshotMetadata(snapshotDirectory: string): Promise<{
     rootDir: string;
-    manifest: CatalogManifestV4;
-    ledger?: PluginReleaseLedger;
+    workspaceIdentity: string;
+    manifest: CatalogManifestV7;
+}>;
+export declare function validateCatalogSnapshotTransport(snapshotDirectory: string): Promise<{
+    rootDir: string;
+    manifest: CatalogManifestV7;
     snapshotDigest: string;
 }>;
+type CatalogSnapshotValidationResult = {
+    rootDir: string;
+    manifest: CatalogManifestV7;
+    snapshotDigest: string;
+};
+export declare function validateCatalogSnapshotPluginEntriesComplete(snapshotDirectory: string, pluginNames: readonly string[]): Promise<CatalogSnapshotValidationResult>;
+export declare function validateCatalogSnapshotComplete(snapshotDirectory: string): Promise<CatalogSnapshotValidationResult>;
+export {};