makefx 1.4.0 → 1.5.0

package/makefx.mjs

@@ -660,6 +660,9 @@ function createVariantRef(name, assetId, variantId) {
 function createDraftRef(name, draftId) {
 	return `draft:${slugify(name, "draft")}~${compactIdPrefix(draftId)}`;
 }
+function createGraphRunRef(runId) {
+	return `graph-run:${compactIdPrefix(runId)}`;
+}
 function parseAssetRef(value) {
 	const match = /^asset:[^~]+~([a-z0-9]{4,8})$/u.exec(value);
 	return match ? { idPrefix: match[1] } : null;
@@ -4399,6 +4402,7 @@ var WebSocketClient = class WebSocketClient {
 	chatHandlers = /* @__PURE__ */ new Map();
 	generateHandlers = /* @__PURE__ */ new Map();
 	earlyTerminalVariants = /* @__PURE__ */ new Map();
+	draftRunStartsAwaitingVariant = /* @__PURE__ */ new Set();
 	variantCompletionHandlers = /* @__PURE__ */ new Map();
 	describeHandlers = /* @__PURE__ */ new Map();
 	compareHandlers = /* @__PURE__ */ new Map();
@@ -4724,7 +4728,7 @@ var WebSocketClient = class WebSocketClient {
 		return handled;
 	}
 	hasRequestsAwaitingStarted() {
-		return this.generateHandlers.size > 0;
+		return this.generateHandlers.size > 0 || this.draftRunStartsAwaitingVariant.size > 0;
 	}
 	clearOrphanedEarlyTerminalVariants() {
 		if (!this.hasRequestsAwaitingStarted()) this.earlyTerminalVariants.clear();
@@ -4869,6 +4873,58 @@ var WebSocketClient = class WebSocketClient {
 			bindingId
 		}, (msg) => msg.type === "binding:cleared" && msg.draftId === draftId && msg.bindingId === bindingId);
 	}
+	async runDraft(draftId, requestId, onStarted) {
+		if (onStarted) this.draftRunStartsAwaitingVariant.add(requestId);
+		try {
+			const result = await this.awaitServerMessage({
+				type: "drafts.run",
+				draftId,
+				requestId,
+				source: "cli"
+			}, (msg) => (msg.type === "drafts.run_started" || msg.type === "drafts.run_error") && msg.requestId === requestId);
+			if (result.type === "drafts.run_error") throw new Error(`${result.code}: ${result.error}`);
+			onStarted?.(result);
+			return result;
+		} finally {
+			this.draftRunStartsAwaitingVariant.delete(requestId);
+			this.clearOrphanedEarlyTerminalVariants();
+		}
+	}
+	async runGraph(input) {
+		const result = await this.awaitServerMessage({
+			type: "graph.run",
+			...input,
+			source: "cli"
+		}, (msg) => msg.type === "graph.run_started" && msg.run.request_id === input.requestId || msg.type === "graph.run_error" && msg.requestId === input.requestId);
+		if (result.type === "graph.run_error") {
+			const detail = result.failures.map((failure) => `${failure.draftId}: ${failure.error}`).join("; ");
+			throw new Error(`${result.code}: ${detail || result.error}`);
+		}
+		return {
+			type: "graph.run_status",
+			run: result.run,
+			drafts: result.drafts
+		};
+	}
+	async getGraphRunStatus(runRef) {
+		return this.awaitServerMessage({
+			type: "graph.status",
+			runRef
+		}, (msg) => msg.type === "graph.run_status");
+	}
+	async cancelGraphRun(runId) {
+		return this.awaitServerMessage({
+			type: "graph.cancel",
+			runId
+		}, (msg) => msg.type === "graph.run_status" && msg.run.id === runId);
+	}
+	async waitForGraphRun(runRef, runId, timeoutMs = GENERATION_REQUEST_TIMEOUT_MS) {
+		await this.awaitServerMessage({
+			type: "graph.status",
+			runRef
+		}, (msg) => (msg.type === "graph.run_status" && msg.run.id === runId || msg.type === "graph.run_progress" && msg.run.id === runId) && msg.run.status !== "running", timeoutMs);
+		return this.getGraphRunStatus(runRef);
+	}
 	async setCanvasLens(lens) {
 		return (await this.awaitServerMessage({
 			type: "canvas.set_lens",
@@ -4992,6 +5048,11 @@ var WebSocketClient = class WebSocketClient {
 				reject,
 				timeout
 			});
+			const earlyTerminal = this.earlyTerminalVariants.get(params.variantId);
+			if (earlyTerminal) {
+				this.earlyTerminalVariants.delete(params.variantId);
+				this.handleTerminalVariant(earlyTerminal);
+			}
 		});
 	}
 	cancelFollowVariant(variantId, requestId) {
@@ -6017,6 +6078,11 @@ var VIDEO_GENERATION_RESOLUTIONS = [
 ];
 var ALL_VIDEO_GENERATION_RESOLUTIONS = ["480p", ...VIDEO_GENERATION_RESOLUTIONS];
 var KLING_VIDEO_GENERATION_RESOLUTIONS = ["720p", "1080p"];
+var VIDEO_GENERATION_DURATION_SECONDS = [
+	4,
+	6,
+	8
+];
 var SEEDANCE_2_DURATION_SECONDS = [
 	4,
 	5,
@@ -6042,6 +6108,12 @@ var VIDEO_MODEL_SELECTIONS = [
 	"kling",
 	"fal-seedance"
 ];
+var VIDEO_MODEL_LABELS = {
+	"veo-3.1": "Veo 3.1",
+	"omni-flash": "Omni Flash",
+	kling: "Kling 3.0",
+	"fal-seedance": "fal.ai Seedance v1 (text-to-video)"
+};
 var VIDEO_MODEL_SUPPORTED_OPERATIONS = {
 	"veo-3.1": [
 		"generate",
@@ -6069,6 +6141,7 @@ var VIDEO_GENERATION_RESOLUTIONS_BY_TIER = {
 	fast: VIDEO_GENERATION_RESOLUTIONS,
 	lite: ["720p", "1080p"]
 };
+var DEFAULT_VIDEO_GENERATION_RESOLUTION = "720p";
 var DEFAULT_VIDEO_GENERATION_TIER = "generate";
 var DEFAULT_VIDEO_MODEL_SELECTION = "veo-3.1";
 function normalizeVideoGenerationAspectRatio(value) {
@@ -6144,6 +6217,12 @@ function isFalSeedanceV1VideoGenerationModel(model) {
 function isFalSeedance2VideoGenerationModel(model) {
 	return typeof model === "string" && getSeedance2CapabilityByEndpoint(model) !== void 0;
 }
+function getVideoGenerationMaxReferenceImages(model) {
+	if (isFalSeedanceV1VideoGenerationModel(model)) return 0;
+	if (isFalSeedance2VideoGenerationModel(model)) return getSeedance2CapabilityByEndpoint(model)?.references.find((reference) => reference.mediaKind === "image")?.maxCount ?? 0;
+	if (isKlingVideoGenerationModel(model)) return 1;
+	return 3;
+}
 function isVideoOperationSupportedByModel(model, operation) {
 	const seedanceCapability = getSeedance2CapabilityByEndpoint(model);
 	if (seedanceCapability) return seedanceCapability.operations.includes(operation);
@@ -6234,6 +6313,9 @@ var IMAGE_MODEL_CAPABILITIES = {
 function isImageModelSelection(value) {
 	return IMAGE_MODEL_SELECTIONS.includes(value);
 }
+function isImageModelId(value) {
+	return Object.values(IMAGE_MODEL_IDS).includes(value);
+}
 function isImageSize(value) {
 	return IMAGE_SIZES.includes(value);
 }
@@ -6382,9 +6464,21 @@ var AUDIO_FORGE_MEDIA_MODES = MEDIA_OPERATION_MATRIX.filter((entry) => entry.med
 function getMediaOperationEntry(mode) {
 	return ENTRY_BY_MODE.get(mode) ?? MEDIA_OPERATION_MATRIX[0];
 }
+function getMediaKindForForgeMode(mode) {
+	return getMediaOperationEntry(mode).mediaKind;
+}
 function isAudioForgeMediaMode(value) {
 	return AUDIO_FORGE_MEDIA_MODES.includes(value);
 }
+function getForgeModeForAudioAssetType(assetType) {
+	switch (assetType) {
+		case "speech":
+		case "dialogue":
+		case "music":
+		case "sfx": return assetType;
+		default: return "speech";
+	}
+}
 function getCliGenerationProfile(namespace) {
 	const profile = PROFILE_BY_NAMESPACE.get(namespace);
 	if (!profile) throw new Error(`Unknown CLI generation namespace: ${namespace}`);
@@ -6489,49 +6583,49 @@ async function executeForgeCommand(command, parsed, deps = defaultDeps$12, optio
 		client.disconnect();
 	}
 }
+var CLI_GENERATION_COMMON_OPTIONS = [
+	"env",
+	"local",
+	"space",
+	"force",
+	"name",
+	"type",
+	"o",
+	"output",
+	"collection"
+];
+var CLI_GENERATION_MEDIA_OPTIONS = {
+	image: [
+		"model",
+		"refs",
+		"aspect",
+		"size"
+	],
+	audio: [
+		"model",
+		"input",
+		"voice",
+		"dialogue-voices"
+	],
+	video: [
+		"model",
+		"refs",
+		"aspect",
+		"audio",
+		"no-audio",
+		"resolution",
+		"duration",
+		"tier",
+		"bitrate",
+		"first-frame",
+		"last-frame",
+		"image-refs",
+		"video-refs",
+		"audio-refs"
+	]
+};
 function rejectUnknownGenerationOptions(options, mediaKind) {
-	const common = [
-		"env",
-		"local",
-		"space",
-		"force",
-		"name",
-		"type",
-		"o",
-		"output",
-		"collection"
-	];
-	const byKind = {
-		image: [
-			"model",
-			"refs",
-			"aspect",
-			"size"
-		],
-		audio: [
-			"model",
-			"input",
-			"voice",
-			"dialogue-voices"
-		],
-		video: [
-			"model",
-			"refs",
-			"aspect",
-			"audio",
-			"no-audio",
-			"resolution",
-			"duration",
-			"tier",
-			"bitrate",
-			"first-frame",
-			"last-frame",
-			"image-refs",
-			"video-refs",
-			"audio-refs"
-		]
-	};
-	const allowed = new Set([...common, ...byKind[mediaKind]]);
+	const allowed = new Set([...CLI_GENERATION_COMMON_OPTIONS, ...CLI_GENERATION_MEDIA_OPTIONS[mediaKind]]);
 	const unknown = Object.keys(options).find((name) => !allowed.has(name));
 	if (unknown) throw new Error(`Unknown option: --${unknown}`);
 }
@@ -6585,12 +6679,16 @@ async function executeGenerate(parsed, ctx, client, deps, mediaKind, followOptio
 	const seedanceCapability = mediaKind === "video" ? getSeedance2CapabilityByEndpoint(effectiveVideoModel) : void 0;
 	const videoFrameRefs = parseVideoFrameReferenceOptions(parsed, "generate", mediaKind).refs;
 	const seedanceRefs = parseSeedanceReferenceOptions(parsed);
+	const plainRefs = parseOptionalRefs(parsed, "refs");
 	validateSeedanceReferenceOptions(seedanceRefs, effectiveVideoModel, "generate");
 	if (seedanceCapability?.mode === "frame" && videoFrameRefs.length === 0) throw new Error(`--model ${seedanceCapability.selection} requires --first-frame`);
 	if (seedanceCapability?.mode === "text" && videoFrameRefs.length > 0) throw new Error(`--model ${seedanceCapability.selection} does not accept references`);
 	if (seedanceCapability?.mode === "reference" && videoFrameRefs.length > 0) throw new Error(`--model ${seedanceCapability.selection} uses --image-refs, --video-refs, and --audio-refs`);
+	if (seedanceCapability && plainRefs.length > 0) throw new Error(`--model ${seedanceCapability.selection} uses --image-refs, --video-refs, and --audio-refs instead of --refs`);
+	if (mediaKind === "video" && isKlingVideoGenerationModel(effectiveVideoModel) && videoFrameRefs.length + plainRefs.length > 1) throw new Error("--model kling supports at most one image reference");
+	if (mediaKind === "video" && isFalVideoGenerationModel(effectiveVideoModel) && !isFalSeedance2VideoGenerationModel(effectiveVideoModel) && (videoFrameRefs.length > 0 || plainRefs.length > 0)) throw new Error(`--model ${getVideoModelSelectionForModel(effectiveVideoModel) ?? effectiveVideoModel} does not support image references`);
 	const seedanceReferenceCount = seedanceRefs.imageRefs.length + seedanceRefs.videoRefs.length + seedanceRefs.audioRefs.length;
-	const state = videoFrameRefs.length > 0 || seedanceReferenceCount > 0 ? await requestSpaceState(client) : void 0;
+	const state = videoFrameRefs.length > 0 || seedanceReferenceCount > 0 || plainRefs.length > 0 ? await requestSpaceState(client) : void 0;
 	const referenceDeps = {
 		...deps,
 		waitForReferenceVariant: (variant) => waitForReferenceVariant(client, variant)
@@ -6599,12 +6697,12 @@ async function executeGenerate(parsed, ctx, client, deps, mediaKind, followOptio
 		refs: [],
 		ids: []
 	};
-	const referenceVariantIds = resolvedSeedanceRefs.ids.length > 0 ? resolvedSeedanceRefs.ids : videoFrameRefs.length > 0 ? await resolveReferenceVariantIds(videoFrameRefs, ctx, referenceDeps, state?.variants, CLI_GENERATION_MEDIA_KIND, state?.assets) : [];
+	const directRefs = videoFrameRefs.length > 0 ? videoFrameRefs : plainRefs;
+	const directRefMediaKind = videoFrameRefs.length > 0 ? CLI_GENERATION_MEDIA_KIND : mediaKind;
+	const referenceVariantIds = resolvedSeedanceRefs.ids.length > 0 ? resolvedSeedanceRefs.ids : directRefs.length > 0 ? await resolveReferenceVariantIds(directRefs, ctx, referenceDeps, state?.variants, directRefMediaKind, state?.assets) : [];
 	const imageOptions = parseImageGenerationOptions(parsed, mediaKind);
 	const audioModelOptions = parseAudioGenerationOptions(parsed, mediaKind);
 	const videoAudioOptions = parseVideoAudioOptions(parsed, mediaKind);
-	if (mediaKind === "video" && isKlingVideoGenerationModel(effectiveVideoModel) && videoFrameRefs.length > 1) throw new Error("--model kling supports at most one image reference");
-	if (mediaKind === "video" && isFalVideoGenerationModel(effectiveVideoModel) && !isFalSeedance2VideoGenerationModel(effectiveVideoModel) && videoFrameRefs.length > 0) throw new Error(`--model ${getVideoModelSelectionForModel(effectiveVideoModel) ?? effectiveVideoModel} does not support image references`);
 	const collectionPlacement = parseCollectionPlacementOptions(parsed);
 	const followCommandOptions = {
 		...followOptions,
@@ -7290,7 +7388,7 @@ function cliImageModelValues(command) {
 function printUsage$6(command) {
 	console.log(`
 Usage:
-  makefx image generate "prompt" --name <name> --type <type> -o <file> [--model ${cliImageModelValues(command)}] [--size ${cliImageSizeValues()}] [--aspect ${cliImageAspectValues()}] [--collection <id>] [--space <id>]
+  makefx image generate "prompt" --name <name> --type <type> -o <file> [--model ${cliImageModelValues(command)}] [--refs <variant-ref-or-file,...>] [--size ${cliImageSizeValues()}] [--aspect ${cliImageAspectValues()}] [--collection <id>] [--space <id>]
 `);
 }
 //#endregion
@@ -7431,7 +7529,7 @@ function resolveVideoRegenerationModel(model, parsed, sourceRecipe) {
 			"video-refs",
 			"audio-refs"
 		].some((name) => parsed.options[name] !== void 0);
-		const storedRecipe = parseStoredRecipe$1(sourceRecipe);
+		const storedRecipe = parseStoredRecipe$2(sourceRecipe);
 		return getSeedance2RegenerationCapability(model, {
 			model: storedRecipe?.model,
 			references: storedRecipe?.references ?? [],
@@ -7442,7 +7540,7 @@ function resolveVideoRegenerationModel(model, parsed, sourceRecipe) {
 	if (!selection) throw new Error("Unsupported video model. Expected veo-3.1, omni-flash, kling, seedance-1, seedance-2, or seedance-2-fast");
 	return getVideoGenerationModelForSelection(selection, tier);
 }
-function parseStoredRecipe$1(recipe) {
+function parseStoredRecipe$2(recipe) {
 	if (!recipe) return void 0;
 	try {
 		const parsed = JSON.parse(recipe);
@@ -8360,13 +8458,575 @@ async function executeSpaceLens(parsed, deps = defaultDeps$8) {
 	return result;
 }
 //#endregion
+//#region src/shared/generatorCapabilities.ts
+function input(name, type, required, description, options = {}) {
+	return {
+		name,
+		type,
+		required,
+		description,
+		...options
+	};
+}
+var SPACE_INPUT = input("space_id", "string", true, "Target Space ID from list_spaces.");
+var NAME_INPUT = input("name", "string", true, "Human-readable asset name.");
+var PROMPT_INPUT = input("prompt", "string", true, "Generation instruction.");
+function fixedInput(name, value, description) {
+	return input(name, "string", true, description, { allowedValues: [value] });
+}
+function imageGenerator(capability) {
+	const referenceInput = input("reference_variant_refs", "string_array", false, "Completed image variant references from find_assets or get_asset.", {
+		minItems: 1,
+		maxItems: capability.maxReferenceImages
+	});
+	const generateInputs = [
+		SPACE_INPUT,
+		fixedInput("generator_id", `image/${capability.selection}`, "Selects this image generator."),
+		NAME_INPUT,
+		input("asset_type", "string", true, "Asset classification stored in the Space."),
+		PROMPT_INPUT,
+		input("aspect_ratio", "string", false, "Output aspect ratio.", {
+			allowedValues: capability.supportedAspectRatios,
+			defaultValue: "1:1"
+		}),
+		input("image_size", "string", false, "Output image size.", {
+			allowedValues: capability.supportedImageSizes,
+			defaultValue: "1K"
+		})
+	];
+	const operations = [{
+		operation: "generate",
+		tool: "generate_image",
+		description: "Create a new image asset from text.",
+		inputs: generateInputs
+	}];
+	if (capability.supportedOperations.includes("derive")) operations.push({
+		operation: "derive",
+		tool: "generate_image",
+		description: "Create a new image asset using completed image variants as references.",
+		inputs: [...generateInputs, {
+			...referenceInput,
+			required: true
+		}]
+	});
+	if (capability.supportedOperations.includes("refine")) operations.push({
+		operation: "refine",
+		tool: "edit_image",
+		description: "Create a new variant on an existing image asset.",
+		inputs: [
+			SPACE_INPUT,
+			fixedInput("generator_id", `image/${capability.selection}`, "Selects this image generator."),
+			input("asset_ref", "string", true, "Target image asset reference from find_assets."),
+			PROMPT_INPUT,
+			input("source_variant_ref", "string", true, "Completed image variant to edit."),
+			input("reference_variant_refs", "string_array", false, "Additional completed image references.", {
+				minItems: 1,
+				maxItems: Math.max(0, capability.maxReferenceImages - 1)
+			}),
+			input("aspect_ratio", "string", false, "Output aspect ratio.", {
+				allowedValues: capability.supportedAspectRatios,
+				defaultValue: "1:1"
+			}),
+			input("image_size", "string", false, "Output image size.", {
+				allowedValues: capability.supportedImageSizes,
+				defaultValue: "1K"
+			})
+		]
+	});
+	return {
+		id: `image/${capability.selection}`,
+		label: capability.label,
+		mediaKind: "image",
+		provider: capability.provider === "gemini" ? "google_ai" : "fal",
+		modelIds: [capability.modelId],
+		defaultModelId: capability.modelId,
+		operations,
+		referenceRules: {
+			mediaKind: capability.maxReferenceImages > 0 ? "image" : null,
+			completedOnly: capability.maxReferenceImages > 0,
+			maxCount: capability.maxReferenceImages
+		},
+		notes: capability.maxReferenceImages > 0 ? ["Use compact variant references; binary image input is not accepted."] : ["Text-to-image only; reference inputs are not supported."]
+	};
+}
+function videoGenerator(selection) {
+	const defaultModel = getVideoGenerationModelForSelection(selection);
+	const isVeo = selection === "veo-3.1";
+	const isOmni = selection === "omni-flash";
+	const isKling = selection === "kling";
+	const modelIds = isVeo ? Object.values(VIDEO_GENERATION_TIER_MODELS) : [defaultModel];
+	const resolutions = isVeo ? VIDEO_GENERATION_RESOLUTIONS : getVideoGenerationResolutionsForModel(defaultModel);
+	const maxReferences = getVideoGenerationMaxReferenceImages(defaultModel);
+	const parameterInputs = [input("aspect_ratio", "string", false, "Output aspect ratio.", {
+		allowedValues: VIDEO_GENERATION_ASPECT_RATIOS,
+		defaultValue: "16:9"
+	})];
+	if (!isOmni) parameterInputs.push(input("video_resolution", "string", false, "Output resolution.", {
+		allowedValues: resolutions,
+		defaultValue: DEFAULT_VIDEO_GENERATION_RESOLUTION
+	}), input("video_duration_seconds", "integer", false, "Output duration in seconds.", {
+		allowedValues: VIDEO_GENERATION_DURATION_SECONDS,
+		defaultValue: 8
+	}));
+	if (isVeo) parameterInputs.push(input("video_tier", "string", false, "Veo model tier.", {
+		allowedValues: VIDEO_GENERATION_TIERS,
+		defaultValue: DEFAULT_VIDEO_GENERATION_TIER
+	}));
+	if (isKling) parameterInputs.push(input("generate_audio", "boolean", false, "Generate synchronized audio.", {
+		allowedValues: [true, false],
+		defaultValue: true
+	}));
+	const commonInputs = [
+		SPACE_INPUT,
+		fixedInput("generator_id", `video/${selection}`, "Selects this video generator."),
+		NAME_INPUT,
+		input("asset_type", "string", true, "Asset classification stored in the Space."),
+		PROMPT_INPUT,
+		...parameterInputs
+	];
+	const operations = [{
+		operation: "generate",
+		tool: "generate_video",
+		description: "Create a new video asset from text.",
+		inputs: commonInputs
+	}];
+	if (VIDEO_MODEL_SUPPORTED_OPERATIONS[selection].includes("refine")) operations.push({
+		operation: "refine",
+		tool: "edit_video",
+		description: "Create a new sibling variant from a completed video variant.",
+		inputs: [
+			SPACE_INPUT,
+			fixedInput("generator_id", `video/${selection}`, "Selects this video generator."),
+			input("asset_ref", "string", true, "Target video asset reference from find_assets."),
+			input("source_variant_ref", "string", true, "Completed video variant to refine."),
+			PROMPT_INPUT,
+			...parameterInputs
+		]
+	});
+	if (VIDEO_MODEL_SUPPORTED_OPERATIONS[selection].includes("derive")) operations.push({
+		operation: "derive",
+		tool: "generate_video",
+		description: "Create a new video from completed image variants.",
+		inputs: [...commonInputs, input("reference_variant_refs", "string_array", true, "Completed image variant references from find_assets or get_asset.", {
+			minItems: 1,
+			maxItems: maxReferences
+		})]
+	});
+	const notes = isVeo ? [`Resolution support by tier: ${VIDEO_GENERATION_TIERS.map((tier) => `${tier}=${VIDEO_GENERATION_RESOLUTIONS_BY_TIER[tier].join("/")}`).join(", ")}.`, "Synchronized audio is always enabled."] : isOmni ? ["Resolution, duration, tier, and generated-audio options are not accepted."] : selection === "fal-seedance" ? ["Text-to-video only; generated audio is not supported."] : ["At most one completed image reference is accepted."];
+	return {
+		id: `video/${selection}`,
+		label: VIDEO_MODEL_LABELS[selection],
+		mediaKind: "video",
+		provider: selection === "kling" ? "kling" : selection === "fal-seedance" ? "fal" : "google_ai",
+		modelIds,
+		defaultModelId: defaultModel,
+		operations,
+		referenceRules: {
+			mediaKind: maxReferences > 0 ? "image" : null,
+			completedOnly: maxReferences > 0,
+			maxCount: maxReferences
+		},
+		notes
+	};
+}
+function seedanceVideoGenerator(capability) {
+	const fixedGenerator = fixedInput("generator_id", capability.generatorId, "Selects this exact Seedance 2 mode and tier.");
+	const parameters = [
+		input("aspect_ratio", "string", false, "Output aspect ratio; auto lets Seedance infer it.", {
+			allowedValues: capability.aspectRatios,
+			defaultValue: capability.defaultAspectRatio
+		}),
+		input("resolution", "string", false, "Output resolution.", {
+			allowedValues: capability.resolutions,
+			defaultValue: capability.defaultResolution
+		}),
+		input("duration", "string_or_integer", false, "Output seconds from 4 to 15, or auto.", {
+			allowedValues: capability.durations,
+			defaultValue: capability.defaultDuration
+		}),
+		input("generate_audio", "boolean", false, "Generate synchronized native audio.", {
+			allowedValues: [true, false],
+			defaultValue: capability.generateAudio.default
+		}),
+		input("bitrate_mode", "string", false, "Output bitrate quality.", {
+			allowedValues: capability.bitrateModes,
+			defaultValue: capability.defaultBitrateMode
+		})
+	];
+	const common = [
+		SPACE_INPUT,
+		fixedGenerator,
+		NAME_INPUT,
+		input("asset_type", "string", true, "Asset classification stored in the Space."),
+		PROMPT_INPUT,
+		...parameters
+	];
+	const frameInputs = [input("start_frame_variant_ref", "string", true, "Completed image variant used as the authoritative first frame; cannot be combined with extended references."), input("end_frame_variant_ref", "string", false, "Completed image variant used as the authoritative final frame; cannot be combined with extended references.")];
+	const referenceInputs = [
+		input("image_reference_variant_refs", "string_array", false, "Ordered completed images addressed as @Image1 through @Image9 for soft subject, style, or geography guidance; not authoritative boundary frames.", {
+			minItems: 1,
+			maxItems: 9
+		}),
+		input("video_reference_variant_refs", "string_array", false, "Ordered completed videos addressed as @Video1 through @Video3.", {
+			minItems: 1,
+			maxItems: 3
+		}),
+		input("audio_reference_variant_refs", "string_array", false, "Ordered completed audio clips addressed as @Audio1 through @Audio3.", {
+			minItems: 1,
+			maxItems: 3
+		})
+	];
+	const modeInputs = capability.mode === "frame" ? frameInputs : capability.mode === "reference" ? referenceInputs : [];
+	const operations = capability.operations.filter((operation) => operation !== "refine").map((operation) => ({
+		operation,
+		tool: "generate_video",
+		description: capability.mode === "text" ? "Create a video from text." : capability.mode === "frame" ? "Animate a required authoritative start frame and optional authoritative end frame; extended references cannot be combined with them." : "Direct a video with ordered image, video, and audio references; these guide generation but cannot serve as authoritative start/end frames.",
+		inputs: [...common, ...modeInputs]
+	}));
+	if (capability.operations.includes("refine")) {
+		const budget = getSeedance2ReferenceBudget(capability, "refine");
+		const editReferenceInputs = referenceInputs.map((referenceInput) => referenceInput.name === "video_reference_variant_refs" ? {
+			...referenceInput,
+			maxItems: 2,
+			description: "Up to two additional completed videos addressed as @Video2 and @Video3; the source video is @Video1."
+		} : referenceInput);
+		operations.push({
+			operation: "refine",
+			tool: "edit_video",
+			description: "Edit or continue a completed video using it as @Video1 plus optional ordered references.",
+			referenceLimits: {
+				maxAdditionalCount: budget.maxAdditionalFiles,
+				implicitSourceCount: 1,
+				maxAdditionalByKind: budget.maxAdditionalByKind
+			},
+			inputs: [
+				SPACE_INPUT,
+				fixedGenerator,
+				input("asset_ref", "string", true, "Target video asset reference from find_assets."),
+				input("source_variant_ref", "string", true, "Completed target video used as @Video1."),
+				PROMPT_INPUT,
+				...parameters,
+				...editReferenceInputs
+			]
+		});
+	}
+	return {
+		id: capability.generatorId,
+		label: capability.label,
+		mediaKind: "video",
+		provider: "fal",
+		modelIds: [capability.endpointId],
+		defaultModelId: capability.endpointId,
+		operations,
+		referenceRules: {
+			mediaKind: capability.mode === "frame" ? "image" : null,
+			completedOnly: capability.mode !== "text",
+			maxCount: capability.maxReferenceFiles,
+			maxTotalCount: capability.maxReferenceFiles,
+			requiresVisualWithAudio: capability.requiresVisualReferenceWithAudio,
+			modalities: capability.references.map((reference) => ({
+				mediaKind: reference.mediaKind,
+				minCount: reference.minCount,
+				maxCount: reference.maxCount,
+				promptLabel: reference.promptLabel,
+				acceptedMimeTypes: reference.acceptedMimeTypes,
+				maxBytesPerFile: reference.maxBytesPerFile,
+				...reference.combinedMaxBytes !== void 0 ? { combinedMaxBytes: reference.combinedMaxBytes } : {},
+				...reference.combinedDurationSeconds ? { combinedDurationSeconds: reference.combinedDurationSeconds } : {}
+			}))
+		},
+		notes: [
+			"Use compact variant references; binary media input is not accepted.",
+			capability.mode === "reference" ? "Prompt labels are modality-specific and one-based: @ImageN, @VideoN, and @AudioN. @ImageN guides content, style, or geography but is not an authoritative start/end frame." : capability.mode === "frame" ? "The start and end images are authoritative boundary frames. The provider does not allow extended image, video, or audio references in this mode." : "This mode rejects all reference inputs.",
+			"Seedance 2 cannot combine authoritative start/end frames with extended multimodal references in one request.",
+			capability.resolutions.includes("4k") ? "Standard supports 480p, 720p, 1080p, and 4K output." : "Fast supports 480p and 720p output."
+		]
+	};
+}
+function audioGenerator(input_) {
+	const inputs = [
+		SPACE_INPUT,
+		fixedInput("generator_id", input_.id, "Selects this audio generator and mode."),
+		NAME_INPUT,
+		PROMPT_INPUT
+	];
+	if (input_.provider === "elevenlabs" && (input_.assetType === "speech" || input_.assetType === "dialogue")) inputs.push(input("model", "string", false, "Optional ElevenLabs model override.", { defaultValue: input_.modelId }));
+	if (input_.assetType === "speech") inputs.push(input("voice_id", "string", true, "Voice ID returned by list_voices."));
+	else if (input_.assetType === "dialogue") inputs.push(input("dialogue_voice_ids", "string_array", true, "One voice ID per distinct speaker, in first-appearance order.", { minItems: 2 }));
+	const notes = input_.assetType === "dialogue" ? ["Prompt must contain at least two `Speaker: line` entries and at least two distinct speakers."] : input_.assetType === "speech" ? ["Prompt must be plain speech text, not `Speaker: line` dialogue."] : ["Prompt describes the desired audio; voice inputs and image references are not accepted."];
+	return {
+		id: input_.id,
+		label: input_.label,
+		mediaKind: "audio",
+		provider: input_.provider,
+		modelIds: [input_.modelId],
+		defaultModelId: input_.modelId,
+		operations: [{
+			operation: "generate",
+			tool: "generate_audio",
+			description: `Create a new ${input_.assetType} audio asset.`,
+			inputs
+		}],
+		referenceRules: {
+			mediaKind: null,
+			completedOnly: false,
+			maxCount: 0
+		},
+		notes
+	};
+}
+function getGeneratorCatalog(overrides = {}) {
+	const elevenLabsSpeech = overrides.elevenLabsSpeech ?? "eleven_v3";
+	const elevenLabsMusic = overrides.elevenLabsMusic ?? "music_v1";
+	const elevenLabsSfx = overrides.elevenLabsSfx ?? "eleven_text_to_sound_v2";
+	const lyria = overrides.lyria ?? "lyria-3-clip-preview";
+	return [
+		...Object.values(IMAGE_MODEL_CAPABILITIES).map(imageGenerator),
+		...VIDEO_MODEL_SELECTIONS.map(videoGenerator),
+		...SEEDANCE_2_SELECTIONS.map((selection) => seedanceVideoGenerator(SEEDANCE_2_CAPABILITIES[selection])),
+		audioGenerator({
+			id: "audio/elevenlabs-speech",
+			label: "ElevenLabs Speech",
+			provider: "elevenlabs",
+			assetType: "speech",
+			modelId: elevenLabsSpeech
+		}),
+		audioGenerator({
+			id: "audio/elevenlabs-dialogue",
+			label: "ElevenLabs Dialogue",
+			provider: "elevenlabs",
+			assetType: "dialogue",
+			modelId: elevenLabsSpeech
+		}),
+		audioGenerator({
+			id: "audio/elevenlabs-music",
+			label: "ElevenLabs Music",
+			provider: "elevenlabs",
+			assetType: "music",
+			modelId: elevenLabsMusic
+		}),
+		audioGenerator({
+			id: "audio/elevenlabs-sfx",
+			label: "ElevenLabs Sound Effects",
+			provider: "elevenlabs",
+			assetType: "sfx",
+			modelId: elevenLabsSfx
+		}),
+		audioGenerator({
+			id: "audio/lyria-music",
+			label: "Lyria Music",
+			provider: "lyria",
+			assetType: "music",
+			modelId: lyria
+		})
+	];
+}
+function getGeneratorDefinition(id, overrides = {}) {
+	return getGeneratorCatalog(overrides).find((generator) => generator.id === id);
+}
+//#endregion
+//#region src/shared/generationReferences.ts
+function isGenerationReference(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const reference = value;
+	return typeof reference.variantId === "string" && reference.variantId.length > 0 && (reference.mediaKind === "image" || reference.mediaKind === "video" || reference.mediaKind === "audio") && typeof reference.storageKey === "string" && reference.storageKey.length > 0 && Number.isInteger(reference.sequenceIndex) && Number.isInteger(reference.modalityIndex) && (reference.mimeType === void 0 || typeof reference.mimeType === "string") && (reference.sizeBytes === void 0 || typeof reference.sizeBytes === "number") && (reference.width === void 0 || typeof reference.width === "number") && (reference.height === void 0 || typeof reference.height === "number") && (reference.durationMs === void 0 || typeof reference.durationMs === "number");
+}
+function areGenerationReferencesIndexed(value) {
+	if (!Array.isArray(value)) return false;
+	const modalityCounts = {
+		image: 0,
+		video: 0,
+		audio: 0
+	};
+	return value.every((reference, sequenceIndex) => {
+		if (!isGenerationReference(reference) || reference.sequenceIndex !== sequenceIndex) return false;
+		const expectedModalityIndex = modalityCounts[reference.mediaKind]++;
+		return reference.modalityIndex === expectedModalityIndex;
+	});
+}
+//#endregion
+//#region src/shared/draftMapping.ts
+/** Generator input names map to the canonical camel-case keys stored in recipes. */
+var DRAFT_RECIPE_INPUT_KEYS = {
+	asset_type: "assetType",
+	prompt: "prompt",
+	aspect_ratio: "aspectRatio",
+	image_size: "imageSize",
+	model: "model",
+	voice_id: "voiceId",
+	dialogue_voice_ids: "dialogueVoiceIds",
+	generate_audio: "generateAudio",
+	video_resolution: "videoResolution",
+	resolution: "videoResolution",
+	video_duration_seconds: "videoDurationSeconds",
+	video_tier: "videoTier",
+	duration: "seedanceDuration",
+	bitrate_mode: "seedanceBitrateMode"
+};
+var DRAFT_REFERENCE_FIELD = /(?:_variant_refs?|VariantRefs?)$/;
+/**
+* The one slot-naming convention used while authoring and resolving Bindings.
+* Unknown reference slots inherit the Draft output kind.
+*/
+function mediaKindForDraftSlot(slot, fallback) {
+	if (slot.startsWith("image_") || slot === "start_frame_variant_ref" || slot === "end_frame_variant_ref" || slot === "reference_variant_refs") return "image";
+	if (slot.startsWith("video_")) return "video";
+	if (slot.startsWith("audio_")) return "audio";
+	return fallback;
+}
+function generatorIdForDraftRecipe(mediaMode, recipe) {
+	if (mediaMode === "image") {
+		if (recipe.modelProvider === "custom") throw new Error("Custom-provider image Recipes do not map to a Draft generator");
+		const model = typeof recipe.model === "string" ? recipe.model : "pro";
+		if (!isImageModelSelection(model) && !isImageModelId(model)) throw new Error(`Stored image model ${model} does not map to a Draft generator`);
+		return `image/${getImageModelSelection(model)}`;
+	}
+	if (mediaMode === "video") {
+		const model = typeof recipe.model === "string" ? recipe.model : "veo-3.1";
+		const seedance = getSeedance2CapabilityByEndpoint(model);
+		if (seedance) return seedance.generatorId;
+		const selection = getVideoModelSelectionForModel(model);
+		if (!selection) throw new Error(`Stored video model ${model} does not map to a Draft generator`);
+		return `video/${selection}`;
+	}
+	if (mediaMode === "speech") return "audio/elevenlabs-speech";
+	if (mediaMode === "dialogue") return "audio/elevenlabs-dialogue";
+	if (mediaMode === "sfx") return "audio/elevenlabs-sfx";
+	return recipe.musicProvider === "lyria" ? "audio/lyria-music" : "audio/elevenlabs-music";
+}
+function mediaModeForDraftRecipe(mediaKind, assetType) {
+	if (mediaKind === "image" || mediaKind === "video") return mediaKind;
+	return getForgeModeForAudioAssetType(assetType);
+}
+function buildDraftMapping(args) {
+	const { name, mediaMode, generatorId, recipe, references, destinationKind, destinationAssetId, sourceVariantId } = args;
+	const operation = destinationKind === "sibling" ? "refine" : references.length > 0 ? "derive" : "generate";
+	const operationDefinition = getGeneratorDefinition(generatorId)?.operations.find((candidate) => candidate.operation === operation);
+	if (!operationDefinition) throw new Error(`${generatorId} does not support ${operation} drafts`);
+	const recipeTemplate = { operation };
+	for (const input of operationDefinition.inputs) {
+		const key = DRAFT_RECIPE_INPUT_KEYS[input.name];
+		if (!key) continue;
+		const value = recipe[key];
+		if (value !== void 0) recipeTemplate[key] = value;
+	}
+	const availableSlots = operationDefinition.inputs.filter((input) => DRAFT_REFERENCE_FIELD.test(input.name)).map((input) => input.name);
+	const bindings = [];
+	if (destinationKind === "sibling" && sourceVariantId && availableSlots.includes("source_variant_ref")) bindings.push({
+		slot: "source_variant_ref",
+		sourceKind: "variant",
+		sourceVariantId,
+		sortIndex: 0
+	});
+	const outputMediaKind = getMediaKindForForgeMode(mediaMode);
+	const additionalSlots = availableSlots.filter((slot) => slot !== "source_variant_ref");
+	const usedScalarSlots = /* @__PURE__ */ new Set();
+	for (const [index, reference] of references.entries()) {
+		const targetSlot = additionalSlots.filter((slot) => mediaKindForDraftSlot(slot, outputMediaKind) === reference.mediaKind).find((slot) => slot.endsWith("_refs") || !usedScalarSlots.has(slot));
+		if (!targetSlot) throw new Error(`No ${reference.mediaKind} input slot is available for ${generatorId}`);
+		if (!targetSlot.endsWith("_refs")) usedScalarSlots.add(targetSlot);
+		bindings.push({
+			id: reference.id,
+			slot: targetSlot,
+			sourceKind: reference.sourceKind,
+			sourceVariantId: reference.sourceVariantId,
+			sourceAssetId: reference.sourceAssetId,
+			sourceDraftId: reference.sourceDraftId,
+			sortIndex: index
+		});
+	}
+	return {
+		name,
+		mediaMode,
+		generatorId,
+		recipeTemplate,
+		destinationKind,
+		destinationAssetId: destinationKind === "sibling" ? destinationAssetId : null,
+		bindings
+	};
+}
+function materializeDraftFromVariant(args) {
+	const storedRecipe = parseStoredRecipe$1(args.recipe);
+	if (!areGenerationReferencesIndexed(storedRecipe.references)) throw new Error("Variant recipe has invalid references");
+	const mediaMode = args.mediaMode ?? mediaModeForDraftRecipe(args.variantMediaKind, args.assetType ?? stringValue(storedRecipe.assetType));
+	const recipe = args.recipeOverride ?? storedRecipe;
+	const generatorId = args.generatorId ?? generatorIdForDraftRecipe(mediaMode, storedRecipe);
+	const storedOperation = stringValue(storedRecipe.operation);
+	const destinationKind = args.destinationKind ?? (storedOperation === "refine" ? "sibling" : "new_asset");
+	const storedReferences = storedRecipe.references;
+	if (storedOperation === "refine" && destinationKind === "sibling" && storedReferences.length === 0) throw new Error("Stored refine Recipe has no source Variant reference");
+	const preservesStoredRefine = storedOperation === "refine" && destinationKind === "sibling";
+	const sourceVariantId = preservesStoredRefine ? storedReferences[0]?.variantId : destinationKind === "sibling" ? args.variantId : void 0;
+	const additionalReferences = preservesStoredRefine ? storedReferences.slice(1) : storedReferences;
+	return buildDraftMapping({
+		name: args.name?.trim() || args.assetName,
+		mediaMode,
+		generatorId,
+		recipe,
+		references: additionalReferences.map((reference) => ({
+			mediaKind: reference.mediaKind,
+			sourceKind: "variant",
+			sourceVariantId: reference.variantId
+		})),
+		destinationKind,
+		destinationAssetId: destinationKind === "sibling" ? args.destinationAssetId ?? args.assetId : null,
+		sourceVariantId
+	});
+}
+function parseStoredRecipe$1(value) {
+	let parsed = value;
+	if (typeof value === "string") try {
+		parsed = JSON.parse(value);
+	} catch {
+		throw new Error("Variant recipe is not valid JSON");
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Variant recipe is not a JSON object");
+	return parsed;
+}
+function stringValue(value) {
+	return typeof value === "string" && value.trim() ? value : void 0;
+}
+//#endregion
 //#region src/cli/commands/drafts.ts
+var CLI_DRAFT_OPTIONS = {
+	list: [],
+	show: [],
+	create: [
+		"from",
+		"name",
+		"media",
+		"generator",
+		"recipe",
+		"destination",
+		"asset",
+		"x",
+		"y"
+	],
+	update: [
+		"name",
+		"media",
+		"generator",
+		"recipe",
+		"destination",
+		"asset",
+		"x",
+		"y"
+	],
+	delete: [],
+	run: ["request-id", "wait"]
+};
 var defaultDeps$7 = {
 	loadConfig: loadStoredConfig,
 	loadProjectConfig,
 	createMutationClient: (env, spaceId) => WebSocketClient.create(env, spaceId),
 	print: console.log
 };
+var defaultGraphDeps = {
+	loadConfig: loadStoredConfig,
+	loadProjectConfig,
+	createClient: (env, spaceId) => WebSocketClient.create(env, spaceId),
+	print: console.log
+};
 async function handleDrafts(parsed) {
 	try {
 		await executeDrafts(parsed);
@@ -8383,9 +9043,17 @@ async function handleBindings(parsed) {
 		process$1.exitCode = 1;
 	}
 }
+async function handleGraph(parsed) {
+	try {
+		await executeGraph(parsed);
+	} catch (error) {
+		console.error("Error:", error instanceof Error ? error.message : error);
+		process$1.exitCode = 1;
+	}
+}
 async function executeDrafts(parsed, deps = defaultDeps$7) {
 	const subcommand = parsed.positionals[0];
-	if (!subcommand) throw new Error("Drafts command is required: list, create, update, or delete");
+	if (!subcommand) throw new Error("Drafts command is required: list, show, create, update, delete, or run");
 	rejectUnknownOptions("drafts", subcommand, parsed.options);
 	const ctx = await buildContext$3(parsed, deps);
 	if (subcommand === "list") {
@@ -8395,12 +9063,75 @@ async function executeDrafts(parsed, deps = defaultDeps$7) {
 		return drafts;
 	}
 	if (subcommand === "create") {
-		const name = parsed.positionals.slice(1).join(" ").trim();
+		const fromVariantRef = optionValue$2(parsed.options.from);
+		const name = optionValue$2(parsed.options.name) ?? parsed.positionals.slice(1).join(" ").trim();
+		if (fromVariantRef) {
+			const state = await readDraftState(ctx, deps);
+			const sourceVariantId = requireExactVariantRef$1(fromVariantRef, state);
+			const sourceVariant = state.variants.find((variant) => variant.id === sourceVariantId);
+			const sourceAsset = sourceVariant ? state.assets.find((asset) => asset.id === sourceVariant.asset_id) : void 0;
+			if (!sourceVariant || !sourceAsset) throw new Error("Source Variant is unavailable");
+			if (sourceVariant.status !== "completed") throw new Error("Source Variant must be completed");
+			const destinationKind = parseDestination(parsed.options.destination);
+			const destinationAssetRef = optionValue$2(parsed.options.asset);
+			const mapped = materializeDraftFromVariant({
+				variantId: sourceVariant.id,
+				variantMediaKind: sourceVariant.media_kind,
+				recipe: sourceVariant.recipe,
+				assetName: sourceAsset.name,
+				assetType: sourceAsset.type,
+				assetId: sourceAsset.id,
+				name,
+				mediaMode: parseMediaMode(parsed.options.media),
+				generatorId: optionValue$2(parsed.options.generator),
+				recipeOverride: parseRecipe(parsed.options.recipe),
+				destinationKind,
+				destinationAssetId: destinationAssetRef ? requireAssetRef(destinationAssetRef, state.assets) : void 0
+			});
+			for (const binding of mapped.bindings) {
+				const variantId = binding.sourceVariantId;
+				if (variantId && !state.variants.some((variant) => variant.id === variantId)) throw new Error(`Variant recipe reference ${variantId} is unavailable`);
+			}
+			const created = await withClient(ctx, deps, async (client) => {
+				const draft = await client.createDraft({
+					name: mapped.name,
+					mediaMode: mapped.mediaMode,
+					generatorId: mapped.generatorId,
+					recipeTemplate: mapped.recipeTemplate,
+					destinationKind: mapped.destinationKind,
+					destinationAssetId: mapped.destinationAssetId,
+					canvasX: parseNullableFinite(parsed.options.x, "--x"),
+					canvasY: parseNullableFinite(parsed.options.y, "--y")
+				});
+				const bindings = [];
+				try {
+					for (const binding of mapped.bindings) bindings.push(await client.setBinding({
+						draftId: draft.id,
+						...binding
+					}));
+				} catch (error) {
+					await client.deleteDraft(draft.id);
+					throw error;
+				}
+				return {
+					draft,
+					bindings
+				};
+			});
+			const resultState = {
+				...state,
+				drafts: [...state.drafts, created.draft],
+				bindings: [...state.bindings, ...created.bindings]
+			};
+			const result = publicDraft(created.draft, resultState);
+			printJsonOrValue(parsed, deps, result, () => deps.print(`Created Draft ${result.draftRef}`));
+			return created.draft;
+		}
 		const mediaMode = parseMediaMode(parsed.options.media);
 		const generatorId = optionValue$2(parsed.options.generator);
 		const recipeTemplate = parseRecipe(parsed.options.recipe);
 		const destinationKind = parseDestination(parsed.options.destination);
-		if (!name || !mediaMode || !generatorId || recipeTemplate === void 0 || !destinationKind) throw new Error("Usage: makefx drafts create \"<name>\" --media <mode> --generator <id> --recipe <json> --destination new_asset|sibling [--asset <asset-ref>]");
+		if (!name || !mediaMode || !generatorId || recipeTemplate === void 0 || !destinationKind) throw new Error("Usage: makefx drafts create \"<name>\" --media <mode> --generator <id> --recipe <json> --destination new_asset|sibling [--asset <asset-ref>], or makefx drafts create --from <variant-ref> [--name <name>]");
 		const state = await readDraftState(ctx, deps);
 		const destinationAssetRef = optionValue$2(parsed.options.asset);
 		const destinationAssetId = destinationAssetRef ? requireAssetRef(destinationAssetRef, state.assets) : null;
@@ -8425,6 +9156,52 @@ async function executeDrafts(parsed, deps = defaultDeps$7) {
 	if (!draftRef) throw new Error(`Usage: makefx drafts ${subcommand} <draft-ref>`);
 	const state = await readDraftState(ctx, deps);
 	const draftId = requireDraftRef(draftRef, state.drafts);
+	if (subcommand === "show") {
+		const draft = state.drafts.find((candidate) => candidate.id === draftId);
+		if (!draft) throw new Error("Draft is unavailable");
+		const result = publicDraft(draft, state);
+		printJsonOrValue(parsed, deps, result, () => printDraft(result, deps.print));
+		return result;
+	}
+	if (subcommand === "run") {
+		const requestId = optionValue$2(parsed.options["request-id"]) ?? crypto.randomUUID();
+		const waitSeconds = parsed.options.wait === void 0 ? void 0 : parseGraphWaitSeconds(parsed.options.wait);
+		const run = await withClient(ctx, deps, async (client) => {
+			if (!client.runDraft) throw new Error("The connected client does not support Draft runs");
+			if (waitSeconds !== void 0 && !client.followVariant) throw new Error("The connected client does not support waiting for Draft runs");
+			let outcomePromise;
+			const started = await client.runDraft(draftId, requestId, waitSeconds === void 0 ? void 0 : (runStarted) => {
+				if (runStarted.status !== "completed" && runStarted.status !== "failed") outcomePromise = client.followVariant({
+					variantId: runStarted.variantId,
+					requestId,
+					timeoutMs: waitSeconds * 1e3
+				});
+			});
+			if (waitSeconds === void 0 || started.status === "completed" || started.status === "failed") return {
+				started,
+				terminalStatus: started.status
+			};
+			if (!outcomePromise) throw new Error("Draft run wait was not initialized");
+			return {
+				started,
+				terminalStatus: (await outcomePromise).success ? "completed" : "failed"
+			};
+		});
+		const updatedState = await readDraftState(ctx, deps);
+		const variantRef = variantRefForId(run.started.variantId, updatedState.assets, updatedState.variants);
+		if (!variantRef) throw new Error("Draft run Variant is unavailable");
+		const result = {
+			draftRef,
+			requestId,
+			variantRef,
+			status: run.terminalStatus
+		};
+		printJsonOrValue(parsed, deps, result, () => {
+			deps.print(`${parsed.options.wait === void 0 ? "Started" : "Finished"} ${draftRef} (${run.terminalStatus})`);
+			if (variantRef) deps.print(`  Variant: ${variantRef}`);
+		});
+		return result;
+	}
 	if (subcommand === "update") {
 		const destinationAssetRef = optionValue$2(parsed.options.asset);
 		const changes = {
@@ -8495,6 +9272,47 @@ async function executeBindings(parsed, deps = defaultDeps$7) {
 	printJsonOrValue(parsed, deps, publicBinding(binding, state), () => deps.print(`Set ${slot}[${sortIndex}] on ${draftRef}`));
 	return binding;
 }
+async function executeGraph(parsed, deps = defaultGraphDeps) {
+	const subcommand = parsed.positionals[0];
+	if (subcommand !== "run" && subcommand !== "status" && subcommand !== "cancel") throw new Error("Graph command is required: run, status, or cancel");
+	rejectGraphUnknownOptions(subcommand, parsed.options);
+	const ctx = await buildContext$3(parsed, deps);
+	const state = await readDraftState(ctx, { createMutationClient: deps.createClient });
+	const client = await deps.createClient(ctx.env, ctx.spaceId);
+	await client.connect();
+	try {
+		if (subcommand === "status" || subcommand === "cancel") {
+			const runRef = parsed.positionals[1];
+			if (!runRef) throw new Error(`Usage: makefx graph ${subcommand} <graph-run-ref>`);
+			const current = await client.getGraphRunStatus(runRef);
+			const status = subcommand === "cancel" ? await client.cancelGraphRun(current.run.id) : current;
+			const result = publicGraphRun(status.run, status.drafts, state);
+			printJsonOrValue(parsed, deps, result, () => {
+				if (subcommand === "cancel") deps.print(`Cancelled pending work in ${runRef}`);
+				printGraphRun(result, deps.print);
+			});
+			return result;
+		}
+		const draftRefs = parsed.positionals.slice(1);
+		if (draftRefs.length === 0) throw new Error("Usage: makefx graph run <draft-ref> [draft-ref...] [--upstream] [--downstream] [--from-scratch] [--wait]");
+		const requestId = optionValue$2(parsed.options["request-id"]) ?? crypto.randomUUID();
+		let status = await client.runGraph({
+			draftIds: draftRefs.map((draftRef) => requireDraftRef(draftRef, state.drafts)),
+			requestId,
+			includeUpstream: parsed.options.upstream === "true",
+			includeDownstream: parsed.options.downstream === "true",
+			fromScratch: parsed.options["from-scratch"] === "true"
+		});
+		const runRef = createGraphRunRef(status.run.id);
+		if (parsed.options.wait !== void 0 && status.run.status === "running") status = await client.waitForGraphRun(runRef, status.run.id, parseGraphWaitSeconds(parsed.options.wait) * 1e3);
+		const freshState = await readDraftState(ctx, { createMutationClient: deps.createClient });
+		const result = publicGraphRun(status.run, status.drafts, freshState);
+		printJsonOrValue(parsed, deps, result, () => printGraphRun(result, deps.print));
+		return result;
+	} finally {
+		client.disconnect();
+	}
+}
 async function buildContext$3(parsed, deps) {
 	const project = await deps.loadProjectConfig();
 	const env = resolveCommandEnvironment(parsed, project);
@@ -8655,29 +9473,7 @@ function rejectUnknownOptions(noun, subcommand, options) {
 		"local",
 		"json"
 	];
-	const commands = noun === "drafts" ? {
-		list: [],
-		create: [
-			"media",
-			"generator",
-			"recipe",
-			"destination",
-			"asset",
-			"x",
-			"y"
-		],
-		update: [
-			"name",
-			"media",
-			"generator",
-			"recipe",
-			"destination",
-			"asset",
-			"x",
-			"y"
-		],
-		delete: []
-	} : {
+	const commands = noun === "drafts" ? CLI_DRAFT_OPTIONS : {
 		set: [
 			"source",
 			"ref",
@@ -8689,6 +9485,50 @@ function rejectUnknownOptions(noun, subcommand, options) {
 	const unknown = Object.keys(options).find((name) => !allowed.has(name));
 	if (unknown) throw new Error(`Unknown option for ${noun} ${subcommand}: --${unknown}`);
 }
+function rejectGraphUnknownOptions(subcommand, options) {
+	const allowed = new Set([...[
+		"space",
+		"env",
+		"local",
+		"json"
+	], ...subcommand === "run" ? [
+		"upstream",
+		"downstream",
+		"from-scratch",
+		"wait",
+		"request-id"
+	] : []]);
+	const unknown = Object.keys(options).find((name) => !allowed.has(name));
+	if (unknown) throw new Error(`Unknown option for graph ${subcommand}: --${unknown}`);
+}
+function parseGraphWaitSeconds(value) {
+	if (value === void 0 || value === "true") return 1800;
+	const seconds = Number(value);
+	if (!Number.isFinite(seconds) || seconds <= 0 || seconds > 3600) throw new Error("--wait must be between 1 and 3600 seconds");
+	return seconds;
+}
+function publicGraphRun(run, drafts, state) {
+	return {
+		runRef: createGraphRunRef(run.id),
+		requestId: run.request_id,
+		status: run.status,
+		drafts: drafts.map((item) => {
+			const draft = state.drafts.find((candidate) => candidate.id === item.draft_id);
+			const ancestor = state.drafts.find((candidate) => candidate.id === item.failing_ancestor_draft_id);
+			return {
+				draftRef: draft ? createDraftRef(draft.name, draft.id) : null,
+				status: item.status,
+				variantRef: item.variant_id ? variantRefForId(item.variant_id, state.assets, state.variants) : null,
+				reused: item.reused,
+				failingAncestorDraftRef: ancestor ? createDraftRef(ancestor.name, ancestor.id) : null
+			};
+		})
+	};
+}
+function printGraphRun(result, print) {
+	print(`${result.runRef} (${result.status})`);
+	for (const draft of result.drafts) print(`  ${draft.draftRef ?? "unavailable draft"}: ${draft.status}${draft.variantRef ? ` → ${draft.variantRef}` : ""}`);
+}
 function printJsonOrValue(parsed, deps, value, printHuman) {
 	if (parsed.options.json === "true") deps.print(JSON.stringify(value, null, 2));
 	else printHuman();
@@ -8700,6 +9540,20 @@ function printDrafts(drafts, print) {
 	}
 	for (const draft of drafts) print(`${draft.draftRef}  ${draft.mediaMode}  ${draft.status}  ${draft.name}`);
 }
+function printDraft(draft, print) {
+	print(`${draft.draftRef}  ${draft.name}`);
+	print(`  Media: ${draft.mediaMode} (${draft.generatorId})`);
+	print(`  Destination: ${draft.destination}${draft.destinationAssetRef ? ` → ${draft.destinationAssetRef}` : ""}`);
+	print(`  Recipe: ${JSON.stringify(draft.recipeTemplate)}`);
+	const bindings = draft.bindings;
+	print("  Bindings:");
+	if (bindings.length === 0) print("    none");
+	else for (const binding of bindings) {
+		const broken = binding.broken ? ` [broken${binding.brokenReason ? `: ${binding.brokenReason}` : ""}]` : "";
+		print(`    ${binding.slot}[${binding.sortIndex}]: ${binding.sourceKind} → ${binding.sourceRef ?? "unavailable"}${broken}`);
+	}
+	print(`  Last run: ${draft.lastRunVariantRef ?? "none"}`);
+}
 //#endregion
 //#region src/cli/commands/image.ts
 async function handleImage(parsed) {
@@ -9749,6 +10603,33 @@ var defaultDeps$2 = {
 	print: console.log
 };
 var UploadUsageError = class extends Error {};
+var LINEAGE_RELATION_TYPES = new Set([
+	"derived",
+	"refined",
+	"forked"
+]);
+function parseLineageOption(raw, defaultRelationType) {
+	if (!raw) return [];
+	const entries = raw.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+	if (entries.length === 0) throw new UploadUsageError("--lineage requires at least one compact variant ref");
+	return entries.map((entry) => {
+		const atIndex = entry.lastIndexOf("@");
+		const separator = entry.lastIndexOf(":");
+		let ref = entry;
+		let relationType = defaultRelationType;
+		if (atIndex !== -1 && separator > atIndex) {
+			const suffix = entry.slice(separator + 1);
+			if (!LINEAGE_RELATION_TYPES.has(suffix)) throw new UploadUsageError(`--lineage relation in "${entry}" must be derived, refined, or forked`);
+			ref = entry.slice(0, separator);
+			relationType = suffix;
+		}
+		if (!ref.startsWith("asset:")) throw new UploadUsageError(`--lineage requires compact variant refs, got "${ref}"`);
+		return {
+			ref,
+			relationType
+		};
+	});
+}
 async function handleUpload(parsed) {
 	try {
 		await executeUpload(parsed);
@@ -9773,6 +10654,7 @@ async function executeUpload(parsed, deps = defaultDeps$2) {
 	const jsonOutput = parsed.options.json === "true";
 	if (!spaceId) throw new UploadUsageError("--space is required, or run: makefx init --space <id>");
 	if (!assetId && !assetName) throw new UploadUsageError("Either --asset or --name is required");
+	const lineageEntries = parseLineageOption(parsed.options.lineage, assetId ? "refined" : "derived");
 	const mediaType = resolveMediaType(path.extname(filePath).toLowerCase(), requestedMediaKind);
 	const config = await deps.loadConfig(env);
 	if (!config) throw new Error(`Not logged in to ${env} environment. Run: ${loginCommandForEnvironment(env)}`);
@@ -9780,7 +10662,16 @@ async function executeUpload(parsed, deps = defaultDeps$2) {
 	const baseUrl = deps.resolveBaseUrl(env);
 	const accessToken = config.token.accessToken;
 	const createStateClient = () => (deps.createStateClient ?? defaultDeps$2.createStateClient)(env, spaceId);
-	if (assetId) assetId = await resolveCliAssetIdentifier(assetId, createStateClient);
+	let lineage = [];
+	if (assetId || lineageEntries.length > 0) {
+		if (assetId && !assetId.startsWith("asset:")) throw new Error("A compact asset ref is required");
+		const state = await readReferenceSpaceState(createStateClient);
+		if (assetId) assetId = resolveAssetRef(assetId, state.assets);
+		lineage = lineageEntries.map((entry) => ({
+			parentVariantId: resolveVariantRef(entry.ref, state.assets, state.variants),
+			relationType: entry.relationType
+		}));
+	}
 	if (env === "local") process$1.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
 	try {
 		const fileStat = await deps.stat(filePath);
@@ -9798,11 +10689,13 @@ async function executeUpload(parsed, deps = defaultDeps$2) {
 			formData.append("assetName", assetName);
 			formData.append("assetType", assetType);
 		}
+		if (lineage.length > 0) formData.append("lineage", JSON.stringify(lineage));
 		if (!jsonOutput) {
 			deps.print(`\nUploading "${fileName}" to space ${spaceId}...`);
 			deps.print(`  Media kind: ${mediaType.mediaKind}`);
 			if (assetId) deps.print(`  Target asset: ${requestedAssetRef}`);
 			else deps.print(`  Creating asset: "${assetName}" (${assetType})`);
+			for (const entry of lineageEntries) deps.print(`  Lineage: ${entry.relationType} from ${entry.ref}`);
 		}
 		const response = await deps.fetch(`${baseUrl}/api/spaces/${spaceId}/upload`, {
 			method: "POST",
@@ -9888,6 +10781,7 @@ function rejectUnknownUploadOptions(options) {
 		"name",
 		"type",
 		"media-kind",
+		"lineage",
 		"json"
 	]);
 	const unknown = Object.keys(options).find((name) => !allowed.has(name));
@@ -9905,6 +10799,9 @@ Options:
   --name <name>     New asset name (creates asset + variant)
   --type <type>     Asset type for new assets (default: character)
   --media-kind <k>  Optional explicit kind: image, audio, or video
+  --lineage <refs>  Source variant refs this upload was made from, comma-separated,
+                    each optionally suffixed :derived, :refined, or :forked
+                    (default: refined with --asset, derived with --name)
   --json            Print machine-readable output
   --env <env>       Environment (production|stage|local)
   --local           Shortcut for --env local
@@ -9912,6 +10809,7 @@ Options:
 Examples:
   makefx assets upload hero.png --name "Hero Character"
   makefx assets upload paintover.png --asset asset:hero~27f8f176
+  makefx assets upload paintover.png --asset asset:hero~27f8f176 --lineage asset:hero~27f8f176@active
 `);
 }
 //#endregion
@@ -10317,15 +11215,45 @@ async function handleVideo(parsed) {
 	}
 }
 //#endregion
-//#region src/cli/index.ts
-var CLI_VERSION = "1.4.0+d9f20045c1b1";
+//#region src/cli/help.ts
+var TOP_LEVEL_HELP = `Make Effects CLI
+
+Creative:
+  models list | show
+  image generate | regenerate
+  video generate | regenerate
+  audio speech|dialogue|music|sfx generate|regenerate
+  audio voices
+  audio align
+
+Assets:
+  assets list | show | update | delete | upload | download
+  variants show | update | activate | retry | delete
+  collections list | show | create | update | delete | add | remove | pin | unpin
+  drafts list | show | create | update | delete | run
+  bindings set | clear
+  graph run | status | cancel
+
+Workspace:
+  spaces list | show | create | delete | lens
+  init | login | logout
+  usage | spend | billing
+
+Assets and variants use compact refs:
+  asset:name~prefix
+  asset:name~prefix@variant
+
+Run makefx help <noun> for details.`;
 var HELP = {
 	image: `Usage:
-  makefx image generate "prompt" --name <name> --type <type> -o <file> [--model pro|flash|flux] [--refs <variant-ref-or-file,...>]
+  makefx image generate "prompt" --name <name> --type <type> -o <file> [--model pro|flash|flux] [--refs <variant-ref-or-file,...>] [--aspect <ratio>] [--size 1K|2K|4K] [--collection <id>] [--space <id>]
   makefx image regenerate <variant-ref> ["prompt"] [--model pro|flash|flux] [--aspect <ratio>] [--size <size>] [--refs <refs>] [--no-activate] [--wait]`,
 	video: `Usage:
   makefx video generate "prompt" --name <name> --type <type> -o <file> [--model veo-3.1|omni-flash|kling|seedance-1|seedance-2|seedance-2-fast]
-  makefx video regenerate <variant-ref> ["prompt"] [--model <model>] [--aspect <ratio>] [--resolution <value>] [--duration <seconds>] [--no-activate] [--wait]
+      [--refs <variant-ref-or-file,...>] [--first-frame <ref>] [--last-frame <ref>] [--image-refs <refs>] [--video-refs <refs>] [--audio-refs <refs>]
+      [--aspect <ratio>] [--resolution 480p|720p|1080p|4k] [--duration <seconds|auto>] [--tier generate|fast|lite] [--bitrate standard|high]
+      [--audio | --no-audio] [--collection <id>] [--space <id>]
+  makefx video regenerate <variant-ref> ["prompt"] [--model <model>] [--aspect <ratio>] [--resolution <value>] [--duration <seconds>] [--tier <tier>] [--bitrate standard|high] [--audio | --no-audio] [--image-refs <refs>] [--video-refs <refs>] [--audio-refs <refs>] [--no-activate] [--wait]
 
 Seedance mode is inferred: first/last frame selects frame mode, image/video/audio refs select reference mode, and no references selects text mode.`,
 	audio: `Usage:
@@ -10339,7 +11267,9 @@ Seedance mode is inferred: first/last frame selects frame mode, image/video/audi
   makefx audio music generate "prompt" --model eleven-music|lyria-3 --name <name> -o <file>
   makefx audio music regenerate <variant-ref> ["prompt"] [--model eleven-music|lyria-3] [--no-activate] [--wait]
   makefx audio sfx generate "prompt" --name <name> -o <file>
-  makefx audio sfx regenerate <variant-ref> ["prompt"] [--no-activate] [--wait]`,
+  makefx audio sfx regenerate <variant-ref> ["prompt"] [--no-activate] [--wait]
+
+Generate commands also accept [--collection <id>] [--space <id>].`,
 	models: `Usage:
   makefx models list [--media image|video|audio] [--available] [--json]
   makefx models show <model> [--json]`,
@@ -10348,8 +11278,12 @@ Seedance mode is inferred: first/last frame selects frame mode, image/video/audi
   makefx assets show <asset-ref> [--json]
   makefx assets update <asset-ref> [--name <name>] [--type <type>] [--tags <tag,...>]
   makefx assets delete <asset-ref> [--yes]
-  makefx assets upload <file> (--name <name> | --asset <asset-ref>) [--type <type>]
-  makefx assets download <variant-ref> -o <file>`,
+  makefx assets upload <file> (--name <name> | --asset <asset-ref>) [--type <type>] [--lineage <variant-ref[:relation],...>]
+  makefx assets download <variant-ref> -o <file>
+
+Upload --lineage records which variants the file was made from: comma-separated
+compact variant refs, each optionally suffixed :derived, :refined, or :forked
+(default: refined when uploading to --asset, derived when creating with --name).`,
 	variants: `Usage:
   makefx variants show <variant-ref> [--wait <seconds>] [--json]
   makefx variants update <variant-ref> [--starred true|false] [--rating approved|rejected|none]
@@ -10368,9 +11302,15 @@ Seedance mode is inferred: first/last frame selects frame mode, image/video/audi
   makefx collections unpin <collection-id>`,
 	drafts: `Usage:
   makefx drafts list [--json]
-  makefx drafts create "<name>" --media <mode> --generator <id> --recipe <json> --destination new_asset|sibling [--asset <asset-ref>]
-  makefx drafts update <draft-ref> [--name <name>] [--recipe <json>] [--destination new_asset|sibling] [--asset <asset-ref|none>]
-  makefx drafts delete <draft-ref>`,
+  makefx drafts show <draft-ref> [--json]
+  makefx drafts create ("<name>" --media <mode> --generator <id> --recipe <json> | --from <variant-ref> [--name <name>]) [--destination new_asset|sibling] [--asset <asset-ref>] [--x <number>] [--y <number>]
+  makefx drafts update <draft-ref> [--name <name>] [--media <mode>] [--generator <id>] [--recipe <json>] [--destination new_asset|sibling] [--asset <asset-ref|none>] [--x <number|null>] [--y <number|null>]
+  makefx drafts delete <draft-ref>
+  makefx drafts run <draft-ref> [--request-id <id>] [--wait [seconds]]`,
+	graph: `Usage:
+  makefx graph run <draft-ref> [draft-ref...] [--upstream] [--downstream] [--from-scratch] [--wait [seconds]]
+  makefx graph status <graph-run-ref> [--json]
+  makefx graph cancel <graph-run-ref> [--json]`,
 	bindings: `Usage:
   makefx bindings set <draft-ref> <slot> --source variant|asset-active|draft-output --ref <ref> [--sort <index>]
   makefx bindings clear <draft-ref> <slot> [--sort <index>]`,
@@ -10391,34 +11331,11 @@ Seedance mode is inferred: first/last frame selects frame mode, image/video/audi
   makefx billing reconcile
   makefx billing retry-failed`
 };
+//#endregion
+//#region src/cli/index.ts
+var CLI_VERSION = "1.5.0+27ffb5049678";
 function printHelp() {
-	console.log(`Make Effects CLI
-
-Creative:
-  models list | show
-  image generate | regenerate
-  video generate | regenerate
-  audio speech|dialogue|music|sfx generate|regenerate
-  audio voices
-  audio align
-
-Assets:
-  assets list | show | update | delete | upload | download
-  variants show | update | activate | retry | delete
-  collections list | show | create | update | delete | add | remove | pin | unpin
-  drafts list | create | update | delete
-  bindings set | clear
-
-Workspace:
-  spaces list | show | create | delete | lens
-  init | login | logout
-  usage | spend | billing
-
-Assets and variants use compact refs:
-  asset:name~prefix
-  asset:name~prefix@variant
-
-Run makefx help <noun> for details.`);
+	console.log(TOP_LEVEL_HELP);
 }
 function printCommandHelp(noun) {
 	if (!noun) {
@@ -10449,6 +11366,7 @@ async function dispatchCommand(command, parsed) {
 		case "collections": return handleCollections(parsed);
 		case "drafts": return handleDrafts(parsed);
 		case "bindings": return handleBindings(parsed);
+		case "graph": return handleGraph(parsed);
 		case "usage": return handleUsage(parsed);
 		case "spend": return handleSpend(parsed);
 		case "variants": return handleVariants(parsed);