tracegrove 0.0.0-stage → 0.3.0

package/dist/core/sourcePromotion.d.ts

@@ -0,0 +1,929 @@
+import { z } from 'zod';
+import { PlanRevisionToken, ScenarioDefinition, ScenarioPromotion, ScenarioPromotionIntent, SelectionManifest, type Digest, type Ref, type Scope } from '../protocol/index.ts';
+import { ReviewedSourceDocuments } from './sourceReviewEvidence.ts';
+export declare const PromotionActor: z.ZodObject<{
+    actorId: z.ZodString;
+    policyRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        digest: z.ZodObject<{
+            algorithm: z.ZodLiteral<"sha256">;
+            hex: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ApprovedPlanReview: z.ZodObject<{
+    plan: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"workflow.source-plan/v1">;
+        ref: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        scope: z.ZodObject<{
+            ownerId: z.ZodString;
+            tenantId: z.ZodNullable<z.ZodString>;
+            visibility: z.ZodEnum<{
+                public: "public";
+                owner_private: "owner_private";
+                tenant_private: "tenant_private";
+            }>;
+        }, z.core.$strict>;
+        revisionMatrixRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        changeModelRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        disposition: z.ZodEnum<{
+            scenario_set: "scenario_set";
+            no_e2e_warranted: "no_e2e_warranted";
+            surface_unresolved: "surface_unresolved";
+        }>;
+        dispositionReasonRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        candidates: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            sourceElementIds: z.ZodArray<z.ZodString>;
+            caseRef: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            disposition: z.ZodEnum<{
+                blocked: "blocked";
+                excluded: "excluded";
+                runnable: "runnable";
+                not_derivable: "not_derivable";
+            }>;
+            reasonRefs: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            capabilityRefs: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        validFlowRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        withheldFlows: z.ZodArray<z.ZodObject<{
+            flowRef: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            reasonRefs: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        invalidFlows: z.ZodArray<z.ZodObject<{
+            flowRef: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            diagnosticRefs: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodString;
+                digest: z.ZodObject<{
+                    algorithm: z.ZodLiteral<"sha256">;
+                    hex: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        coverageObligationRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        gapRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    review: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"workflow.plan-review/v1">;
+        ref: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        scope: z.ZodObject<{
+            ownerId: z.ZodString;
+            tenantId: z.ZodNullable<z.ZodString>;
+            visibility: z.ZodEnum<{
+                public: "public";
+                owner_private: "owner_private";
+                tenant_private: "tenant_private";
+            }>;
+        }, z.core.$strict>;
+        sourcePlanRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        editRevision: z.ZodNumber;
+        decision: z.ZodEnum<{
+            approved: "approved";
+            rejected: "rejected";
+        }>;
+        reviewerActorId: z.ZodString;
+        policyRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        reasonRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    validation: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"workflow.source-validation/v1">;
+        sourcePlanRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        changeModelRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        revisionMatrixRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        policyRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        verifiedCitationRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        runnableElementIds: z.ZodArray<z.ZodString>;
+        retainedDiagnosticRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        ref: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        scope: z.ZodObject<{
+            ownerId: z.ZodString;
+            tenantId: z.ZodNullable<z.ZodString>;
+            visibility: z.ZodEnum<{
+                public: "public";
+                owner_private: "owner_private";
+                tenant_private: "tenant_private";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    storageVersion: z.ZodNumber;
+    projection: z.ZodObject<{
+        id: z.ZodString;
+        scope: z.ZodObject<{
+            ownerId: z.ZodString;
+            tenantId: z.ZodNullable<z.ZodString>;
+            visibility: z.ZodEnum<{
+                public: "public";
+                owner_private: "owner_private";
+                tenant_private: "tenant_private";
+            }>;
+        }, z.core.$strict>;
+        editRevision: z.ZodNumber;
+        sourcePlanRef: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        currentReviewRef: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodString;
+            digest: z.ZodObject<{
+                algorithm: z.ZodLiteral<"sha256">;
+                hex: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ApprovedPlanReview = z.infer<typeof ApprovedPlanReview>;
+export interface ApprovedPlanSnapshot {
+    documents: ApprovedPlanReview;
+    assertCurrent(): void;
+}
+export interface ScenarioPromotionPorts {
+    authorizePromotion(scope: Scope, intentDigest: Digest): Promise<z.infer<typeof PromotionActor>>;
+    resolveApprovedReview(token: PlanRevisionToken, reviewRef: Ref): Promise<unknown>;
+    validateDefinition(definition: ScenarioDefinition): Promise<void>;
+    readPromotion(idempotencyKey: string, scope: Scope): Promise<unknown | null>;
+    /** Recheck actual reviewed storage and authority; publish receipt, review snapshot and proposed registry entry together. */
+    compareAndSwapPromotion(intent: ScenarioPromotionIntent, definition: ScenarioDefinition, selections: SelectionManifest[], promotion: ScenarioPromotion, approved: ApprovedPlanReview): Promise<boolean>;
+}
+export declare function normalizePromotionIntent(raw: ScenarioPromotionIntent): ScenarioPromotionIntent;
+export declare function validateApprovedPlanReview(raw: unknown, token: PlanRevisionToken, reviewRef: Ref): ApprovedPlanReview;
+export declare function validatePromotedCases(definition: ScenarioDefinition, approved: ReviewedSourceDocuments): void;
+export declare function deriveScenarioPromotion(intent: ScenarioPromotionIntent, rawDefinition: unknown, rawSelections: unknown[], rawApproved: unknown, actor: z.infer<typeof PromotionActor>, promotedAt: string): {
+    promotion: {
+        schemaVersion: "workflow.scenario-promotion/v1";
+        ref: {
+            id: string;
+            revision: string;
+            digest: {
+                algorithm: "sha256";
+                hex: string;
+            };
+        };
+        scope: {
+            ownerId: string;
+            tenantId: string | null;
+            visibility: "public" | "owner_private" | "tenant_private";
+        };
+        intent: {
+            scenarioId: string;
+            definitionRef: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            };
+            reviewToken: {
+                id: string;
+                scope: {
+                    ownerId: string;
+                    tenantId: string | null;
+                    visibility: "public" | "owner_private" | "tenant_private";
+                };
+                expectedEditRevision: number;
+                expectedSourcePlanRef: {
+                    id: string;
+                    revision: string;
+                    digest: {
+                        algorithm: "sha256";
+                        hex: string;
+                    };
+                };
+            };
+            selectionManifestRefs: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            }[];
+            idempotencyKey: string;
+        };
+        reviewRef: {
+            id: string;
+            revision: string;
+            digest: {
+                algorithm: "sha256";
+                hex: string;
+            };
+        };
+        sourceValidationRef: {
+            id: string;
+            revision: string;
+            digest: {
+                algorithm: "sha256";
+                hex: string;
+            };
+        };
+        reviewStorageVersion: number;
+        actorId: string;
+        authorizationPolicyRef: {
+            id: string;
+            revision: string;
+            digest: {
+                algorithm: "sha256";
+                hex: string;
+            };
+        };
+        promotedAt: string;
+    };
+    definition: {
+        schemaVersion: "workflow.scenario/v1";
+        ref: {
+            id: string;
+            revision: string;
+            digest: {
+                algorithm: "sha256";
+                hex: string;
+            };
+        };
+        scope: {
+            ownerId: string;
+            tenantId: string | null;
+            visibility: "public" | "owner_private" | "tenant_private";
+        };
+        sourcePlanRef: {
+            id: string;
+            revision: string;
+            digest: {
+                algorithm: "sha256";
+                hex: string;
+            };
+        } | null;
+        reviewRef: {
+            id: string;
+            revision: string;
+            digest: {
+                algorithm: "sha256";
+                hex: string;
+            };
+        };
+        caseRefs: {
+            id: string;
+            revision: string;
+            digest: {
+                algorithm: "sha256";
+                hex: string;
+            };
+        }[];
+        replayContractRef: {
+            id: string;
+            revision: string;
+            digest: {
+                algorithm: "sha256";
+                hex: string;
+            };
+        };
+        qualificationPolicyRef: {
+            id: string;
+            revision: string;
+            digest: {
+                algorithm: "sha256";
+                hex: string;
+            };
+        };
+        qualificationMatrixRef: {
+            id: string;
+            revision: string;
+            digest: {
+                algorithm: "sha256";
+                hex: string;
+            };
+        };
+        qualificationTargetProfileRef: {
+            id: string;
+            revision: string;
+            digest: {
+                algorithm: "sha256";
+                hex: string;
+            };
+        };
+    };
+    selections: {
+        policyRef: {
+            id: string;
+            revision: string;
+            digest: {
+                algorithm: "sha256";
+                hex: string;
+            };
+        } | null;
+        cells: {
+            selectionCellId: string;
+            required: boolean;
+            caseRef: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            };
+            personaRef: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            };
+            surfaceBindingRef: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            };
+            variantRef: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            } | null;
+            sourceSelectionRef: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            } | null;
+            environmentRef: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            };
+            expectedTarget: {
+                componentProfileRef: {
+                    id: string;
+                    revision: string;
+                    digest: {
+                        algorithm: "sha256";
+                        hex: string;
+                    };
+                };
+                requiredComponents: string[];
+                excludedComponents: {
+                    component: string;
+                    reason: string;
+                }[];
+                components: {
+                    componentId: string;
+                    kind: "schema" | "application" | "service" | "worker" | "flag_set" | "protocol_server" | "host" | "widget" | "mobile_binary" | "device_runtime" | "model_endpoint" | "other";
+                    identity: {
+                        kind: "source_digest";
+                        sourceDigest: {
+                            algorithm: "sha256";
+                            hex: string;
+                        };
+                        runtime: string;
+                    } | {
+                        kind: "declared_release";
+                        release: string;
+                    } | null;
+                }[];
+                repositories: {
+                    repositoryRole: string;
+                    canonicalUrl: string;
+                    requestedRef: string;
+                    resolvedCommit: string;
+                    origin: "remote_object" | "snapshot_bundle";
+                    sourceObjectsRef: {
+                        id: string;
+                        revision: string;
+                        digest: {
+                            algorithm: "sha256";
+                            hex: string;
+                        };
+                    } | null;
+                    lockfileDigest: {
+                        algorithm: "sha256";
+                        hex: string;
+                    };
+                    dirty: false;
+                }[];
+                corpus: {
+                    id: string;
+                    revision: string;
+                    digest: {
+                        algorithm: "sha256";
+                        hex: string;
+                    };
+                };
+                runner: {
+                    id: string;
+                    revision: string;
+                    digest: {
+                        algorithm: "sha256";
+                        hex: string;
+                    };
+                };
+                evaluator: {
+                    id: string;
+                    revision: string;
+                    digest: {
+                        algorithm: "sha256";
+                        hex: string;
+                    };
+                };
+                frontendRelease: string | null;
+                backendRelease: string | null;
+                workerRelease: string | null;
+                schemaFingerprint: {
+                    algorithm: "sha256";
+                    hex: string;
+                } | null;
+                featureFlagsDigest: {
+                    algorithm: "sha256";
+                    hex: string;
+                } | null;
+                capabilityVersionsDigest: {
+                    algorithm: "sha256";
+                    hex: string;
+                } | null;
+                browserVersion: string | null;
+                containerImageDigest: string | null;
+                modelConfigDigest: {
+                    algorithm: "sha256";
+                    hex: string;
+                } | null;
+            };
+            executionHostRef: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            };
+        }[];
+        excludedCells: {
+            cellKey: string;
+            reason: string;
+        }[];
+        schemaVersion: "workflow.selection/v1";
+        ref: {
+            id: string;
+            revision: string;
+            digest: {
+                algorithm: "sha256";
+                hex: string;
+            };
+        };
+        scope: {
+            ownerId: string;
+            tenantId: string | null;
+            visibility: "public" | "owner_private" | "tenant_private";
+        };
+    }[];
+    approved: {
+        plan: {
+            schemaVersion: "workflow.source-plan/v1";
+            ref: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            };
+            scope: {
+                ownerId: string;
+                tenantId: string | null;
+                visibility: "public" | "owner_private" | "tenant_private";
+            };
+            revisionMatrixRef: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            };
+            changeModelRef: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            };
+            disposition: "scenario_set" | "no_e2e_warranted" | "surface_unresolved";
+            dispositionReasonRefs: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            }[];
+            candidates: {
+                id: string;
+                sourceElementIds: string[];
+                caseRef: {
+                    id: string;
+                    revision: string;
+                    digest: {
+                        algorithm: "sha256";
+                        hex: string;
+                    };
+                } | null;
+                disposition: "blocked" | "excluded" | "runnable" | "not_derivable";
+                reasonRefs: {
+                    id: string;
+                    revision: string;
+                    digest: {
+                        algorithm: "sha256";
+                        hex: string;
+                    };
+                }[];
+                capabilityRefs: {
+                    id: string;
+                    revision: string;
+                    digest: {
+                        algorithm: "sha256";
+                        hex: string;
+                    };
+                }[];
+            }[];
+            validFlowRefs: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            }[];
+            withheldFlows: {
+                flowRef: {
+                    id: string;
+                    revision: string;
+                    digest: {
+                        algorithm: "sha256";
+                        hex: string;
+                    };
+                };
+                reasonRefs: {
+                    id: string;
+                    revision: string;
+                    digest: {
+                        algorithm: "sha256";
+                        hex: string;
+                    };
+                }[];
+            }[];
+            invalidFlows: {
+                flowRef: {
+                    id: string;
+                    revision: string;
+                    digest: {
+                        algorithm: "sha256";
+                        hex: string;
+                    };
+                };
+                diagnosticRefs: {
+                    id: string;
+                    revision: string;
+                    digest: {
+                        algorithm: "sha256";
+                        hex: string;
+                    };
+                }[];
+            }[];
+            coverageObligationRefs: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            }[];
+            gapRefs: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            }[];
+        };
+        review: {
+            schemaVersion: "workflow.plan-review/v1";
+            ref: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            };
+            scope: {
+                ownerId: string;
+                tenantId: string | null;
+                visibility: "public" | "owner_private" | "tenant_private";
+            };
+            sourcePlanRef: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            };
+            editRevision: number;
+            decision: "approved" | "rejected";
+            reviewerActorId: string;
+            policyRef: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            };
+            reasonRefs: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            }[];
+        };
+        validation: {
+            schemaVersion: "workflow.source-validation/v1";
+            sourcePlanRef: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            };
+            changeModelRef: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            };
+            revisionMatrixRef: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            };
+            policyRef: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            };
+            verifiedCitationRefs: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            }[];
+            runnableElementIds: string[];
+            retainedDiagnosticRefs: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            }[];
+            ref: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            };
+            scope: {
+                ownerId: string;
+                tenantId: string | null;
+                visibility: "public" | "owner_private" | "tenant_private";
+            };
+        };
+        storageVersion: number;
+        projection: {
+            id: string;
+            scope: {
+                ownerId: string;
+                tenantId: string | null;
+                visibility: "public" | "owner_private" | "tenant_private";
+            };
+            editRevision: number;
+            sourcePlanRef: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            };
+            currentReviewRef: {
+                id: string;
+                revision: string;
+                digest: {
+                    algorithm: "sha256";
+                    hex: string;
+                };
+            } | null;
+        };
+    };
+};
+/** Promotion registers a proposed scenario only. It does not approve the source plan, execute cases or activate coverage. */
+export declare function promoteScenario(ports: ScenarioPromotionPorts, rawIntent: ScenarioPromotionIntent, rawDefinition: ScenarioDefinition, rawSelections: SelectionManifest[]): Promise<ScenarioPromotion>;