@mcoda/mswarm 0.1.89 → 0.1.91

package/dist/vendor/codali/improvement/PromptSchemaToolMetadataCandidateBuilder.js

@@ -0,0 +1,480 @@
+import { createHash } from "node:crypto";
+export const CODALI_PATCH_CANDIDATE_SCHEMA_VERSION = "codali.improvement.patch_candidate.v1";
+export const CODALI_PATCH_PROPOSAL_ARTIFACTS = [
+    "prompt",
+    "schema",
+    "tool-metadata",
+];
+const ARTIFACT_CONTRACTS = {
+    prompt: {
+        artifact: "prompt",
+        candidateKind: "prompt",
+        patchArtifactType: "prompt_patch",
+        operationType: "add_prompt_failure_guardrail",
+        sourceArtifactTypes: ["prompt", "prompt_patch", "prompt_regression"],
+    },
+    schema: {
+        artifact: "schema",
+        candidateKind: "schema",
+        patchArtifactType: "schema_patch",
+        operationType: "tighten_schema_contract",
+        sourceArtifactTypes: ["schema", "schema_patch"],
+    },
+    "tool-metadata": {
+        artifact: "tool-metadata",
+        candidateKind: "tool_metadata",
+        patchArtifactType: "tool_metadata_patch",
+        operationType: "update_tool_metadata_contract",
+        sourceArtifactTypes: ["tool_metadata", "tool_metadata_patch", "tool_contract"],
+        requiresToolContractHash: true,
+    },
+};
+const isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+const stableJson = (value) => {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(",")}]`;
+    if (!isRecord(value))
+        return JSON.stringify(value);
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
+};
+const sha256Hex = (value) => createHash("sha256").update(stableJson(value)).digest("hex");
+const stableId = (prefix, value) => `${prefix}-${sha256Hex(value).slice(0, 16)}`;
+const normalizeToken = (value) => value.trim().toLowerCase().replace(/[\s-]+/g, "_");
+const uniqueSorted = (values) => Array.from(new Set(values
+    .map((value) => value?.trim())
+    .filter((value) => Boolean(value))))
+    .sort();
+const normalizedUniqueSorted = (values) => uniqueSorted(values.map((value) => value ? normalizeToken(value) : undefined));
+const readString = (record, keys) => {
+    for (const key of keys) {
+        const value = record?.[key];
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return undefined;
+};
+const stringList = (value) => {
+    if (Array.isArray(value)) {
+        return value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+    }
+    if (typeof value === "string" && value.trim())
+        return [value.trim()];
+    return [];
+};
+const objectList = (value) => Array.isArray(value) ? value.filter(isRecord) : [];
+const metadataForRow = (row) => isRecord(row?.metadata) ? row.metadata : {};
+const objectRefFromValue = (value) => isRecord(value) &&
+    typeof value.refId === "string" &&
+    typeof value.contentHash === "string" &&
+    typeof value.byteSize === "number" &&
+    typeof value.mimeType === "string" &&
+    typeof value.deletionGroupId === "string" &&
+    isRecord(value.privacyFlags)
+    ? value
+    : undefined;
+const refsForRow = (row) => {
+    const evidenceRefs = Array.isArray(row?.evidenceRefs)
+        ? row.evidenceRefs.map(objectRefFromValue)
+            .filter((ref) => Boolean(ref))
+        : [];
+    return {
+        inputRef: objectRefFromValue(row?.inputRef),
+        outputRef: objectRefFromValue(row?.outputRef),
+        evidenceRefs,
+    };
+};
+const summarizeObjectRef = (ref) => ({
+    refId: ref.refId,
+    kind: ref.kind,
+    contentHash: ref.contentHash,
+    byteSize: ref.byteSize,
+    mimeType: ref.mimeType,
+    deletionGroupId: ref.deletionGroupId,
+    privacyFlags: ref.privacyFlags,
+    ...(ref.uri ? { uri: ref.uri } : {}),
+    ...(ref.mediaType ? { mediaType: ref.mediaType } : {}),
+    metadataKeys: isRecord(ref.metadata) ? Object.keys(ref.metadata).sort() : [],
+});
+const recordIdForRow = (row) => isRecord(row) ? readString(row, ["recordId", "record_id"]) : undefined;
+const rowsByRecordId = (rows) => {
+    const output = new Map();
+    for (const row of rows) {
+        if (!isRecord(row))
+            continue;
+        const recordId = recordIdForRow(row);
+        if (recordId)
+            output.set(recordId, row);
+    }
+    return output;
+};
+const nestedHash = (metadata, directKeys, nestedKeys) => {
+    const direct = readString(metadata, directKeys);
+    if (direct)
+        return direct;
+    for (const key of nestedKeys) {
+        const nested = metadata[key];
+        if (!isRecord(nested))
+            continue;
+        const hash = readString(nested, ["hash", "contentHash", "content_hash"]);
+        if (hash)
+            return hash;
+    }
+    return undefined;
+};
+const failureEvidenceRecords = (metadata) => [
+    ...objectList(metadata.failureEvidence),
+    ...objectList(metadata.failure_evidence),
+    ...objectList(metadata.failures),
+    ...objectList(metadata.evalFailures),
+    ...objectList(metadata.eval_failures),
+];
+const failureClassesForRow = (row) => {
+    const metadata = metadataForRow(row);
+    const structured = failureEvidenceRecords(metadata);
+    return normalizedUniqueSorted([
+        ...stringList(metadata.failureClass),
+        ...stringList(metadata.failure_class),
+        ...stringList(metadata.failureClasses),
+        ...stringList(metadata.failure_classes),
+        ...structured.flatMap((entry) => [
+            ...stringList(entry.failureClass),
+            ...stringList(entry.failure_class),
+            ...stringList(entry.failureClasses),
+            ...stringList(entry.failure_classes),
+            readString(entry, ["class", "category"]),
+        ]),
+    ]);
+};
+const failureReasonCodesForRow = (row) => {
+    const metadata = metadataForRow(row);
+    const structured = failureEvidenceRecords(metadata);
+    return normalizedUniqueSorted([
+        ...stringList(metadata.reasonCode),
+        ...stringList(metadata.reason_code),
+        ...stringList(metadata.reasonCodes),
+        ...stringList(metadata.reason_codes),
+        ...stringList(metadata.failureReasonCodes),
+        ...stringList(metadata.failure_reason_codes),
+        ...structured.flatMap((entry) => [
+            ...stringList(entry.reasonCode),
+            ...stringList(entry.reason_code),
+            ...stringList(entry.reasonCodes),
+            ...stringList(entry.reason_codes),
+            readString(entry, ["code"]),
+        ]),
+    ]);
+};
+const sourceExampleForAccepted = (item, row) => {
+    const refs = refsForRow(row);
+    const metadata = metadataForRow(row);
+    const schemaHash = nestedHash(metadata, ["schemaHash", "schema_hash", "schemaContractHash", "schema_contract_hash"], ["schema", "schemaMetadata", "schema_metadata", "schemaContract", "schema_contract"]) ?? item.lineageKey.expectedTargetHash;
+    const toolContractHash = item.lineageKey.toolContractHash ?? nestedHash(metadata, ["toolContractHash", "tool_contract_hash"], ["toolContract", "tool_contract", "toolMetadata", "tool_metadata"]);
+    return {
+        recordId: item.recordId,
+        ...(item.sourceGatewayRecordId ? { sourceGatewayRecordId: item.sourceGatewayRecordId } : {}),
+        ...(readString(row, ["datasetKind", "dataset_kind"])
+            ? { datasetKind: readString(row, ["datasetKind", "dataset_kind"]) }
+            : {}),
+        artifactTypes: item.artifactTypes.map(normalizeToken).sort(),
+        failureClasses: failureClassesForRow(row),
+        failureReasonCodes: failureReasonCodesForRow(row),
+        preferenceSignals: [...item.preferenceSignals].sort(),
+        priorityScore: item.priorityScore,
+        lineageKey: {
+            runIds: item.lineageKey.runIds,
+            deletionGroupIds: item.lineageKey.deletionGroupIds,
+            ...(item.lineageKey.promptHash ? { promptHash: item.lineageKey.promptHash } : {}),
+            ...(schemaHash ? { schemaHash } : {}),
+            ...(toolContractHash ? { toolContractHash } : {}),
+            ...(item.lineageKey.expectedTargetHash
+                ? { expectedTargetHash: item.lineageKey.expectedTargetHash }
+                : {}),
+        },
+        objectRefs: {
+            ...(refs.inputRef ? { inputRef: summarizeObjectRef(refs.inputRef) } : {}),
+            ...(refs.outputRef ? { outputRef: summarizeObjectRef(refs.outputRef) } : {}),
+            evidenceRefs: refs.evidenceRefs.map(summarizeObjectRef),
+        },
+        metadataShape: {
+            keys: Object.keys(metadata).sort(),
+            failureEvidenceKeys: failureEvidenceRecords(metadata)
+                .flatMap((entry) => Object.keys(entry))
+                .sort(),
+            contractKeys: Object.keys(metadata)
+                .filter((key) => key.toLowerCase().includes("contract") || key.toLowerCase().includes("schema"))
+                .sort(),
+        },
+    };
+};
+const explicitArtifactTypesForRow = (row) => {
+    const metadata = metadataForRow(row);
+    const refs = refsForRow(row);
+    return normalizedUniqueSorted([
+        readString(metadata, [
+            "artifactType",
+            "artifact_type",
+            "exampleType",
+            "example_type",
+        ]),
+        ...[
+            refs.inputRef,
+            refs.outputRef,
+            ...refs.evidenceRefs,
+        ].map((ref) => readString(isRecord(ref?.metadata) ? ref.metadata : undefined, [
+            "artifactType",
+            "artifact_type",
+        ])),
+    ]);
+};
+const sourceExamplesForArtifact = (inspection, artifact) => {
+    const rowMap = rowsByRecordId(inspection.primaryArtifactRows);
+    const contract = ARTIFACT_CONTRACTS[artifact];
+    const sourceTypes = new Set(contract.sourceArtifactTypes.map(normalizeToken));
+    return inspection.curationReport.accepted
+        .filter((item) => {
+        const row = rowMap.get(item.recordId);
+        const explicitTypes = explicitArtifactTypesForRow(row);
+        const filterTypes = explicitTypes.length > 0
+            ? explicitTypes
+            : item.artifactTypes.map(normalizeToken);
+        return filterTypes.some((type) => sourceTypes.has(type));
+    })
+        .map((item) => sourceExampleForAccepted(item, rowMap.get(item.recordId)))
+        .sort((left, right) => right.priorityScore - left.priorityScore || left.recordId.localeCompare(right.recordId));
+};
+const failureEvidenceForRejected = (rejected) => rejected.map((item) => ({
+    source: "curation_rejection",
+    ...(item.recordId ? { recordId: item.recordId } : {}),
+    targetType: item.targetType,
+    failureClasses: normalizedUniqueSorted(item.reasons.map((reason) => reason.code)),
+    reasonCodes: normalizedUniqueSorted(item.reasons.map((reason) => reason.code)),
+    paths: uniqueSorted(item.reasons.map((reason) => reason.path)),
+}));
+const failureEvidenceForSourceExamples = (sourceExamples) => sourceExamples.map((example) => ({
+    source: "source_example",
+    recordId: example.recordId,
+    failureClasses: example.failureClasses,
+    reasonCodes: example.failureReasonCodes,
+    paths: [],
+}));
+const objectBytesForSourceExamples = (sourceExamples) => {
+    const refs = new Map();
+    for (const example of sourceExamples) {
+        for (const ref of [
+            example.objectRefs.inputRef,
+            example.objectRefs.outputRef,
+            ...example.objectRefs.evidenceRefs,
+        ]) {
+            if (ref)
+                refs.set(`${ref.refId}:${ref.contentHash}`, ref);
+        }
+    }
+    return Array.from(refs.values()).reduce((total, ref) => total + ref.byteSize, 0);
+};
+const targetHashesForExamples = (sourceExamples) => ({
+    artifact: "prompt",
+    candidateKind: "prompt",
+    promptHashes: uniqueSorted(sourceExamples.map((example) => example.lineageKey.promptHash)),
+    schemaHashes: uniqueSorted(sourceExamples.map((example) => example.lineageKey.schemaHash)),
+    toolContractHashes: uniqueSorted(sourceExamples.map((example) => example.lineageKey.toolContractHash)),
+    expectedTargetHashes: uniqueSorted(sourceExamples.map((example) => example.lineageKey.expectedTargetHash)),
+});
+const blockedReasonsFor = (contract, sourceExamples, sourceFailureClasses, inspection) => uniqueSorted([
+    sourceExamples.length === 0 ? "source_examples_required" : undefined,
+    sourceFailureClasses.length === 0 ? "failure_classes_required" : undefined,
+    !inspection.curationReport.artifactReadAllowed ? "artifact_payload_read_blocked" : undefined,
+    !inspection.curationReport.lineageValid ? "lineage_invalid" : undefined,
+    contract.requiresToolContractHash &&
+        sourceExamples.every((example) => !example.lineageKey.toolContractHash)
+        ? "tool_contract_hash_required"
+        : undefined,
+]);
+const patchPlanFor = (input) => {
+    const contract = ARTIFACT_CONTRACTS[input.artifact];
+    const target = {
+        ...targetHashesForExamples(input.sourceExamples),
+        artifact: input.artifact,
+        candidateKind: contract.candidateKind,
+    };
+    const planId = stableId("patch-plan", {
+        artifact: input.artifact,
+        manifestId: input.inspection.manifest.manifestId,
+        checksum: input.inspection.manifest.checksum,
+        sourceRecordIds: input.sourceExamples.map((example) => example.recordId),
+        failureClasses: input.sourceFailureClasses,
+        target,
+    });
+    const operationId = stableId("patch-op", {
+        planId,
+        operationType: contract.operationType,
+        sourceRecordIds: input.sourceExamples.map((example) => example.recordId),
+        failureClasses: input.sourceFailureClasses,
+        target,
+    });
+    const operations = input.sourceExamples.length > 0 && input.sourceFailureClasses.length > 0
+        ? [{
+                operationId,
+                operationType: contract.operationType,
+                productNeutral: true,
+                contractDriven: true,
+                sourceRecordIds: input.sourceExamples.map((example) => example.recordId),
+                failureClasses: [...input.sourceFailureClasses],
+                requiredEvidence: ["source_examples", "failure_classes"],
+                writesRuntimeCode: false,
+                target,
+            }]
+        : [];
+    return {
+        planId,
+        artifact: input.artifact,
+        candidateKind: contract.candidateKind,
+        deterministic: true,
+        patchArtifactType: contract.patchArtifactType,
+        sourceExampleCount: input.sourceExamples.length,
+        failureClasses: [...input.sourceFailureClasses],
+        operations,
+        blockedReasons: [...input.blockedReasons],
+    };
+};
+const promptEvalFor = (input) => {
+    if (input.sourceExamples.length === 0 || input.sourceFailureClasses.length === 0) {
+        return undefined;
+    }
+    const suiteId = stableId("prompt-eval-suite", {
+        manifestId: input.inspection.manifest.manifestId,
+        sourceRecordIds: input.sourceExamples.map((example) => example.recordId),
+        failureClasses: input.sourceFailureClasses,
+    });
+    return {
+        suiteId,
+        sourceExportId: input.inspection.manifest.manifestId,
+        wouldFailBeforeChange: true,
+        cases: input.sourceExamples.map((example) => ({
+            caseId: stableId("prompt-eval-case", {
+                suiteId,
+                recordId: example.recordId,
+                failureClasses: example.failureClasses,
+                inputHash: example.objectRefs.inputRef?.contentHash,
+                outputHash: example.objectRefs.outputRef?.contentHash,
+            }),
+            sourceRecordId: example.recordId,
+            failureClasses: example.failureClasses,
+            preChangeExpectedStatus: "fail",
+            postChangeExpectedStatus: "pass",
+            assertions: [
+                "uses_source_evidence",
+                "covers_recorded_failure_class",
+                "preserves_product_neutral_contract",
+            ],
+            objectRefs: example.objectRefs,
+        })),
+    };
+};
+const expectedShape = (artifact) => ({
+    schemaVersion: CODALI_PATCH_CANDIDATE_SCHEMA_VERSION,
+    artifact,
+    requiredFields: [
+        "sourceExamples",
+        "failureEvidence",
+        "failureClasses",
+        "patchPlan",
+        "candidates",
+    ],
+    sourceExampleRequiredFields: [
+        "recordId",
+        "artifactTypes",
+        "failureClasses",
+        "lineageKey",
+        "objectRefs",
+    ],
+    patchPlanRequiredFields: [
+        "planId",
+        "artifact",
+        "deterministic",
+        "failureClasses",
+        "operations",
+    ],
+});
+const primaryArtifactRefForInspection = (inspection) => {
+    const ref = inspection.primaryArtifact?.ref ?? inspection.manifest.artifactRefs[0];
+    if (!ref) {
+        throw new Error("CODALI_PATCH_PRIMARY_ARTIFACT_MISSING");
+    }
+    return ref;
+};
+export const buildCodaliPatchCandidateBundle = (input) => {
+    const contract = ARTIFACT_CONTRACTS[input.artifact];
+    const inspection = input.inspection;
+    const sourceExamples = sourceExamplesForArtifact(inspection, input.artifact);
+    const sourceFailureClasses = normalizedUniqueSorted(sourceExamples
+        .flatMap((example) => example.failureClasses));
+    const rejectedFailureEvidence = failureEvidenceForRejected(inspection.curationReport.rejected);
+    const failureEvidence = [
+        ...failureEvidenceForSourceExamples(sourceExamples),
+        ...rejectedFailureEvidence,
+    ];
+    const failureClasses = normalizedUniqueSorted([
+        ...sourceFailureClasses,
+        ...rejectedFailureEvidence.flatMap((item) => item.failureClasses),
+    ]);
+    const blockedReasons = blockedReasonsFor(contract, sourceExamples, sourceFailureClasses, inspection);
+    const patchPlan = patchPlanFor({
+        artifact: input.artifact,
+        sourceExamples,
+        sourceFailureClasses,
+        blockedReasons,
+        inspection,
+    });
+    const candidateId = stableId("candidate", {
+        artifact: input.artifact,
+        manifestId: inspection.manifest.manifestId,
+        checksum: inspection.manifest.checksum,
+        patchPlanId: patchPlan.planId,
+        sourceRecordIds: sourceExamples.map((example) => example.recordId),
+        failureClasses: sourceFailureClasses,
+    });
+    const promptEval = input.artifact === "prompt"
+        ? promptEvalFor({ sourceExamples, sourceFailureClasses, inspection })
+        : undefined;
+    const candidateStatus = blockedReasons.length === 0 ? "proposed" : "blocked";
+    return {
+        schemaVersion: CODALI_PATCH_CANDIDATE_SCHEMA_VERSION,
+        artifact: input.artifact,
+        source: {
+            exportId: inspection.exportId,
+            manifestId: inspection.manifest.manifestId,
+            manifestPath: inspection.manifestPath,
+            exportKind: inspection.manifest.exportKind,
+            checksum: inspection.manifest.checksum,
+            recordCount: inspection.manifest.recordCount,
+            primaryArtifactRef: summarizeObjectRef(primaryArtifactRefForInspection(inspection)),
+        },
+        generationPolicy: {
+            deterministic: true,
+            modifiesRuntimePrompts: false,
+            modifiesRuntimeCode: false,
+            bodyPolicy: "object_refs_only",
+            failureEvidenceRequired: true,
+            sourceExamplesRequired: true,
+        },
+        expectedShape: expectedShape(input.artifact),
+        sourceExamples,
+        failureEvidence,
+        failureClasses,
+        patchPlan,
+        ...(promptEval ? { promptEval } : {}),
+        candidates: [{
+                candidateId,
+                candidateKind: contract.candidateKind,
+                status: candidateStatus,
+                patchPlanId: patchPlan.planId,
+                sourceExportIds: [inspection.manifest.manifestId],
+                sourceRecordIds: sourceExamples.map((example) => example.recordId),
+                artifactIds: inspection.manifest.artifactRefs.map((ref) => ref.refId),
+                exampleCount: sourceExamples.length,
+                objectBytes: objectBytesForSourceExamples(sourceExamples),
+                failureClasses: sourceFailureClasses,
+                blockedReasons,
+            }],
+    };
+};

package/dist/vendor/codali/improvement/PublishOrchestrator.d.ts

@@ -0,0 +1,113 @@
+import { type CodaliCandidateReleaseBuild, type CodaliCandidateReleaseCommandRunner, type CodaliCandidateReleaseDirtyEntry } from "./CandidateReleaseBuilder.js";
+import { type CodaliImprovementEvalRunnerResult } from "./ImprovementEvalRunner.js";
+import { evaluateCodaliImprovementPolicy, type CodaliImprovementOutcome, type CodaliImprovementPolicy, type CodaliImprovementReleaseLevel, type CodaliImprovementScope } from "./ImprovementPolicy.js";
+import { StorageServiceImprovementClient, type StorageServiceImprovementWriteResult } from "./StorageServiceImprovementClient.js";
+import type { GatewayDatasetStorageScope } from "../storage/GatewayDatasetStore.js";
+export declare const CODALI_PUBLISH_ORCHESTRATOR_SCHEMA_VERSION: "codali.improvement.publish.v1";
+export declare const CODALI_PUBLISH_RELEASE_WORKFLOW_FILE: ".github/workflows/release.yml";
+export declare const DEFAULT_CODALI_PUBLISH_NPM_REGISTRY: "https://registry.npmjs.org/";
+export type CodaliPublishMode = "branch_only" | "auto_tag";
+export type CodaliPublishStatus = "planned" | "blocked" | "tagged" | "workflow_queued" | "workflow_succeeded" | "workflow_failed" | "published_verified" | "failed";
+export type CodaliPublishWorkflowStatus = "not_requested" | "queued" | "in_progress" | "completed" | "unknown";
+export type CodaliPublishWorkflowConclusion = "success" | "failure" | "cancelled" | "skipped" | "timed_out" | "action_required" | "neutral" | "unknown";
+export type CodaliPublishNpmVersionStatus = "planned" | "verified" | "mismatch" | "unavailable";
+export interface CodaliPublishWorkflowRunStatus {
+    workflowFile: typeof CODALI_PUBLISH_RELEASE_WORKFLOW_FILE;
+    source: "planned" | "ingested" | "gh_cli";
+    runId?: string;
+    status: CodaliPublishWorkflowStatus;
+    conclusion?: CodaliPublishWorkflowConclusion;
+    headSha?: string;
+    url?: string;
+    error?: string;
+}
+export interface CodaliPublishNpmVersion {
+    packageName: string;
+    expectedVersion: string;
+    registry: string;
+    observedVersion?: string;
+    status: CodaliPublishNpmVersionStatus;
+    command: string[];
+    error?: string;
+}
+export interface CodaliPublishCommitGuard {
+    required: boolean;
+    status: "clean" | "dirty" | "unavailable" | "skipped";
+    commitSha?: string;
+    dirtyFileCount: number;
+    dirtyFilesSample: string[];
+    reasons: string[];
+}
+export interface CodaliPublishCommandStep {
+    command: string;
+    args: string[];
+    executed: boolean;
+    exitCode?: number;
+    stdout?: string;
+    stderr?: string;
+    error?: string;
+}
+export interface CodaliPublishPublisher {
+    type: "github_actions_release_workflow";
+    workflowFile: typeof CODALI_PUBLISH_RELEASE_WORKFLOW_FILE;
+    localNpmPublishAllowed: false;
+    note: string;
+}
+export interface CodaliPublishResult {
+    schemaVersion: typeof CODALI_PUBLISH_ORCHESTRATOR_SCHEMA_VERSION;
+    dryRun: boolean;
+    mode: CodaliPublishMode;
+    status: CodaliPublishStatus;
+    candidateId: string;
+    releaseBuild: CodaliCandidateReleaseBuild;
+    scorecard?: CodaliImprovementEvalRunnerResult;
+    policy: CodaliImprovementPolicy;
+    policyDecisions: {
+        autoTag: ReturnType<typeof evaluateCodaliImprovementPolicy>;
+        publishStable: ReturnType<typeof evaluateCodaliImprovementPolicy>;
+    };
+    publisher: CodaliPublishPublisher;
+    commitGuard: CodaliPublishCommitGuard;
+    workflowRun: CodaliPublishWorkflowRunStatus;
+    npmVersions: CodaliPublishNpmVersion[];
+    commands: CodaliPublishCommandStep[];
+    blockedReasons: string[];
+    outcome: CodaliImprovementOutcome;
+}
+export interface RunCodaliPublishOrchestratorInput {
+    candidateId: string;
+    candidatePath?: string;
+    candidateDirectories?: readonly string[];
+    repoRoot?: string;
+    mode?: CodaliPublishMode;
+    dryRun?: boolean;
+    releaseLevel?: CodaliImprovementReleaseLevel;
+    scope?: CodaliImprovementScope;
+    policy?: CodaliImprovementPolicy;
+    autoTagEnabled?: boolean;
+    autoPublishEnabled?: boolean;
+    runId?: string;
+    candidateDate?: string;
+    commitSha?: string;
+    dirtyEntries?: readonly CodaliCandidateReleaseDirtyEntry[];
+    scorecard?: CodaliImprovementEvalRunnerResult;
+    workflowRun?: Partial<CodaliPublishWorkflowRunStatus>;
+    pollActions?: boolean;
+    verifyNpm?: boolean;
+    npmRegistry?: string;
+    npmPackages?: readonly string[];
+    npmVersions?: readonly {
+        packageName: string;
+        version: string;
+    }[];
+    now?: () => Date;
+    commandRunner?: CodaliCandidateReleaseCommandRunner;
+}
+export interface WriteCodaliPublishToStorageInput {
+    result: CodaliPublishResult;
+    scope: GatewayDatasetStorageScope;
+    client: StorageServiceImprovementClient;
+}
+export declare const runCodaliPublishOrchestrator: (input: RunCodaliPublishOrchestratorInput) => Promise<CodaliPublishResult>;
+export declare const writeCodaliPublishToStorageService: (input: WriteCodaliPublishToStorageInput) => Promise<Array<StorageServiceImprovementWriteResult<unknown>>>;
+//# sourceMappingURL=PublishOrchestrator.d.ts.map

package/dist/vendor/codali/improvement/PublishOrchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PublishOrchestrator.d.ts","sourceRoot":"","sources":["../../src/improvement/PublishOrchestrator.ts"],"names":[],"mappings":"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"}