@promptdriven/pds 0.1.2 → 0.1.4

package/dist/commands/registry.js

@@ -9,6 +9,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const node_util_1 = require("node:util");
 const config_1 = require("../config/config");
 const errors_1 = require("../errors/errors");
+const repo_url_1 = require("../utils/repo-url");
 const DEFAULT_LOGIN_SCOPES = [
     "project:create",
     "project:read",
@@ -24,7 +25,26 @@ const RELEASE_VIDEO_REATTACH_INITIAL_DELAY_MS = 250;
 const RELEASE_VIDEO_REATTACH_MAX_DELAY_MS = 5_000;
 const RELEASE_VIDEO_WAIT_MAX_CONFIRMATIONS = 60;
 const RELEASE_VIDEO_WAIT_POLL_MS = 1_000;
+const PIPELINE_REATTACH_MAX_ATTEMPTS = 8;
+const PIPELINE_REATTACH_INITIAL_DELAY_MS = 250;
+const PIPELINE_REATTACH_MAX_DELAY_MS = 5_000;
+const PIPELINE_WAIT_MAX_CONFIRMATIONS = 60;
+const PIPELINE_WAIT_POLL_MS = 1_000;
+const JOBS_WATCH_MAX_CONFIRMATIONS = 60;
+const JOBS_WATCH_POLL_MS = 1_000;
+const DISTRIBUTION_PUBLISH_REATTACH_MAX_ATTEMPTS = 8;
+const DISTRIBUTION_PUBLISH_REATTACH_INITIAL_DELAY_MS = 250;
+const DISTRIBUTION_PUBLISH_REATTACH_MAX_DELAY_MS = 5_000;
+const DISTRIBUTION_PUBLISH_WAIT_MAX_CONFIRMATIONS = 60;
+const DISTRIBUTION_PUBLISH_WAIT_POLL_MS = 1_000;
 const PRIVATE_INTERNAL_ERROR_DETAIL_KEY_PATTERN = /^(?:errorName|rootCause|raw(?:Provider)?(?:Payload|Response|Error|Message)?|providerRaw(?:Payload|Response|Error|Message)?)$/i;
+const REFERENCE_LIBRARY_SCOPES = ["user", "workspace", "organization"];
+const REFERENCE_LIBRARY_UPDATE_POLICIES = ["notify", "pinned"];
+const REFERENCE_LIBRARY_CAPTURE_POLICIES = ["off", "private-draft"];
+const REFERENCE_LIBRARY_GRANT_PRESETS = {
+    "can-use": ["library:view", "library:use"],
+    admin: ["library:view", "library:use", "library:admin"]
+};
 async function dispatchCommand(commandPath, commandArgs, context) {
     const command = commandPath.join(" ");
     switch (command) {
@@ -75,28 +95,40 @@ async function dispatchCommand(commandPath, commandArgs, context) {
                 "dry-run": "boolean",
                 "force-regenerate": "boolean",
                 wait: "boolean",
-                "idempotency-key": "string"
+                "idempotency-key": "string",
+                sections: "string[]",
+                files: "string[]",
+                segments: "string[]",
+                clips: "string[]"
             });
             const dryRun = values["dry-run"] === true;
-            const response = await context.client.runPipeline(compact({
+            const wait = !dryRun;
+            const requestPayload = compact({
                 projectId: requireProject(context.config),
                 to: optionalString(values.to),
                 stage: optionalString(values.stage),
                 mode: optionalString(values.mode),
+                sections: optionalStringList(values.sections),
+                files: optionalStringList(values.files),
+                segments: optionalStringList(values.segments),
+                clips: optionalStringList(values.clips),
                 dryRun: dryRun || undefined,
                 forceRegenerate: values["force-regenerate"] === true || undefined,
                 wait: values.wait === true || undefined,
                 idempotencyKey: mutationIdempotencyKey(values["idempotency-key"], dryRun)
-            }));
+            });
+            const response = wait
+                ? await createPipelineRunWithReattach(requestPayload, context)
+                : await context.client.runPipeline(requestPayload);
+            if (wait) {
+                return await waitForPipelineRun(response, context);
+            }
             await followAgentRunEvents(response, context);
             return response;
         }
         case "jobs watch": {
             const values = parse(commandArgs, { "job-id": "string", "run-id": "string" });
-            return await context.client.watchJob({
-                jobId: requiredRunOrJobId(values),
-                onEvent: context.emitJsonlEvent
-            });
+            return await watchJobUntilTerminal(requiredRunOrJobId(values), context);
         }
         case "jobs cancel": {
             const values = parse(commandArgs, { "job-id": "string" });
@@ -121,6 +153,8 @@ async function dispatchCommand(commandPath, commandArgs, context) {
                 platform: optionalString(values.platform)
             }));
         }
+        case "distribution thumbnails upload":
+            return await distributionThumbnailsUpload(commandArgs, context);
         case "distribution connections list": {
             const values = parse(commandArgs, { platform: "string" });
             return await context.client.listDistributionConnections(compact({
@@ -149,7 +183,8 @@ async function dispatchCommand(commandPath, commandArgs, context) {
                 "idempotency-key": "string"
             });
             const dryRun = values["dry-run"] === true;
-            const response = await context.client.publishDistribution(compact({
+            const wait = !dryRun;
+            const requestPayload = compact({
                 projectId: requireProject(context.config),
                 platform: optionalString(values.platform),
                 privacy: optionalString(values.privacy),
@@ -160,12 +195,75 @@ async function dispatchCommand(commandPath, commandArgs, context) {
                 auditOverrideRationale: optionalString(values["audit-override-rationale"]),
                 wait: values.wait === true || undefined,
                 idempotencyKey: mutationIdempotencyKey(values["idempotency-key"], dryRun)
-            }));
+            });
+            const response = wait
+                ? await publishDistributionWithReattach(requestPayload, context)
+                : await context.client.publishDistribution(requestPayload);
+            if (wait) {
+                return await waitForDistributionPublishRun(response, context);
+            }
             await followAgentRunEvents(response, context);
             return response;
         }
+        case "reference-library list": {
+            const values = parse(commandArgs, { scope: "string" });
+            return await context.client.listReferenceLibraries(compact({
+                projectId: context.config.projectId,
+                scope: referenceLibraryScope(values.scope)
+            }));
+        }
+        case "reference-library create": {
+            const values = parse(commandArgs, {
+                label: "string",
+                slug: "string",
+                "library-id": "string",
+                "idempotency-key": "string"
+            });
+            return await context.client.createReferenceLibrary(compact({
+                projectId: requireProject(context.config),
+                label: requiredString(values.label, "--label"),
+                slug: optionalString(values.slug),
+                libraryId: optionalString(values["library-id"]),
+                idempotencyKey: requiredString(values["idempotency-key"], "--idempotency-key")
+            }));
+        }
+        case "reference-library items list": {
+            const values = parse(commandArgs, { "library-id": "string" });
+            return await context.client.listReferenceLibraryItems(compact({
+                projectId: context.config.projectId,
+                libraryId: requiredString(values["library-id"], "--library-id")
+            }));
+        }
+        case "reference-library bindings list": {
+            ensureNoCommandArgs(commandArgs);
+            return await context.client.listReferenceLibraryProjectBindings({
+                projectId: requireProject(context.config)
+            });
+        }
+        case "reference-library policy get": {
+            ensureNoCommandArgs(commandArgs);
+            return await context.client.getReferenceLibraryProjectPolicy({
+                projectId: requireProject(context.config)
+            });
+        }
+        case "reference-library policy set":
+            return await referenceLibraryPolicySet(commandArgs, context);
+        case "reference-library bindings attach":
+            return await referenceLibraryBindingsAttach(commandArgs, context);
+        case "reference-library bindings update":
+            return await referenceLibraryBindingsUpdate(commandArgs, context);
+        case "reference-library bindings detach":
+            return await referenceLibraryBindingsDetach(commandArgs, context);
+        case "reference-library grants list":
+            return await referenceLibraryGrantsList(commandArgs, context);
+        case "reference-library grants add":
+            return await referenceLibraryGrantsAdd(commandArgs, context);
+        case "reference-library grants revoke":
+            return await referenceLibraryGrantsRevoke(commandArgs, context);
         case "release-video create":
             return await releaseVideoCreate(commandArgs, context);
+        case "release-video preflight":
+            return await releaseVideoPreflight(commandArgs, context);
         case "release-video status":
             return await releaseVideoStatus(commandArgs, context);
         default:
@@ -397,6 +495,366 @@ async function projectResetPipeline(commandArgs, context) {
         idempotencyKey: requiredString(values["idempotency-key"], "--idempotency-key"),
     }));
 }
+async function distributionThumbnailsUpload(commandArgs, context) {
+    const values = parse(commandArgs, {
+        platform: "string",
+        file: "string",
+        "target-candidate": "string",
+        "target-candidate-id": "string",
+        "confirm-rights": "boolean",
+        "rights-confirmed": "boolean",
+        "replace-live": "boolean",
+        "idempotency-key": "string"
+    });
+    const idempotencyKey = requiredString(values["idempotency-key"], "--idempotency-key");
+    if (values["confirm-rights"] !== true && values["rights-confirmed"] !== true) {
+        throw new errors_1.CliError("Missing required option --confirm-rights", {
+            code: "missing_required_option",
+            exitCode: errors_1.EXIT_CODES.usage
+        });
+    }
+    const sourcePath = requiredString(values.file, "--file");
+    const targetCandidateId = targetCandidateOption(values);
+    const fileRequest = await thumbnailFileRequest(sourcePath);
+    return await context.client.uploadDistributionThumbnail(compact({
+        projectId: requireProject(context.config),
+        platform: optionalString(values.platform),
+        targetCandidateId,
+        rightsConfirmed: true,
+        replaceLive: values["replace-live"] === true || undefined,
+        file: fileRequest.file,
+        fileName: fileRequest.fileName,
+        idempotencyKey
+    }));
+}
+function targetCandidateOption(values) {
+    const shortFlag = optionalString(values["target-candidate"]);
+    const longFlag = optionalString(values["target-candidate-id"]);
+    if (shortFlag && longFlag && shortFlag !== longFlag) {
+        throw new errors_1.CliError("Use only one of --target-candidate or --target-candidate-id", {
+            code: "invalid_arguments",
+            exitCode: errors_1.EXIT_CODES.usage
+        });
+    }
+    return shortFlag ?? longFlag;
+}
+async function thumbnailFileRequest(sourcePath) {
+    try {
+        const fileBytes = new Uint8Array(await (0, promises_1.readFile)(sourcePath));
+        return {
+            file: new Blob([fileBytes]),
+            fileName: node_path_1.default.basename(sourcePath)
+        };
+    }
+    catch (error) {
+        if (isNodeFileNotFound(error)) {
+            throw new errors_1.CliError(`Thumbnail file not found: ${sourcePath}`, {
+                code: "file_not_found",
+                exitCode: errors_1.EXIT_CODES.usage
+            });
+        }
+        throw error;
+    }
+}
+function isNodeFileNotFound(error) {
+    return Boolean(error) &&
+        typeof error === "object" &&
+        error.code === "ENOENT";
+}
+async function referenceLibraryPolicySet(commandArgs, context) {
+    const values = parse(commandArgs, {
+        "capture-policy": "string",
+        "default-capture-library-id": "string",
+        "auto-select-from-library": "boolean",
+        "no-auto-select-from-library": "boolean",
+        "auto-attach-confidence": "string",
+        "suggest-confidence": "string",
+        "idempotency-key": "string"
+    });
+    const capturePolicy = referenceLibraryCapturePolicy(values["capture-policy"]);
+    const defaultCaptureLibraryId = optionalString(values["default-capture-library-id"]);
+    if (capturePolicy === "private-draft" && !defaultCaptureLibraryId) {
+        throw new errors_1.CliError("Missing required option --default-capture-library-id when --capture-policy private-draft", { code: "missing_required_option", exitCode: errors_1.EXIT_CODES.usage });
+    }
+    return await context.client.setReferenceLibraryProjectPolicy(compact({
+        projectId: requireProject(context.config),
+        capturePolicy,
+        defaultCaptureLibraryId,
+        autoSelectFromLibrary: referenceLibraryAutoSelectFromFlags(values),
+        autoAttachConfidence: optionalReferenceLibraryConfidence(values["auto-attach-confidence"], "--auto-attach-confidence"),
+        suggestConfidence: optionalReferenceLibraryConfidence(values["suggest-confidence"], "--suggest-confidence"),
+        idempotencyKey: requiredString(values["idempotency-key"], "--idempotency-key")
+    }));
+}
+async function referenceLibraryGrantsList(commandArgs, context) {
+    const values = parse(commandArgs, { "library-id": "string" });
+    return await context.client.listReferenceLibraryGrants({
+        projectId: requireProject(context.config),
+        libraryId: requiredString(values["library-id"], "--library-id")
+    });
+}
+async function referenceLibraryGrantsAdd(commandArgs, context) {
+    const values = parse(commandArgs, {
+        "library-id": "string",
+        "user-id": "string",
+        permission: "string",
+        "expires-at": "string",
+        "idempotency-key": "string"
+    });
+    return await context.client.addReferenceLibraryGrant(compact({
+        projectId: requireProject(context.config),
+        libraryId: requiredString(values["library-id"], "--library-id"),
+        userId: requiredString(values["user-id"], "--user-id"),
+        permissions: referenceLibraryGrantPermissions(values.permission),
+        expiresAt: optionalString(values["expires-at"]),
+        idempotencyKey: requiredString(values["idempotency-key"], "--idempotency-key")
+    }));
+}
+async function referenceLibraryGrantsRevoke(commandArgs, context) {
+    const values = parse(commandArgs, {
+        "library-id": "string",
+        "grant-id": "string",
+        "idempotency-key": "string"
+    });
+    return await context.client.revokeReferenceLibraryGrant({
+        projectId: requireProject(context.config),
+        libraryId: requiredString(values["library-id"], "--library-id"),
+        grantId: requiredString(values["grant-id"], "--grant-id"),
+        idempotencyKey: requiredString(values["idempotency-key"], "--idempotency-key")
+    });
+}
+async function referenceLibraryBindingsAttach(commandArgs, context) {
+    const values = parse(commandArgs, {
+        "library-id": "string",
+        "item-id": "string",
+        "version-id": "string",
+        "binding-id": "string",
+        "reference-id": "string",
+        "target-json": "string",
+        "update-policy": "string",
+        "expected-reference-fingerprint": "string",
+        "idempotency-key": "string"
+    });
+    return await context.client.attachReferenceLibraryProjectBinding(compact({
+        projectId: requireProject(context.config),
+        libraryId: requiredString(values["library-id"], "--library-id"),
+        itemId: requiredString(values["item-id"], "--item-id"),
+        versionId: optionalString(values["version-id"]),
+        bindingId: optionalString(values["binding-id"]),
+        target: referenceLibraryBindingTarget(values),
+        updatePolicy: referenceLibraryUpdatePolicy(values["update-policy"]),
+        expectedReferenceFingerprint: optionalString(values["expected-reference-fingerprint"]),
+        idempotencyKey: requiredString(values["idempotency-key"], "--idempotency-key")
+    }));
+}
+async function referenceLibraryBindingsUpdate(commandArgs, context) {
+    const values = parse(commandArgs, {
+        "binding-id": "string",
+        "to-version-id": "string",
+        "dry-run": "boolean",
+        "idempotency-key": "string"
+    });
+    const dryRun = values["dry-run"] === true;
+    return await context.client.updateReferenceLibraryProjectBinding(compact({
+        projectId: requireProject(context.config),
+        bindingId: requiredString(values["binding-id"], "--binding-id"),
+        toVersionId: optionalString(values["to-version-id"]),
+        dryRun: dryRun || undefined,
+        idempotencyKey: mutationIdempotencyKey(values["idempotency-key"], dryRun)
+    }));
+}
+async function referenceLibraryBindingsDetach(commandArgs, context) {
+    const values = parse(commandArgs, {
+        "binding-id": "string",
+        "delete-materialized-assets": "boolean",
+        "idempotency-key": "string"
+    });
+    return await context.client.detachReferenceLibraryProjectBinding(compact({
+        projectId: requireProject(context.config),
+        bindingId: requiredString(values["binding-id"], "--binding-id"),
+        deleteMaterializedAssets: values["delete-materialized-assets"] === true || undefined,
+        idempotencyKey: requiredString(values["idempotency-key"], "--idempotency-key")
+    }));
+}
+function referenceLibraryBindingTarget(values) {
+    const referenceId = optionalString(values["reference-id"]);
+    const targetJson = optionalString(values["target-json"]);
+    if (referenceId && targetJson) {
+        throw new errors_1.CliError("Use only one of --reference-id or --target-json", {
+            code: "invalid_arguments",
+            exitCode: errors_1.EXIT_CODES.usage
+        });
+    }
+    if (referenceId) {
+        return {
+            artifact: "references",
+            referenceId
+        };
+    }
+    if (!targetJson) {
+        throw new errors_1.CliError("Missing binding target. Pass --reference-id or --target-json.", {
+            code: "missing_required_option",
+            exitCode: errors_1.EXIT_CODES.usage
+        });
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(targetJson);
+    }
+    catch {
+        throw new errors_1.CliError("Invalid --target-json: expected a JSON object", {
+            code: "invalid_arguments",
+            exitCode: errors_1.EXIT_CODES.usage
+        });
+    }
+    if (!isRecord(parsed)) {
+        throw new errors_1.CliError("Invalid --target-json: expected a JSON object", {
+            code: "invalid_arguments",
+            exitCode: errors_1.EXIT_CODES.usage
+        });
+    }
+    return validateReferenceLibraryTargetJson(parsed);
+}
+function referenceLibraryScope(value) {
+    const scope = optionalString(value);
+    if (!scope) {
+        return undefined;
+    }
+    if (REFERENCE_LIBRARY_SCOPES.includes(scope)) {
+        return scope;
+    }
+    throw new errors_1.CliError(`Unsupported reference library scope: ${scope}`, {
+        code: "invalid_arguments",
+        exitCode: errors_1.EXIT_CODES.usage
+    });
+}
+function referenceLibraryCapturePolicy(value) {
+    const capturePolicy = optionalString(value);
+    if (!capturePolicy) {
+        throw new errors_1.CliError("Missing required option --capture-policy", {
+            code: "missing_required_option",
+            exitCode: errors_1.EXIT_CODES.usage
+        });
+    }
+    if (REFERENCE_LIBRARY_CAPTURE_POLICIES.includes(capturePolicy)) {
+        return capturePolicy;
+    }
+    throw new errors_1.CliError(`Unsupported --capture-policy: ${capturePolicy}`, {
+        code: "invalid_arguments",
+        exitCode: errors_1.EXIT_CODES.usage
+    });
+}
+function referenceLibraryAutoSelectFromFlags(values) {
+    const enable = values["auto-select-from-library"] === true;
+    const disable = values["no-auto-select-from-library"] === true;
+    if (enable && disable) {
+        throw new errors_1.CliError("Use only one of --auto-select-from-library or --no-auto-select-from-library", { code: "invalid_arguments", exitCode: errors_1.EXIT_CODES.usage });
+    }
+    if (disable) {
+        return false;
+    }
+    if (enable) {
+        return true;
+    }
+    return undefined;
+}
+function referenceLibraryUpdatePolicy(value) {
+    const updatePolicy = optionalString(value);
+    if (!updatePolicy) {
+        return undefined;
+    }
+    if (REFERENCE_LIBRARY_UPDATE_POLICIES.includes(updatePolicy)) {
+        return updatePolicy;
+    }
+    throw new errors_1.CliError(`Unsupported --update-policy: ${updatePolicy}`, {
+        code: "invalid_arguments",
+        exitCode: errors_1.EXIT_CODES.usage
+    });
+}
+function referenceLibraryGrantPermissions(value) {
+    const permission = optionalString(value);
+    if (!permission) {
+        throw new errors_1.CliError("Missing required option --permission", {
+            code: "missing_required_option",
+            exitCode: errors_1.EXIT_CODES.usage
+        });
+    }
+    if (permission === "can-use" || permission === "admin") {
+        return [...REFERENCE_LIBRARY_GRANT_PRESETS[permission]];
+    }
+    throw new errors_1.CliError(`Unsupported --permission: ${permission}`, {
+        code: "invalid_arguments",
+        exitCode: errors_1.EXIT_CODES.usage
+    });
+}
+function optionalReferenceLibraryConfidence(value, flag) {
+    const raw = optionalString(value);
+    if (!raw) {
+        return undefined;
+    }
+    const confidence = Number(raw);
+    if (!Number.isFinite(confidence) || confidence < 0 || confidence > 1) {
+        throw new errors_1.CliError(`${flag} must be a number between 0 and 1`, {
+            code: "invalid_arguments",
+            exitCode: errors_1.EXIT_CODES.usage
+        });
+    }
+    return confidence;
+}
+function validateReferenceLibraryTargetJson(target) {
+    const artifact = optionalString(target.artifact);
+    if (!artifact) {
+        throw new errors_1.CliError('Invalid --target-json: missing "artifact"', {
+            code: "invalid_arguments",
+            exitCode: errors_1.EXIT_CODES.usage
+        });
+    }
+    if (artifact === "references") {
+        requireTargetString(target, "referenceId", artifact);
+        assertReferenceLibraryTargetKeys(target, artifact, ["artifact", "referenceId"]);
+        return target;
+    }
+    if (artifact === "style-guide") {
+        requireTargetString(target, "styleGuideId", artifact);
+        if (target.variantId !== undefined) {
+            requireTargetString(target, "variantId", artifact);
+        }
+        assertReferenceLibraryTargetKeys(target, artifact, ["artifact", "styleGuideId", "variantId"]);
+        return target;
+    }
+    if (artifact === "distribution") {
+        if (target.platform !== undefined) {
+            requireTargetString(target, "platform", artifact);
+        }
+        assertReferenceLibraryTargetKeys(target, artifact, ["artifact", "platform"]);
+        return target;
+    }
+    throw new errors_1.CliError(`Invalid --target-json: unsupported artifact "${artifact}"`, {
+        code: "invalid_arguments",
+        exitCode: errors_1.EXIT_CODES.usage
+    });
+}
+function requireTargetString(target, key, artifact) {
+    const value = optionalString(target[key]);
+    if (!value) {
+        throw new errors_1.CliError(`Invalid --target-json: ${artifact}.${key} is required`, {
+            code: "invalid_arguments",
+            exitCode: errors_1.EXIT_CODES.usage
+        });
+    }
+    return value;
+}
+function assertReferenceLibraryTargetKeys(target, artifact, allowedKeys) {
+    const allowed = new Set(allowedKeys);
+    for (const key of Object.keys(target)) {
+        if (!allowed.has(key)) {
+            throw new errors_1.CliError(`Invalid --target-json: unsupported ${artifact}.${key}`, {
+                code: "invalid_arguments",
+                exitCode: errors_1.EXIT_CODES.usage
+            });
+        }
+    }
+}
 async function releaseVideoCreate(commandArgs, context) {
     const values = parse(commandArgs, {
         "project-name": "string",
@@ -407,6 +865,7 @@ async function releaseVideoCreate(commandArgs, context) {
         "repo-name": "string",
         "git-sha": "string",
         "release-tag": "string",
+        "bootstrap-selected-project": "boolean",
         preset: "string",
         target: "string",
         platform: "string",
@@ -430,10 +889,11 @@ async function releaseVideoCreate(commandArgs, context) {
         script,
         releaseNotes,
         changelog,
-        repoUrl: optionalString(values["repo-url"]),
+        repoUrl: (0, repo_url_1.canonicalizeRepoUrl)(optionalString(values["repo-url"])),
         repoName: optionalString(values["repo-name"]),
         gitSha: optionalString(values["git-sha"]),
         releaseTag: optionalString(values["release-tag"]),
+        bootstrapSelectedProject: values["bootstrap-selected-project"] === true || undefined,
         preset: optionalString(values.preset),
         target: optionalString(values.target),
         platform: optionalString(values.platform),
@@ -449,24 +909,94 @@ async function releaseVideoCreate(commandArgs, context) {
         ? await createReleaseVideoWithReattach(requestPayload, context)
         : await context.client.createReleaseVideo(requestPayload);
     if (wait && !dryRun) {
+        emitReleaseVideoWaitHandle(response, context);
         return await waitForReleaseVideoRun(response, context);
     }
     await followAgentRunEvents(response, context);
     return response;
 }
+async function releaseVideoPreflight(commandArgs, context) {
+    const values = parse(commandArgs, {
+        "project-name": "string",
+        script: "string",
+        "release-notes": "string",
+        changelog: "string",
+        "repo-url": "string",
+        "repo-name": "string",
+        "git-sha": "string",
+        "release-tag": "string",
+        "bootstrap-selected-project": "boolean",
+        preset: "string",
+        target: "string",
+        platform: "string",
+        privacy: "string",
+        "force-regenerate": "boolean",
+        "override-audit": "boolean",
+        "audit-override-rationale": "string",
+        "idempotency-key": "string"
+    });
+    const script = await fileContentRequest(optionalString(values.script));
+    const releaseNotes = await fileContentRequest(optionalString(values["release-notes"]));
+    const changelog = await fileContentRequest(optionalString(values.changelog));
+    return await context.client.preflightReleaseVideo(compact({
+        projectName: optionalString(values["project-name"]),
+        projectId: context.config.projectIdSource === "flag" || context.config.projectIdSource === "env" ? context.config.projectId : undefined,
+        script,
+        releaseNotes,
+        changelog,
+        repoUrl: (0, repo_url_1.canonicalizeRepoUrl)(optionalString(values["repo-url"])),
+        repoName: optionalString(values["repo-name"]),
+        gitSha: optionalString(values["git-sha"]),
+        releaseTag: optionalString(values["release-tag"]),
+        bootstrapSelectedProject: values["bootstrap-selected-project"] === true || undefined,
+        preset: optionalString(values.preset),
+        target: optionalString(values.target),
+        platform: optionalString(values.platform),
+        privacy: optionalString(values.privacy),
+        forceRegenerate: values["force-regenerate"] === true || undefined,
+        overrideAudit: values["override-audit"] === true || undefined,
+        auditOverrideRationale: optionalString(values["audit-override-rationale"]),
+        idempotencyKey: optionalString(values["idempotency-key"]),
+        wait: true
+    }));
+}
 async function releaseVideoStatus(commandArgs, context) {
     const values = parse(commandArgs, { "run-id": "string" });
     const runId = requiredString(values["run-id"], "--run-id");
     const jobResponse = await context.client.getJob({ jobId: runId });
     return releaseVideoStatusFromJob(jobResponse, runId);
 }
+function emitReleaseVideoWaitHandle(response, context) {
+    const writer = context.waitNotice ?? context.notice;
+    if (!writer) {
+        return;
+    }
+    const runId = agentRunIdFromResponse(response);
+    if (!runId) {
+        return;
+    }
+    const data = readEnvelopeData(response);
+    const project = isRecord(data.project) ? data.project : {};
+    const projectId = optionalString(project.id) ??
+        optionalString(data.projectId) ??
+        readNestedString(data, ["pipeline", "run", "projectId"]);
+    const status = optionalString(data.status) ??
+        readNestedString(data, ["pipeline", "run", "status"]);
+    writer(`[pds] release-video run handle: runId=${runId}` +
+        `${projectId ? ` projectId=${projectId}` : ""}` +
+        `${status ? ` status=${status}` : ""}`);
+    writer(`[pds] recover: pds release-video status --run-id ${runId} --json`);
+    writer(`[pds] watch: pds jobs watch --run-id ${runId} --jsonl`);
+}
 async function createReleaseVideoWithReattach(request, context) {
     let attempt = 0;
     let delayMs = RELEASE_VIDEO_REATTACH_INITIAL_DELAY_MS;
     let sawDroppedCreate = false;
     while (true) {
         try {
-            return await context.client.createReleaseVideo(request);
+            return await context.client.createReleaseVideo(request, {
+                timeoutMs: context.config.timeoutMs
+            });
         }
         catch (error) {
             if (isRecoverableCreateWaitDrop(error)) {
@@ -523,7 +1053,12 @@ function parse(commandArgs, options) {
             args: commandArgs,
             allowPositionals: false,
             strict: true,
-            options: Object.fromEntries(Object.entries(options).map(([name, type]) => [name, { type }]))
+            options: Object.fromEntries(Object.entries(options).map(([name, type]) => [
+                name,
+                type === "string[]"
+                    ? { type: "string", multiple: true }
+                    : { type }
+            ]))
         }).values;
     }
     catch (error) {
@@ -560,6 +1095,19 @@ function requiredRunOrJobId(values) {
 function optionalString(value) {
     return typeof value === "string" && value.length > 0 ? value : undefined;
 }
+function optionalStringList(value) {
+    const values = Array.isArray(value)
+        ? value
+        : typeof value === "string"
+            ? [value]
+            : [];
+    const items = values
+        .filter((item) => typeof item === "string")
+        .flatMap((item) => item.split(","))
+        .map((item) => item.trim())
+        .filter(Boolean);
+    return items.length > 0 ? items : undefined;
+}
 function mutationIdempotencyKey(value, dryRun) {
     if (dryRun) {
         return optionalString(value);
@@ -597,28 +1145,349 @@ async function followAgentRunEvents(response, context) {
         onEvent: context.emitJsonlEvent
     });
 }
-async function waitForReleaseVideoRun(response, context) {
-    const runId = agentRunIdFromResponse(response);
-    if (!runId) {
-        return response;
-    }
-    let confirmations = 0;
-    const seenEvents = new Set();
-    const emitRunEvent = context.emitJsonlEvent
-        ? (event) => {
-            const eventKey = JSON.stringify(event);
-            if (seenEvents.has(eventKey)) {
-                return;
-            }
-            context.emitJsonlEvent?.(event);
-            seenEvents.add(eventKey);
-        }
-        : undefined;
+async function publishDistributionWithReattach(request, context) {
+    let attempt = 0;
+    let delayMs = DISTRIBUTION_PUBLISH_REATTACH_INITIAL_DELAY_MS;
+    let sawDroppedCreate = false;
     while (true) {
-        await context.client.watchJob({
-            jobId: runId,
-            onEvent: emitRunEvent
+        try {
+            return await context.client.publishDistribution(request, {
+                timeoutMs: context.config.timeoutMs
+            });
+        }
+        catch (error) {
+            if (isRecoverableCreateWaitDrop(error)) {
+                if (attempt >= DISTRIBUTION_PUBLISH_REATTACH_MAX_ATTEMPTS) {
+                    throw error;
+                }
+                attempt += 1;
+                sawDroppedCreate = true;
+                context.emitJsonlEvent?.({
+                    type: "wait_reconnect",
+                    command: "distribution.publish",
+                    reason: "create_request_dropped"
+                });
+                continue;
+            }
+            if (sawDroppedCreate && isPendingIdempotencyReplayWithoutRunId(error)) {
+                if (attempt >= DISTRIBUTION_PUBLISH_REATTACH_MAX_ATTEMPTS) {
+                    throw new errors_1.CliError("Distribution publish run handle was not available before retry limit", {
+                        code: "distribution_publish_reattach_timeout",
+                        exitCode: errors_1.EXIT_CODES.timeout,
+                        details: {
+                            attempts: attempt,
+                            reason: "idempotency_in_progress_without_run_id"
+                        }
+                    });
+                }
+                context.emitJsonlEvent?.({
+                    type: "wait_reconnect",
+                    command: "distribution.publish",
+                    reason: "idempotency_in_progress_without_run_id",
+                    attempt: attempt + 1
+                });
+                await (context.sleep ?? defaultSleep)(delayMs);
+                delayMs = Math.min(delayMs * 2, DISTRIBUTION_PUBLISH_REATTACH_MAX_DELAY_MS);
+                attempt += 1;
+                continue;
+            }
+            throw error;
+        }
+    }
+}
+async function waitForDistributionPublishRun(response, context) {
+    const runId = agentRunIdFromResponse(response);
+    if (!runId) {
+        return response;
+    }
+    if (isTerminalDistributionPublishResponse(response)) {
+        await followAgentRunEvents(response, context);
+        return response;
+    }
+    let confirmations = 0;
+    const seenEvents = new Set();
+    const emitRunEvent = context.emitJsonlEvent
+        ? (event) => {
+            const eventKey = JSON.stringify(event);
+            if (seenEvents.has(eventKey)) {
+                return;
+            }
+            context.emitJsonlEvent?.(event);
+            seenEvents.add(eventKey);
+        }
+        : undefined;
+    while (true) {
+        try {
+            await context.client.watchJob({
+                jobId: runId,
+                onEvent: emitRunEvent
+            });
+        }
+        catch (error) {
+            if (!isRecoverableWatchDrop(error)) {
+                throw error;
+            }
+            context.emitJsonlEvent?.({
+                type: "wait_reconnect",
+                command: "distribution.publish",
+                reason: "event_stream_dropped",
+                runId,
+                attempt: confirmations + 1
+            });
+        }
+        const jobResponse = await context.client.getJob({ jobId: runId });
+        const run = readJobRun(jobResponse);
+        assertTerminalDistributionPublishRunSucceeded(run, runId);
+        const merged = mergeDistributionPublishRun(response, jobResponse);
+        if (isTerminalDistributionPublishRun(run)) {
+            return merged;
+        }
+        if (confirmations >= DISTRIBUTION_PUBLISH_WAIT_MAX_CONFIRMATIONS) {
+            throw new errors_1.CliError("Distribution publish run did not reach a terminal state before wait limit", {
+                code: "distribution_publish_wait_timeout",
+                exitCode: errors_1.EXIT_CODES.timeout,
+                details: {
+                    runId,
+                    status: run ? optionalString(run.status) ?? null : null,
+                    confirmations
+                }
+            });
+        }
+        context.emitJsonlEvent?.({
+            type: "wait_reconnect",
+            command: "distribution.publish",
+            reason: "event_stream_closed_before_terminal",
+            runId,
+            status: run ? optionalString(run.status) ?? null : null,
+            attempt: confirmations + 1
+        });
+        await (context.sleep ?? defaultSleep)(DISTRIBUTION_PUBLISH_WAIT_POLL_MS);
+        confirmations += 1;
+    }
+}
+async function createPipelineRunWithReattach(request, context) {
+    let attempt = 0;
+    let delayMs = PIPELINE_REATTACH_INITIAL_DELAY_MS;
+    let sawDroppedCreate = false;
+    while (true) {
+        try {
+            return await context.client.runPipeline(request, {
+                timeoutMs: context.config.timeoutMs
+            });
+        }
+        catch (error) {
+            if (isRecoverableCreateWaitDrop(error)) {
+                if (attempt >= PIPELINE_REATTACH_MAX_ATTEMPTS) {
+                    throw error;
+                }
+                attempt += 1;
+                sawDroppedCreate = true;
+                context.emitJsonlEvent?.({
+                    type: "wait_reconnect",
+                    command: "pipeline.run",
+                    reason: "create_request_dropped"
+                });
+                continue;
+            }
+            if (sawDroppedCreate && isPendingIdempotencyReplayWithoutRunId(error)) {
+                if (attempt >= PIPELINE_REATTACH_MAX_ATTEMPTS) {
+                    throw new errors_1.CliError("Pipeline run handle was not available before retry limit", {
+                        code: "pipeline_reattach_timeout",
+                        exitCode: errors_1.EXIT_CODES.timeout,
+                        details: {
+                            attempts: attempt,
+                            reason: "idempotency_in_progress_without_run_id"
+                        }
+                    });
+                }
+                context.emitJsonlEvent?.({
+                    type: "wait_reconnect",
+                    command: "pipeline.run",
+                    reason: "idempotency_in_progress_without_run_id",
+                    attempt: attempt + 1
+                });
+                await (context.sleep ?? defaultSleep)(delayMs);
+                delayMs = Math.min(delayMs * 2, PIPELINE_REATTACH_MAX_DELAY_MS);
+                attempt += 1;
+                continue;
+            }
+            throw error;
+        }
+    }
+}
+async function waitForPipelineRun(response, context) {
+    const runId = agentRunIdFromResponse(response);
+    if (!runId) {
+        return response;
+    }
+    let confirmations = 0;
+    const seenEvents = new Set();
+    const emitRunEvent = context.emitJsonlEvent
+        ? (event) => {
+            const eventKey = JSON.stringify(event);
+            if (seenEvents.has(eventKey)) {
+                return;
+            }
+            context.emitJsonlEvent?.(event);
+            seenEvents.add(eventKey);
+        }
+        : undefined;
+    while (true) {
+        try {
+            await context.client.watchJob({
+                jobId: runId,
+                onEvent: emitRunEvent
+            });
+        }
+        catch (error) {
+            if (!isRecoverableWatchDrop(error)) {
+                throw error;
+            }
+            context.emitJsonlEvent?.({
+                type: "wait_reconnect",
+                command: "pipeline.run",
+                reason: "event_stream_dropped",
+                runId,
+                attempt: confirmations + 1
+            });
+        }
+        const jobResponse = await context.client.getJob({ jobId: runId });
+        const run = readJobRun(jobResponse);
+        assertTerminalPipelineRunSucceeded(run, runId);
+        const merged = mergePipelineRun(response, jobResponse);
+        if (isTerminalJobRun(run)) {
+            return merged;
+        }
+        if (confirmations >= PIPELINE_WAIT_MAX_CONFIRMATIONS) {
+            throw new errors_1.CliError("Pipeline run did not reach a terminal state before wait limit", {
+                code: "pipeline_wait_timeout",
+                exitCode: errors_1.EXIT_CODES.timeout,
+                details: {
+                    runId,
+                    status: run ? optionalString(run.status) ?? null : null,
+                    confirmations
+                }
+            });
+        }
+        context.emitJsonlEvent?.({
+            type: "wait_reconnect",
+            command: "pipeline.run",
+            reason: "event_stream_closed_before_terminal",
+            runId,
+            status: run ? optionalString(run.status) ?? null : null,
+            attempt: confirmations + 1
+        });
+        await (context.sleep ?? defaultSleep)(PIPELINE_WAIT_POLL_MS);
+        confirmations += 1;
+    }
+}
+async function watchJobUntilTerminal(jobId, context) {
+    let confirmations = 0;
+    const events = [];
+    const seenEvents = new Set();
+    let sawTerminalEvent = false;
+    const emitJobEvent = (event) => {
+        const eventKey = JSON.stringify(event);
+        if (seenEvents.has(eventKey)) {
+            return;
+        }
+        seenEvents.add(eventKey);
+        if (isTerminalWatchEvent(event)) {
+            sawTerminalEvent = true;
+        }
+        events.push(event);
+        context.emitJsonlEvent?.(event);
+    };
+    while (true) {
+        let streamDropped = false;
+        try {
+            const watchResponse = await context.client.watchJob({
+                jobId,
+                onEvent: emitJobEvent
+            });
+            collectWatchEvents(watchResponse, emitJobEvent);
+        }
+        catch (error) {
+            if (!isRecoverableWatchDrop(error)) {
+                throw error;
+            }
+            streamDropped = true;
+        }
+        const jobResponse = await context.client.getJob({ jobId });
+        const run = readJobRun(jobResponse);
+        if (isTerminalJobRun(run)) {
+            if (!sawTerminalEvent) {
+                emitJobEvent(terminalJobWatchEvent(run, jobId));
+            }
+            return context.emitJsonlEvent ? { events: [] } : { events };
+        }
+        if (confirmations >= JOBS_WATCH_MAX_CONFIRMATIONS) {
+            throw new errors_1.CliError("Agent job did not reach a terminal state before watch limit", {
+                code: "job_watch_timeout",
+                exitCode: errors_1.EXIT_CODES.timeout,
+                details: {
+                    runId: jobId,
+                    status: run ? optionalString(run.status) ?? null : null,
+                    confirmations
+                }
+            });
+        }
+        context.emitJsonlEvent?.({
+            type: "wait_reconnect",
+            command: "jobs.watch",
+            reason: streamDropped
+                ? "event_stream_dropped"
+                : "event_stream_closed_before_terminal",
+            runId: jobId,
+            status: run ? optionalString(run.status) ?? null : null,
+            attempt: confirmations + 1
         });
+        await (context.sleep ?? defaultSleep)(JOBS_WATCH_POLL_MS);
+        confirmations += 1;
+    }
+}
+async function waitForReleaseVideoRun(response, context) {
+    const runId = agentRunIdFromResponse(response);
+    if (!runId) {
+        return response;
+    }
+    let confirmations = 0;
+    const seenEvents = new Set();
+    const emitRunEvent = context.emitJsonlEvent
+        ? (event) => {
+            const eventKey = JSON.stringify(event);
+            if (seenEvents.has(eventKey)) {
+                return;
+            }
+            context.emitJsonlEvent?.(event);
+            seenEvents.add(eventKey);
+        }
+        : undefined;
+    while (true) {
+        try {
+            await context.client.watchJob({
+                jobId: runId,
+                onEvent: emitRunEvent
+            });
+        }
+        catch (error) {
+            if (!isRecoverableWatchDrop(error)) {
+                throw error;
+            }
+            context.emitJsonlEvent?.({
+                type: "wait_reconnect",
+                command: "release-video.create",
+                reason: "event_stream_dropped",
+                runId,
+                attempt: confirmations + 1
+            });
+            emitWaitStatusNotice(context, {
+                command: "release-video.create",
+                runId,
+                reason: "event stream dropped; polling durable status",
+                attempt: confirmations + 1
+            });
+        }
         const jobResponse = await context.client.getJob({ jobId: runId });
         const run = readJobRun(jobResponse);
         assertTerminalReleaseVideoRunSucceeded(run, runId);
@@ -630,11 +1499,13 @@ async function waitForReleaseVideoRun(response, context) {
             throw new errors_1.CliError("Release video run did not reach a terminal state before wait limit", {
                 code: "release_video_wait_timeout",
                 exitCode: errors_1.EXIT_CODES.timeout,
-                details: {
+                details: compact({
                     runId,
+                    eventsUrl: releaseVideoEventsUrl(response, run),
                     status: run ? optionalString(run.status) ?? null : null,
+                    activeStep: activeStepId(run),
                     confirmations
-                }
+                })
             });
         }
         context.emitJsonlEvent?.({
@@ -645,26 +1516,144 @@ async function waitForReleaseVideoRun(response, context) {
             status: run ? optionalString(run.status) ?? null : null,
             attempt: confirmations + 1
         });
+        emitWaitStatusNotice(context, {
+            command: "release-video.create",
+            runId,
+            reason: "event stream closed before terminal state",
+            status: run ? optionalString(run.status) ?? null : null,
+            activeStep: activeStepId(run),
+            attempt: confirmations + 1
+        });
         await (context.sleep ?? defaultSleep)(RELEASE_VIDEO_WAIT_POLL_MS);
         confirmations += 1;
     }
 }
+function emitWaitStatusNotice(context, input) {
+    const writer = context.waitNotice ?? context.notice;
+    if (!writer) {
+        return;
+    }
+    writer(`[pds] ${input.command} wait: ${input.reason}; ` +
+        `runId=${input.runId}` +
+        `${input.status ? ` status=${input.status}` : ""}` +
+        `${input.activeStep ? ` activeStep=${input.activeStep}` : ""}` +
+        ` attempt=${input.attempt}`);
+}
+function releaseVideoEventsUrl(response, run) {
+    return optionalString(run?.eventsUrl) ??
+        readNestedString(readEnvelopeData(response), ["pipeline", "run", "eventsUrl"]);
+}
+function activeStepId(run) {
+    if (!run || !Array.isArray(run.steps)) {
+        return undefined;
+    }
+    const activeStep = run.steps.find((step) => isRecord(step) && step.status === "running");
+    return isRecord(activeStep)
+        ? optionalString(activeStep.id) ?? optionalString(activeStep.stage)
+        : undefined;
+}
 function agentRunIdFromResponse(value) {
     const data = readEnvelopeData(value);
     return (optionalString(data.runId) ??
         runIdFromNested(data.agentRun) ??
         runIdFromNested(data.pipeline, "run"));
 }
-function mergeReleaseVideoRun(response, jobResponse) {
+function isTerminalDistributionPublishResponse(response) {
+    const data = readEnvelopeData(response);
+    const status = optionalString(data.status);
+    return isTerminalAgentRunStatus(status);
+}
+function mergeDistributionPublishRun(response, jobResponse) {
     const run = readJobRun(jobResponse);
     if (!run || !isRecord(response)) {
         return response;
     }
+    const data = readEnvelopeData(response);
+    const terminalResult = isRecord(run.terminalResult) ? run.terminalResult : {};
+    const responseAgentRun = isRecord(data.agentRun) ? data.agentRun : {};
+    const runId = optionalString(run.runId) ??
+        optionalString(run.id) ??
+        agentRunIdFromResponse(response);
+    const normalizedAgentRun = {
+        ...responseAgentRun,
+        ...run,
+        ...(runId ? { runId } : {})
+    };
+    const responsePublishStatus = isRecord(data.publishStatus) ? data.publishStatus : {};
+    const terminalPublishStatus = isRecord(terminalResult.publishStatus)
+        ? terminalResult.publishStatus
+        : undefined;
+    const mergedData = compact({
+        ...data,
+        ...terminalResult,
+        status: optionalString(run.status) ??
+            optionalString(terminalResult.status) ??
+            optionalString(data.status) ??
+            "running",
+        publishStatus: terminalPublishStatus
+            ? {
+                ...responsePublishStatus,
+                ...terminalPublishStatus
+            }
+            : data.publishStatus,
+        agentRun: normalizedAgentRun
+    });
+    if (isRecord(response.data)) {
+        return {
+            ...response,
+            data: mergedData
+        };
+    }
+    return mergedData;
+}
+function mergePipelineRun(response, jobResponse) {
+    const run = readJobRun(jobResponse);
+    if (!run || !isRecord(response)) {
+        return response;
+    }
+    const runId = optionalString(run.runId) ??
+        optionalString(run.id) ??
+        agentRunIdFromResponse(response);
     const normalizedRun = {
         ...run,
-        runId: optionalString(run.runId) ?? optionalString(run.id)
+        ...(runId ? { runId } : {})
     };
     const data = readEnvelopeData(response);
+    const mergedData = compact({
+        ...data,
+        runId,
+        projectId: optionalString(run.projectId) ?? optionalString(data.projectId),
+        target: optionalString(run.target) ?? optionalString(data.target),
+        status: optionalString(run.status) ?? optionalString(data.status) ?? "running",
+        run: normalizedRun,
+        steps: Array.isArray(run.steps) ? run.steps : data.steps,
+        terminalResult: run.terminalResult !== undefined
+            ? run.terminalResult
+            : data.terminalResult
+    });
+    if (isRecord(response.data)) {
+        return {
+            ...response,
+            data: mergedData
+        };
+    }
+    return mergedData;
+}
+function mergeReleaseVideoRun(response, jobResponse) {
+    const run = readJobRun(jobResponse);
+    if (!run || !isRecord(response)) {
+        return response;
+    }
+    const data = readEnvelopeData(response);
+    const responsePipeline = isRecord(data.pipeline) ? data.pipeline : {};
+    const responseRun = isRecord(responsePipeline.run) ? responsePipeline.run : {};
+    const normalizedRun = {
+        ...responseRun,
+        ...run,
+        runId: optionalString(run.runId) ??
+            optionalString(run.id) ??
+            optionalString(responseRun.runId)
+    };
     if (!isRecord(data.pipeline)) {
         return response;
     }
@@ -787,6 +1776,70 @@ function readJobRun(value) {
     }
     return null;
 }
+function collectWatchEvents(value, onEvent) {
+    if (!isRecord(value) || !Array.isArray(value.events)) {
+        return;
+    }
+    for (const event of value.events) {
+        onEvent(event);
+    }
+}
+function isTerminalWatchEvent(event) {
+    if (!isRecord(event)) {
+        return false;
+    }
+    const type = optionalString(event.type);
+    return type === "run_succeeded" ||
+        type === "run_failed" ||
+        type === "run_cancelled" ||
+        type === "job_terminal";
+}
+function terminalJobWatchEvent(run, fallbackRunId) {
+    return {
+        type: "job_terminal",
+        command: "jobs.watch",
+        runId: optionalString(run?.runId) ??
+            optionalString(run?.id) ??
+            fallbackRunId,
+        status: run ? optionalString(run.status) ?? null : null
+    };
+}
+function assertTerminalDistributionPublishRunSucceeded(run, fallbackRunId) {
+    if (!run) {
+        return;
+    }
+    const status = optionalString(run.status);
+    if (!status || status === "succeeded") {
+        return;
+    }
+    if (isTerminalAgentRunStatus(status)) {
+        const error = isRecord(run.error) ? run.error : null;
+        const publicError = publicReleaseVideoFailureError(error);
+        const terminalCode = status === "timed_out"
+            ? "timeout"
+            : status === "cancelled"
+                ? "cancelled"
+                : undefined;
+        const errorCode = optionalString(error?.code);
+        const code = terminalCode ??
+            errorCode ??
+            "agent_run_failed";
+        const message = errorCode === code
+            ? optionalString(error?.message) ?? distributionPublishFailureMessage(status)
+            : distributionPublishFailureMessage(status);
+        throw new errors_1.CliError(message, {
+            code,
+            exitCode: (0, errors_1.mapApiErrorToExitCode)(code, undefined),
+            details: compact({
+                runId: optionalString(run.runId) ?? optionalString(run.id) ?? fallbackRunId,
+                status,
+                failedStage: failedStepStage(run),
+                logRef: pipelineFailureLogRef(run),
+                error: publicError
+            })
+        });
+    }
+}
 function assertTerminalReleaseVideoRunSucceeded(run, fallbackRunId) {
     if (!run) {
         return;
@@ -823,6 +1876,42 @@ function assertTerminalReleaseVideoRunSucceeded(run, fallbackRunId) {
         });
     }
 }
+function assertTerminalPipelineRunSucceeded(run, fallbackRunId) {
+    if (!run) {
+        return;
+    }
+    const status = optionalString(run.status);
+    if (!status || status === "succeeded") {
+        return;
+    }
+    if (status === "failed" || status === "cancelled" || status === "timed_out") {
+        const error = isRecord(run.error) ? run.error : null;
+        const publicError = publicReleaseVideoFailureError(error);
+        const terminalCode = status === "timed_out"
+            ? "timeout"
+            : status === "cancelled"
+                ? "cancelled"
+                : undefined;
+        const errorCode = optionalString(error?.code);
+        const code = terminalCode ??
+            errorCode ??
+            "agent_run_failed";
+        const message = errorCode === code
+            ? optionalString(error?.message) ?? pipelineRunFailureMessage(status)
+            : pipelineRunFailureMessage(status);
+        throw new errors_1.CliError(message, {
+            code,
+            exitCode: (0, errors_1.mapApiErrorToExitCode)(code, undefined),
+            details: compact({
+                runId: optionalString(run.runId) ?? optionalString(run.id) ?? fallbackRunId,
+                status,
+                failedStage: failedStepStage(run),
+                logRef: pipelineFailureLogRef(run),
+                error: publicError
+            })
+        });
+    }
+}
 function isTerminalReleaseVideoRun(run) {
     const status = run ? optionalString(run.status) : undefined;
     return status === "succeeded" ||
@@ -830,6 +1919,56 @@ function isTerminalReleaseVideoRun(run) {
         status === "cancelled" ||
         status === "timed_out";
 }
+function isTerminalPipelineRun(run) {
+    return isTerminalJobRun(run);
+}
+function isTerminalDistributionPublishRun(run) {
+    return isTerminalJobRun(run);
+}
+function isTerminalJobRun(run) {
+    const status = run ? optionalString(run.status) : undefined;
+    return isTerminalAgentRunStatus(status);
+}
+function isTerminalAgentRunStatus(status) {
+    return status === "succeeded" ||
+        status === "failed" ||
+        status === "cancelled" ||
+        status === "timed_out";
+}
+function distributionPublishFailureMessage(status) {
+    if (status === "timed_out") {
+        return "Distribution publish run timed out";
+    }
+    if (status === "cancelled") {
+        return "Distribution publish run cancelled";
+    }
+    return "Distribution publish run failed";
+}
+function pipelineRunFailureMessage(status) {
+    if (status === "timed_out") {
+        return "Pipeline run timed out";
+    }
+    if (status === "cancelled") {
+        return "Pipeline run cancelled";
+    }
+    return "Pipeline run failed";
+}
+function pipelineFailureLogRef(run) {
+    const error = isRecord(run.error) ? run.error : null;
+    const details = isRecord(error?.details) ? error.details : null;
+    if (isRecord(details?.logRef)) {
+        return details.logRef;
+    }
+    const failedStage = failedStepStage(run);
+    const runId = optionalString(run.runId) ?? optionalString(run.id);
+    if (!failedStage || !runId) {
+        return undefined;
+    }
+    return {
+        runId,
+        stage: failedStage,
+    };
+}
 function releaseRunFailureMessage(status) {
     if (status === "timed_out") {
         return "Release video run timed out";
@@ -910,6 +2049,12 @@ function isRecoverableCreateWaitDrop(error) {
     }
     return error instanceof TypeError || isTransportLikeError(error);
 }
+function isRecoverableWatchDrop(error) {
+    if (error instanceof errors_1.CliError && error.code === "watch_reconnect_exhausted") {
+        return true;
+    }
+    return isRecoverableCreateWaitDrop(error);
+}
 function isClientTimeoutDrop(error) {
     return error.code === "timeout" &&
         error.status === undefined &&