makefx 0.1.3 → 0.2.1

package/makefx.mjs

@@ -44,7 +44,19 @@ var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["modu
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 //#endregion
 //#region src/cli/lib/utils.ts
-var BOOLEAN_LONG_OPTIONS = new Set(["audio", "no-audio"]);
+var BOOLEAN_LONG_OPTIONS = new Set([
+	"audio",
+	"append",
+	"default",
+	"disable",
+	"enable",
+	"json",
+	"local",
+	"no-collection",
+	"no-default",
+	"no-audio",
+	"no-style"
+]);
 function parseArgs(argv) {
 	const options = {};
 	const positionals = [];
@@ -689,6 +701,7 @@ async function handleBillingOpsCheck(env) {
 		if (product?.productId) console.log(`  Product: ${product.productId}${product.name ? ` (${product.name})` : ""}`);
 		console.log(`  Metered prices: ${product?.meteredPriceMeters.length ?? 0}/${productCheck.expectedMeteredPriceMeters.length}`);
 		if (productCheck.missingMeteredPriceMeters.length > 0) console.log(`  Missing metered prices: ${productCheck.missingMeteredPriceMeters.join(", ")}`);
+		if (productCheck.unexpectedMeterCreditBenefitMeters.length > 0) console.log(`  Unexpected meter-credit benefits: ${productCheck.unexpectedMeterCreditBenefitMeters.join(", ")}`);
 	}
 	const syncCheck = billingChecks.checks.syncHealth;
 	console.log("\nSync health:");
@@ -725,8 +738,26 @@ async function handleBillingReconcile(env, parsed) {
 			const marker = meter.matched ? "OK      " : "MISMATCH";
 			console.log(`  ${marker} ${meter.name.padEnd(22)} local=${meter.local} polar=${meter.polar} delta=${meter.delta}`);
 		}
-		if (data.mismatches.length > 0) {
-			console.log("\nMismatched meters need sync/retry investigation before billing is considered reconciled.");
+		if (data.customerCharges) {
+			console.log("\nCustomer charge ledger:");
+			console.log(`  usageEvents=${data.customerCharges.usageEvents} chargeRows=${data.customerCharges.chargeRows} missing=${data.customerCharges.missingChargeRows} orphan=${data.customerCharges.orphanChargeRows}`);
+			console.log(`  billableUsage=${data.customerCharges.billableUsageQuantity} billableCharges=${data.customerCharges.billableChargeQuantity} delta=${data.customerCharges.billableQuantityDelta}`);
+		}
+		if (data.providerCost) {
+			console.log("\nProvider cost ledger:");
+			console.log(`  amount=$${data.providerCost.totals.amountUsd.toFixed(6)} entries=${data.providerCost.totals.entries} unpriced=${data.providerCost.totals.unpricedEntries}`);
+			console.log(`  linkedUsage=${data.providerCost.linkedUsageEvents} linkedCharges=${data.providerCost.linkedCustomerCharges} missingUsage=${data.providerCost.missingUsageEventLinks} missingCharges=${data.providerCost.missingCustomerChargeLinks}`);
+		}
+		if (data.platformUsage) {
+			console.log("\nPlatform usage:");
+			console.log(`  storageBytes=${data.platformUsage.totals.storageBytes} workflowRuns=${data.platformUsage.totals.workflowRuns} deliveryBytes=${data.platformUsage.totals.deliveryBytes}`);
+		}
+		if (data.alerts && data.alerts.length > 0) {
+			console.log("\nAlerts:");
+			for (const alert of data.alerts) console.log(`  ${alert.severity.toUpperCase().padEnd(8)} ${alert.code}: ${alert.message}`);
+		}
+		if (data.status === "mismatch") {
+			console.log("\nMismatched billing ledgers need sync/retry or attribution investigation before billing is considered reconciled.");
 			process$1.exitCode = 1;
 		}
 	} catch (error) {
@@ -808,7 +839,7 @@ function validateProjectConfig(config, configPath) {
 *   makefx spaces --id <space_id>    Show details for a specific space
 *   makefx spaces create <name>      Create a new space
 */
-var defaultDeps$9 = {
+var defaultDeps$12 = {
 	loadConfig: loadStoredConfig,
 	resolveBaseUrl,
 	saveProjectConfig,
@@ -823,7 +854,7 @@ async function handleSpaces(parsed) {
 		process$1.exitCode = 1;
 	}
 }
-async function executeSpaces(parsed, deps = defaultDeps$9) {
+async function executeSpaces(parsed, deps = defaultDeps$12) {
 	const env = resolveCommandEnvironment(parsed);
 	const showDetails = parsed.options.details === "true";
 	const spaceId = parsed.options.id;
@@ -4962,18 +4993,6 @@ function printMessageDetails(message, type) {
 		}
 	}
 }
-//#endregion
-//#region src/cli/commands/upload.ts
-/**
-* Upload Command - Upload media to create variants
-*
-* Usage:
-*   makefx upload <file> --space <id> --asset <id>     Upload to existing asset
-*   makefx upload <file> --space <id> --name <name>    Create new asset
-*   makefx upload <file> --space <id> --name <name> --type <type>
-*/
-var MAX_FILE_SIZE_MB$1 = 10;
-var MAX_FILE_SIZE_BYTES$1 = MAX_FILE_SIZE_MB$1 * 1024 * 1024;
 var EXT_TO_MEDIA_TYPE = {
 	".aac": {
 		mediaKind: "audio",
@@ -5037,7 +5056,28 @@ var EXT_TO_MEDIA_TYPE = {
 	}
 };
 var ALLOWED_EXTENSIONS$1 = Object.keys(EXT_TO_MEDIA_TYPE).sort();
-var defaultDeps$8 = {
+function resolveMediaType(ext, requestedMediaKind) {
+	const mediaType = EXT_TO_MEDIA_TYPE[ext];
+	if (!mediaType) throw new Error(`Invalid file type "${ext}". Allowed types: ${ALLOWED_EXTENSIONS$1.join(", ")}`);
+	if (requestedMediaKind !== void 0 && requestedMediaKind !== "image" && requestedMediaKind !== "audio" && requestedMediaKind !== "video") throw new Error("Invalid --media-kind. Expected image, audio, or video");
+	if (ext === ".webm" && requestedMediaKind === "audio") return {
+		mediaKind: "audio",
+		mimeType: "audio/webm"
+	};
+	if (requestedMediaKind && requestedMediaKind !== mediaType.mediaKind) throw new Error(`--media-kind ${requestedMediaKind} does not match ${ext} (${mediaType.mediaKind})`);
+	return mediaType;
+}
+//#endregion
+//#region src/cli/commands/upload.ts
+/**
+* Upload Command - Upload one media file to create variants
+*
+* Usage:
+*   makefx upload <file> --space <id> --asset <id>     Upload to existing asset
+*   makefx upload <file> --space <id> --name <name>    Upload as new asset
+*   makefx upload <file> --space <id> --name <name> --type <type>
+*/
+var defaultDeps$11 = {
 	loadConfig: loadStoredConfig,
 	loadProjectConfig,
 	resolveBaseUrl,
@@ -5052,50 +5092,111 @@ async function handleUpload(parsed) {
 		await executeUpload(parsed);
 	} catch (error) {
 		console.error(error instanceof Error ? `Error: ${error.message}` : "Error: Upload failed");
-		if (error instanceof UploadUsageError) printUsage$9();
+		if (error instanceof UploadUsageError) printUsage$11();
 		process$1.exitCode = 1;
 	}
 }
-async function executeUpload(parsed, deps = defaultDeps$8) {
+async function executeUpload(parsed, deps = defaultDeps$11) {
+	const filePath = parsed.positionals[0];
+	if (!filePath) throw new UploadUsageError("File path is required");
 	const projectConfig = await deps.loadProjectConfig();
 	const env = resolveCommandEnvironment(parsed, projectConfig);
 	const spaceId = resolveCommandSpace(parsed, projectConfig);
 	const assetId = parsed.options.asset;
 	const assetName = parsed.options.name;
 	const assetType = parsed.options.type || "character";
-	const parentAssetId = parsed.options.parent;
 	const requestedMediaKind = parsed.options["media-kind"] || parsed.options.mediaKind;
-	const filePath = parsed.positionals[0];
-	if (!filePath) throw new UploadUsageError("File path is required");
+	const prompt = parsed.options.prompt;
+	const model = parsed.options.model;
+	const provider = parsed.options.provider;
+	const rawProviderMetadata = parsed.options["provider-metadata"] ?? parsed.options.providerMetadata ?? parsed.options.provider_metadata;
+	const rawGenerationProvenance = parsed.options["generation-provenance"] ?? parsed.options.generationProvenance ?? parsed.options.generation_provenance;
+	const sourceVariantId = parsed.options["source-variant"] ?? parsed.options.sourceVariantId ?? parsed.options.parentVariantId;
+	const rawRelationType = parsed.options["relation-type"] ?? parsed.options.relationType;
+	const rawActiveVariantBehavior = parsed.options["active-variant-behavior"] ?? parsed.options.activeVariantBehavior;
+	const rawCollectionIds = parsed.options.collection ?? parsed.options.collections;
+	const rawCollectionNames = parsed.options["collection-name"] ?? parsed.options.collectionName;
+	const rawCollectionRole = parsed.options["collection-role"] ?? parsed.options.collectionRole;
+	const rawCollectionSubject = parsed.options["collection-subject"] ?? parsed.options.collectionSubject;
+	const rawCollectionPinnedVariant = parsed.options["collection-pinned-variant"] ?? parsed.options.collectionPinnedVariant;
+	const rawManualRelation = parsed.options["manual-relation"] ?? parsed.options.manualRelation;
+	const rawManualRelationSubject = parsed.options["manual-relation-subject"] ?? parsed.options.manualRelationSubject;
+	const rawManualRelationLabel = parsed.options["manual-relation-label"] ?? parsed.options.manualRelationLabel;
+	const rawManualRelationContext = parsed.options["manual-relation-context"] ?? parsed.options.manualRelationContext;
+	const rawManualRelationMetadata = parsed.options["manual-relation-metadata"] ?? parsed.options.manualRelationMetadata;
+	const jsonOutput = parsed.options.json === "true";
+	if (parsed.options["dry-run"] === "true" || parsed.options.dryRun === "true") throw new UploadUsageError("--dry-run is not supported for direct file upload");
 	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");
+	if (!sourceVariantId && (parsed.options["relation-type"] || parsed.options.relationType)) throw new UploadUsageError("--relation-type requires --source-variant");
+	const providerMetadata = parseJsonObjectOption(rawProviderMetadata, "--provider-metadata");
+	const generationProvenance = parseJsonObjectOption(rawGenerationProvenance, "--generation-provenance");
+	const relationType = normalizeRelationType(rawRelationType);
+	const activeVariantBehavior = normalizeActiveVariantBehavior(rawActiveVariantBehavior);
+	const collectionPlacements = parseCollectionPlacements({
+		collectionIds: rawCollectionIds,
+		collectionNames: rawCollectionNames,
+		role: rawCollectionRole,
+		subjectType: rawCollectionSubject,
+		pinnedVariant: rawCollectionPinnedVariant
+	});
+	const manualRelations = parseManualRelations({
+		relations: rawManualRelation,
+		subjectType: rawManualRelationSubject,
+		label: rawManualRelationLabel,
+		context: rawManualRelationContext,
+		metadata: rawManualRelationMetadata
+	});
 	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)}`);
 	if (config.token.expiresAt < Date.now()) throw new Error(`Token expired for ${env} environment. Run: ${loginCommandForEnvironment(env)}`);
 	const baseUrl = deps.resolveBaseUrl(env);
 	const accessToken = config.token.accessToken;
+	const ctx = {
+		spaceId,
+		baseUrl,
+		accessToken
+	};
 	if (env === "local") process$1.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
 	try {
 		const fileStat = await deps.stat(filePath);
 		if (!fileStat.isFile()) throw new Error(`"${filePath}" is not a file`);
-		if (fileStat.size > MAX_FILE_SIZE_BYTES$1) throw new Error(`File too large (${(fileStat.size / 1024 / 1024).toFixed(2)}MB). Maximum size: ${MAX_FILE_SIZE_MB$1}MB`);
+		if (fileStat.size > 10485760) throw new Error(`File too large (${(fileStat.size / 1024 / 1024).toFixed(2)}MB). Maximum size: 10MB`);
+		await preflightUploadOrganization(ctx, deps, {
+			assetId,
+			sourceVariantId,
+			collectionPlacements,
+			manualRelations
+		});
 		const fileBuffer = await deps.readFile(filePath);
 		const fileName = path.basename(filePath);
 		const formData = new FormData();
 		const blob = new Blob([fileBuffer], { type: mediaType.mimeType });
 		formData.append("file", blob, fileName);
 		formData.append("mediaKind", mediaType.mediaKind);
+		formData.append("activeVariantBehavior", activeVariantBehavior);
 		if (assetId) formData.append("assetId", assetId);
 		else {
 			formData.append("assetName", assetName);
 			formData.append("assetType", assetType);
-			if (parentAssetId) formData.append("parentAssetId", parentAssetId);
 		}
-		deps.print(`\nUploading "${fileName}" to space ${spaceId}...`);
-		deps.print(`  Media kind: ${mediaType.mediaKind}`);
-		if (assetId) deps.print(`  Target asset: ${assetId}`);
-		else deps.print(`  Creating asset: "${assetName}" (${assetType})`);
+		if (prompt) formData.append("prompt", prompt);
+		if (model) formData.append("model", model);
+		if (provider) formData.append("provider", provider);
+		if (providerMetadata) formData.append("providerMetadata", JSON.stringify(providerMetadata));
+		if (generationProvenance) formData.append("generationProvenance", JSON.stringify(generationProvenance));
+		if (sourceVariantId) formData.append("lineage", JSON.stringify([{
+			parentVariantId: sourceVariantId,
+			relationType
+		}]));
+		if (!jsonOutput) {
+			deps.print(`\nUploading "${fileName}" to space ${spaceId}...`);
+			deps.print(`  Media kind: ${mediaType.mediaKind}`);
+			if (assetId) deps.print(`  Target asset: ${assetId}`);
+			else deps.print(`  Creating asset: "${assetName}" (${assetType})`);
+			if (sourceVariantId) deps.print(`  Source variant: ${sourceVariantId} (${relationType})`);
+		}
 		const response = await deps.fetch(`${baseUrl}/api/spaces/${spaceId}/upload`, {
 			method: "POST",
 			headers: { "Authorization": `Bearer ${accessToken}` },
@@ -5104,6 +5205,29 @@ async function executeUpload(parsed, deps = defaultDeps$8) {
 		const data = await response.json();
 		if (!response.ok) throw new Error(`Upload failed: ${"error" in data ? data.error : response.statusText}`);
 		const upload = data;
+		let organization = {
+			collectionItemIds: [],
+			relationIds: []
+		};
+		try {
+			organization = await applyUploadOrganization(ctx, deps, upload, {
+				collectionPlacements,
+				manualRelations
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			throw new Error(`Upload created asset ${upload.variant.asset_id} and variant ${upload.variant.id}, but organization failed: ${message}`);
+		}
+		const result = {
+			asset: upload.asset,
+			variant: upload.variant,
+			lineage: upload.lineage,
+			organization
+		};
+		if (jsonOutput) {
+			deps.print(JSON.stringify(result, null, 2));
+			return result;
+		}
 		deps.print("\nUpload successful!\n");
 		if (upload.asset) {
 			deps.print("New Asset:");
@@ -5121,6 +5245,11 @@ async function executeUpload(parsed, deps = defaultDeps$8) {
 		if (upload.variant.image_key) deps.print(`  Image:    ${upload.variant.image_key}`);
 		if (upload.variant.thumb_key) deps.print(`  Thumb:    ${upload.variant.thumb_key}`);
 		if (upload.variant.media_mime_type) deps.print(`  MIME:     ${upload.variant.media_mime_type}`);
+		if (organization.collectionItemIds.length > 0 || organization.relationIds.length > 0) {
+			deps.print("\nOrganization:");
+			if (organization.collectionItemIds.length > 0) deps.print(`  Collection items: ${organization.collectionItemIds.join(", ")}`);
+			if (organization.relationIds.length > 0) deps.print(`  Relations:        ${organization.relationIds.join(", ")}`);
+		}
 		if (upload.variant.recipe) try {
 			const recipe = JSON.parse(upload.variant.recipe);
 			deps.print("\nRecipe:");
@@ -5130,31 +5259,235 @@ async function executeUpload(parsed, deps = defaultDeps$8) {
 		} catch {}
 		deps.print("\nTo inspect:");
 		deps.print(`  makefx assets show ${upload.variant.asset_id} --space ${spaceId}`);
-		return {
-			asset: upload.asset,
-			variant: upload.variant
-		};
+		return result;
 	} catch (error) {
 		if (error.code === "ENOENT") throw new Error(`File not found: ${filePath}`);
 		throw error;
 	}
 }
-function resolveMediaType(ext, requestedMediaKind) {
-	const mediaType = EXT_TO_MEDIA_TYPE[ext];
-	if (!mediaType) throw new Error(`Invalid file type "${ext}". Allowed types: ${ALLOWED_EXTENSIONS$1.join(", ")}`);
-	if (requestedMediaKind !== void 0 && requestedMediaKind !== "image" && requestedMediaKind !== "audio" && requestedMediaKind !== "video") throw new Error("Invalid --media-kind. Expected image, audio, or video");
-	if (ext === ".webm" && requestedMediaKind === "audio") return {
-		mediaKind: "audio",
-		mimeType: "audio/webm"
+function parseJsonObjectOption(value, optionName) {
+	if (value === void 0) return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(value);
+	} catch {
+		throw new UploadUsageError(`${optionName} must be valid JSON`);
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new UploadUsageError(`${optionName} must be a JSON object`);
+	return parsed;
+}
+function parseJsonObjectOrStringOption(value, optionName) {
+	if (value === void 0) return void 0;
+	if (!value.trim().startsWith("{")) return value;
+	return parseJsonObjectOption(value, optionName);
+}
+function normalizeRelationType(value) {
+	if (!value) return "derived";
+	if (value === "derived" || value === "refined" || value === "forked") return value;
+	throw new UploadUsageError("--relation-type must be derived, refined, or forked");
+}
+function normalizeActiveVariantBehavior(value) {
+	if (!value || value === "if-missing" || value === "if_missing") return "if-missing";
+	if (value === "set-active" || value === "set_active") return "set-active";
+	if (value === "keep") return "keep";
+	throw new UploadUsageError("--active-variant-behavior must be if-missing, set-active, or keep");
+}
+function normalizeSpaceSubjectType(value, optionName, defaultValue) {
+	if (!value) return defaultValue;
+	if (value === "asset" || value === "variant") return value;
+	throw new UploadUsageError(`${optionName} must be asset or variant`);
+}
+function normalizeManualRelationType(value, optionName) {
+	if ([
+		"appears_in",
+		"background_for",
+		"style_reference_for",
+		"thumbnail_for",
+		"alternate_of",
+		"prop_in",
+		"map_for",
+		"part_of",
+		"reference_for",
+		"custom"
+	].includes(value)) return value;
+	throw new UploadUsageError(`${optionName} relation type is invalid`);
+}
+function parseCsvOption$1(value, optionName) {
+	if (!value) return [];
+	if (value === "true") throw new UploadUsageError(`${optionName} requires a value`);
+	return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function parseCollectionPlacements(input) {
+	const collectionIds = parseCsvOption$1(input.collectionIds, "--collection");
+	const collectionNames = parseCsvOption$1(input.collectionNames, "--collection-name");
+	if (collectionIds.length === 0 && collectionNames.length === 0) return [];
+	const subjectType = normalizeSpaceSubjectType(input.subjectType, "--collection-subject", "asset");
+	if (subjectType === "variant" && input.pinnedVariant && input.pinnedVariant !== "true") throw new UploadUsageError("--collection-pinned-variant can only be used when --collection-subject is asset");
+	const pinnedVariantId = normalizeCollectionPinnedVariant(input.pinnedVariant);
+	const placement = {
+		role: input.role && input.role !== "true" ? input.role : "member",
+		subjectType,
+		pinnedVariantId
+	};
+	return [...collectionIds.map((collectionId) => ({
+		...placement,
+		collectionId
+	})), ...collectionNames.map((collectionName) => ({
+		...placement,
+		collectionName
+	}))];
+}
+function normalizeCollectionPinnedVariant(value) {
+	if (!value || value === "true" || value === "uploaded") return void 0;
+	if (value === "none" || value === "unpin") return null;
+	return value;
+}
+function parseManualRelations(input) {
+	const relationSpecs = parseCsvOption$1(input.relations, "--manual-relation");
+	if (relationSpecs.length === 0) return [];
+	const subjectType = normalizeSpaceSubjectType(input.subjectType, "--manual-relation-subject", "variant");
+	const context = parseJsonObjectOrStringOption(input.context, "--manual-relation-context");
+	const metadata = parseJsonObjectOption(input.metadata, "--manual-relation-metadata");
+	return relationSpecs.map((spec) => {
+		const parts = spec.split(":");
+		if (parts.length !== 3) throw new UploadUsageError("--manual-relation entries must use <relation-type>:asset:<asset-id> or <relation-type>:variant:<variant-id>");
+		const [relationTypeValue, objectTypeValue, objectId] = parts;
+		const objectType = normalizeSpaceSubjectType(objectTypeValue, "--manual-relation object type", "asset");
+		if (!objectId) throw new UploadUsageError("--manual-relation object id is required");
+		return {
+			relationType: normalizeManualRelationType(relationTypeValue, "--manual-relation"),
+			object: objectType === "asset" ? {
+				subjectType: "asset",
+				assetId: objectId
+			} : {
+				subjectType: "variant",
+				variantId: objectId
+			},
+			subjectType,
+			label: input.label && input.label !== "true" ? input.label : void 0,
+			context,
+			metadata
+		};
+	});
+}
+async function preflightUploadOrganization(ctx, deps, options) {
+	const needsCollections = options.collectionPlacements.length > 0;
+	const needsAssetState = Boolean(options.sourceVariantId) || options.manualRelations.length > 0 || options.collectionPlacements.some((placement) => placement.pinnedVariantId);
+	const [collections, state] = await Promise.all([needsCollections ? fetchJson$1(ctx, deps, `/api/spaces/${ctx.spaceId}/collections`) : void 0, needsAssetState ? fetchAssetState(ctx, deps) : void 0]);
+	if (collections) {
+		const collectionList = collections.collections ?? [];
+		const collectionIds = new Set(collectionList.map((collection) => collection.id));
+		for (const placement of options.collectionPlacements) {
+			if (placement.collectionId && !collectionIds.has(placement.collectionId)) throw new Error(`Collection not found: ${placement.collectionId}`);
+			if (!placement.collectionName) continue;
+			const matches = collectionList.filter((collection) => collection.name === placement.collectionName);
+			if (matches.length === 0) throw new Error(`Collection not found by exact name: ${placement.collectionName}`);
+			if (matches.length > 1) throw new Error(`Collection name is ambiguous: ${placement.collectionName}; use --collection <id>`);
+			placement.collectionId = matches[0].id;
+		}
+	}
+	if (!state) return;
+	if (options.sourceVariantId && !state.variantsById.has(options.sourceVariantId)) throw new Error(`Source variant not found in space: ${options.sourceVariantId}`);
+	for (const placement of options.collectionPlacements) {
+		if (!placement.pinnedVariantId) continue;
+		const pinned = state.variantsById.get(placement.pinnedVariantId);
+		if (!pinned) throw new Error(`Collection pinned variant not found: ${placement.pinnedVariantId}`);
+		if (placement.subjectType === "asset") {
+			if (!options.assetId) throw new Error("--collection-pinned-variant cannot reference an existing variant when creating a new asset");
+			if (pinned.asset_id !== options.assetId) throw new Error("--collection-pinned-variant must reference a variant on the target asset");
+		}
+	}
+	for (const relation of options.manualRelations) if (relation.object.subjectType === "asset") {
+		if (!relation.object.assetId || !state.assetsById.has(relation.object.assetId)) throw new Error(`Manual relation object asset not found: ${relation.object.assetId ?? ""}`);
+	} else if (!relation.object.variantId || !state.variantsById.has(relation.object.variantId)) throw new Error(`Manual relation object variant not found: ${relation.object.variantId ?? ""}`);
+}
+async function fetchAssetState(ctx, deps) {
+	const assets = (await fetchJson$1(ctx, deps, `/api/spaces/${ctx.spaceId}/assets`)).assets ?? [];
+	const variantsById = /* @__PURE__ */ new Map();
+	await Promise.all(assets.map(async (asset) => {
+		const details = await fetchJson$1(ctx, deps, `/api/spaces/${ctx.spaceId}/assets/${encodeURIComponent(asset.id)}`);
+		for (const variant of details.variants ?? []) variantsById.set(variant.id, variant);
+	}));
+	return {
+		assetsById: new Map(assets.map((asset) => [asset.id, asset])),
+		variantsById
+	};
+}
+async function applyUploadOrganization(ctx, deps, upload, options) {
+	const collectionItemIds = [];
+	const relationIds = [];
+	const uploadedSubject = {
+		assetId: upload.variant.asset_id,
+		variantId: upload.variant.id
+	};
+	for (const placement of options.collectionPlacements) {
+		if (!placement.collectionId) throw new Error(`Collection name was not resolved: ${placement.collectionName ?? ""}`);
+		const body = placement.subjectType === "asset" ? {
+			subjectType: "asset",
+			assetId: uploadedSubject.assetId,
+			role: placement.role,
+			pinnedVariantId: placement.pinnedVariantId === void 0 ? uploadedSubject.variantId : placement.pinnedVariantId
+		} : {
+			subjectType: "variant",
+			variantId: uploadedSubject.variantId,
+			role: placement.role
+		};
+		const created = await postJson(ctx, deps, `/api/spaces/${ctx.spaceId}/collections/${encodeURIComponent(placement.collectionId)}/items`, body);
+		collectionItemIds.push(created.item.id);
+	}
+	for (const relation of options.manualRelations) {
+		const created = await postJson(ctx, deps, `/api/spaces/${ctx.spaceId}/relations`, {
+			subject: relation.subjectType === "asset" ? {
+				subjectType: "asset",
+				assetId: uploadedSubject.assetId
+			} : {
+				subjectType: "variant",
+				variantId: uploadedSubject.variantId
+			},
+			object: relation.object,
+			relationType: relation.relationType,
+			label: relation.label,
+			context: relation.context,
+			metadata: relation.metadata
+		});
+		relationIds.push(created.relation.id);
+	}
+	return {
+		collectionItemIds,
+		relationIds
 	};
-	if (requestedMediaKind && requestedMediaKind !== mediaType.mediaKind) throw new Error(`--media-kind ${requestedMediaKind} does not match ${ext} (${mediaType.mediaKind})`);
-	return mediaType;
 }
-function printUsage$9() {
+async function postJson(ctx, deps, requestPath, json) {
+	const response = await deps.fetch(`${ctx.baseUrl}${requestPath}`, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${ctx.accessToken}`,
+			Accept: "application/json",
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify(stripUndefined(json))
+	});
+	const data = await response.json().catch(() => ({}));
+	if (!response.ok) throw new Error("error" in data ? data.error : `Request failed: ${response.status}`);
+	return data;
+}
+async function fetchJson$1(ctx, deps, requestPath) {
+	const response = await deps.fetch(`${ctx.baseUrl}${requestPath}`, { headers: {
+		Authorization: `Bearer ${ctx.accessToken}`,
+		Accept: "application/json"
+	} });
+	const data = await response.json().catch(() => ({}));
+	if (!response.ok) throw new Error("error" in data ? data.error : `Request failed: ${response.status}`);
+	return data;
+}
+function stripUndefined(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
+function printUsage$11() {
 	console.log(`
 Usage:
   makefx upload <file> --asset <id> [--space <id>]     Upload media to existing asset
-  makefx upload <file> --name <name> [--space <id>]    Create new asset
+  makefx upload <file> --name <name> [--space <id>]    Upload media as a new asset
 
 Options:
   --space <id>      Target space ID; defaults from initialized project
@@ -5162,16 +5495,43 @@ 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
-  --parent <id>     Parent asset ID for new assets
+  --prompt <text>   Prompt provenance for uploaded media
+  --model <model>   Model provenance for uploaded media
+  --provider <name> Provider provenance for uploaded media
+  --provider-metadata <json>     Provider metadata JSON object
+  --generation-provenance <json> Extra provenance JSON object
+  --source-variant <id>          Existing source variant for upload lineage
+  --relation-type <type>         Lineage type: derived, refined, or forked (default: derived)
+  --active-variant-behavior <b>  if-missing, set-active, or keep
+  --collection <ids>             Comma-separated collection IDs for the uploaded asset or variant
+  --collection-name <names>      Comma-separated exact collection names for lookup
+  --collection-role <role>       Collection item role (default: member)
+  --collection-subject <type>    Collection subject: asset or variant (default: asset)
+  --collection-pinned-variant <id|uploaded|none>
+                                 Pin an asset collection item to the uploaded variant by default
+  --manual-relation <spec>       Comma-separated <type>:asset:<id> or <type>:variant:<id>
+  --manual-relation-subject <type>
+                                 Relation subject: uploaded asset or variant (default: variant)
+  --manual-relation-label <text> Optional manual relation label
+  --manual-relation-context <json|string>
+                                 Optional manual relation context
+  --manual-relation-metadata <json>
+                                 Optional manual relation metadata object
+  --json            Print machine-readable upload output with Space IDs
   --env <env>       Environment (production|stage|local)
   --local           Shortcut for --env local
 
 Examples:
   makefx upload hero.png --space abc123 --name "Hero Character"
+  makefx upload hero.png --space abc123 --name "Hero" --prompt "external render" --provider blender
+  makefx upload paintover.png --space abc123 --asset def456 --source-variant var123 --relation-type refined
+  makefx upload hero.png --space abc123 --name "Hero" --collection collection_cast --collection-role character
+  makefx upload hero.png --space abc123 --name "Hero" --collection-name "Cast" --collection-role character
+  makefx upload thumbnail.png --space abc123 --asset asset_thumb --manual-relation thumbnail_for:asset:asset_target
   makefx upload theme.mp3 --space abc123 --name "Theme Music" --type audio
   makefx upload cutscene.mp4 --space abc123 --name "Opening Cutscene" --type video
   makefx upload variant.jpg --space abc123 --asset def456
-  makefx upload sword.png --space abc123 --name "Sword" --type item --parent abc789
+  makefx upload hero.png --space abc123 --name "Hero" --json
 `);
 }
 //#endregion
@@ -19110,7 +19470,8 @@ var UserProfileSchema = object({
 }).openapi("UserProfile");
 var SessionConfigSchema = object({
 	googleClientId: string$1(),
-	environment: string$1()
+	environment: string$1(),
+	features: object({ rotation: boolean$1() })
 }).openapi("SessionConfig");
 var AuthSessionResponseSchema = object({
 	user: ApiUserSchema.nullable(),
@@ -19138,6 +19499,33 @@ var UserSettingsResponseSchema = object({
 	success: literal(true),
 	user: ApiUserSchema
 }).openapi("UserSettingsResponse");
+var ProviderKeyProviderSchema = _enum([
+	"google_ai",
+	"anthropic",
+	"elevenlabs",
+	"lyria"
+]).openapi("ProviderKeyProvider");
+var ProviderKeyParamsSchema = object({ provider: ProviderKeyProviderSchema.openapi({ param: {
+	name: "provider",
+	in: "path"
+} }) });
+var ProviderKeySummarySchema = object({
+	provider: ProviderKeyProviderSchema,
+	label: string$1(),
+	configured: boolean$1(),
+	keyHint: string$1().nullable(),
+	updatedAt: string$1().nullable(),
+	platformConfigured: boolean$1()
+}).openapi("ProviderKeySummary");
+var ListProviderKeysResponseSchema = object({
+	success: literal(true),
+	providers: array(ProviderKeySummarySchema)
+}).openapi("ListProviderKeysResponse");
+var UpsertProviderKeyRequestSchema = object({ apiKey: string$1() }).openapi("UpsertProviderKeyRequest");
+var ProviderKeyResponseSchema = object({
+	success: literal(true),
+	provider: ProviderKeySummarySchema
+}).openapi("ProviderKeyResponse");
 var SpaceRoleSchema = _enum([
 	"owner",
 	"editor",
@@ -19191,6 +19579,12 @@ var VariantStatusSchema = _enum([
 	"completed",
 	"failed"
 ]);
+var PlatformUsageTypeSchema = _enum([
+	"storage",
+	"workflow",
+	"delivery"
+]);
+var PlatformUsageUnitSchema = _enum(["byte", "run"]);
 var BooleanFromSqliteSchema = union([
 	boolean$1(),
 	literal(0),
@@ -19240,10 +19634,454 @@ var VariantSchema = object({
 	created_at: number$1(),
 	updated_at: number$1().nullable()
 }).passthrough().openapi("Variant");
+var LineageSchema = object({
+	id: string$1(),
+	parent_variant_id: string$1(),
+	child_variant_id: string$1(),
+	relation_type: _enum([
+		"derived",
+		"refined",
+		"forked"
+	]),
+	severed: BooleanFromSqliteSchema.optional(),
+	created_at: number$1().optional()
+}).passthrough().openapi("Lineage");
 var ListSpaceAssetsResponseSchema = object({
 	success: literal(true),
 	assets: array(AssetSchema)
 }).openapi("ListSpaceAssetsResponse");
+var SpaceSubjectTypeSchema = _enum(["asset", "variant"]);
+var CollectionKindSchema = _enum([
+	"cast",
+	"style_refs",
+	"backgrounds",
+	"scenes",
+	"thumbnails",
+	"maps",
+	"deliverables",
+	"custom"
+]);
+var SpaceRelationTypeSchema = _enum([
+	"appears_in",
+	"background_for",
+	"style_reference_for",
+	"thumbnail_for",
+	"alternate_of",
+	"prop_in",
+	"map_for",
+	"part_of",
+	"reference_for",
+	"custom"
+]);
+var CompositionItemRoleSchema = _enum([
+	"output",
+	"background",
+	"character",
+	"prop",
+	"style_ref",
+	"overlay",
+	"map",
+	"thumbnail",
+	"custom"
+]);
+var CompositionStatusSchema = _enum(["draft", "final"]);
+var CollectionIdParamsSchema = SpaceIdParamsSchema.extend({ collectionId: string$1().openapi({ param: {
+	name: "collectionId",
+	in: "path"
+} }) });
+var CollectionItemParamsSchema = CollectionIdParamsSchema.extend({ itemId: string$1().openapi({ param: {
+	name: "itemId",
+	in: "path"
+} }) });
+var StylePresetParamsSchema = SpaceIdParamsSchema.extend({ presetId: string$1().openapi({ param: {
+	name: "presetId",
+	in: "path"
+} }) });
+var RelationParamsSchema = SpaceIdParamsSchema.extend({ relationId: string$1().openapi({ param: {
+	name: "relationId",
+	in: "path"
+} }) });
+var CompositionIdParamsSchema = SpaceIdParamsSchema.extend({ compositionId: string$1().openapi({ param: {
+	name: "compositionId",
+	in: "path"
+} }) });
+var CompositionItemParamsSchema = CompositionIdParamsSchema.extend({ itemId: string$1().openapi({ param: {
+	name: "itemId",
+	in: "path"
+} }) });
+var SpaceSubjectSchema = object({
+	subjectType: SpaceSubjectTypeSchema,
+	assetId: string$1().optional(),
+	variantId: string$1().optional()
+}).openapi("SpaceSubject");
+var SpaceCollectionSchema = object({
+	id: string$1(),
+	name: string$1(),
+	kind: CollectionKindSchema,
+	color: string$1().nullable(),
+	description: string$1().nullable(),
+	sort_index: number$1().int(),
+	created_by: string$1(),
+	created_at: number$1(),
+	updated_at: number$1()
+}).openapi("SpaceCollection");
+var CollectionItemSchema = object({
+	id: string$1(),
+	collection_id: string$1(),
+	subject_type: SpaceSubjectTypeSchema,
+	asset_id: string$1().nullable(),
+	variant_id: string$1().nullable(),
+	role: string$1(),
+	pinned_variant_id: string$1().nullable(),
+	sort_index: number$1().int(),
+	created_by: string$1(),
+	created_at: number$1(),
+	updated_at: number$1()
+}).openapi("CollectionItem");
+var StyleReferenceCollectionSchema = SpaceCollectionSchema.extend({
+	reference_count: number$1().int(),
+	preset_count: number$1().int()
+}).openapi("StyleReferenceCollection");
+var StylePresetSchema = object({
+	id: string$1(),
+	name: string$1(),
+	description: string$1().nullable(),
+	style_prompt: string$1(),
+	collection_id: string$1().nullable(),
+	enabled: BooleanFromSqliteSchema,
+	is_default: BooleanFromSqliteSchema,
+	created_by: string$1(),
+	created_at: number$1(),
+	updated_at: number$1(),
+	collection_name: string$1().nullable(),
+	reference_count: number$1().int(),
+	style_reference_variant_ids: array(string$1()),
+	style_reference_image_keys: array(string$1())
+}).openapi("StylePreset");
+var SpaceRelationSchema = object({
+	id: string$1(),
+	subject_type: SpaceSubjectTypeSchema,
+	subject_asset_id: string$1().nullable(),
+	subject_variant_id: string$1().nullable(),
+	object_type: SpaceSubjectTypeSchema,
+	object_asset_id: string$1().nullable(),
+	object_variant_id: string$1().nullable(),
+	relation_type: SpaceRelationTypeSchema,
+	label: string$1().nullable(),
+	context: string$1().nullable(),
+	metadata: string$1(),
+	sort_index: number$1().int(),
+	created_by: string$1(),
+	created_at: number$1(),
+	updated_at: number$1()
+}).openapi("SpaceRelation");
+var CompositionSchema = object({
+	id: string$1(),
+	name: string$1(),
+	description: string$1().nullable(),
+	status: CompositionStatusSchema,
+	output_asset_id: string$1().nullable(),
+	output_variant_id: string$1().nullable(),
+	metadata: string$1(),
+	sort_index: number$1().int(),
+	created_by: string$1(),
+	created_at: number$1(),
+	updated_at: number$1()
+}).openapi("Composition");
+var CompositionItemSchema = object({
+	id: string$1(),
+	composition_id: string$1(),
+	role: CompositionItemRoleSchema,
+	label: string$1().nullable(),
+	asset_id: string$1().nullable(),
+	variant_id: string$1(),
+	metadata: string$1(),
+	sort_index: number$1().int(),
+	created_by: string$1(),
+	created_at: number$1(),
+	updated_at: number$1()
+}).openapi("CompositionItem");
+var UpsertCollectionRequestSchema = object({
+	id: string$1().optional(),
+	name: string$1().min(1),
+	kind: CollectionKindSchema.optional(),
+	color: string$1().nullable().optional(),
+	description: string$1().nullable().optional(),
+	sortIndex: number$1().int().optional()
+}).openapi("UpsertCollectionRequest");
+var UpdateCollectionRequestSchema = UpsertCollectionRequestSchema.omit({ id: true }).partial().openapi("UpdateCollectionRequest");
+var UpsertCollectionItemRequestSchema = object({
+	id: string$1().optional(),
+	subjectType: SpaceSubjectTypeSchema,
+	assetId: string$1().optional(),
+	variantId: string$1().optional(),
+	role: string$1().optional(),
+	pinnedVariantId: string$1().nullable().optional(),
+	sortIndex: number$1().int().optional()
+}).openapi("UpsertCollectionItemRequest");
+var UpsertStylePresetRequestSchema = object({
+	id: string$1().optional(),
+	name: string$1().min(1),
+	description: string$1().nullable().optional(),
+	stylePrompt: string$1().optional(),
+	collectionId: string$1().nullable().optional(),
+	enabled: boolean$1().optional(),
+	isDefault: boolean$1().optional()
+}).openapi("UpsertStylePresetRequest");
+var UpdateStylePresetRequestSchema = UpsertStylePresetRequestSchema.omit({
+	id: true,
+	name: true
+}).extend({ name: string$1().min(1).optional() }).openapi("UpdateStylePresetRequest");
+var UpdateCollectionItemRequestSchema = object({
+	role: string$1().optional(),
+	pinnedVariantId: string$1().nullable().optional(),
+	sortIndex: number$1().int().optional()
+}).openapi("UpdateCollectionItemRequest");
+var ReorderItemsRequestSchema = object({ itemIds: array(string$1()) }).openapi("ReorderItemsRequest");
+var UpsertRelationRequestSchema = object({
+	id: string$1().optional(),
+	subject: SpaceSubjectSchema,
+	object: SpaceSubjectSchema,
+	relationType: SpaceRelationTypeSchema,
+	label: string$1().nullable().optional(),
+	context: union([string$1(), record(string$1(), unknown())]).nullable().optional(),
+	metadata: record(string$1(), unknown()).optional(),
+	sortIndex: number$1().int().optional()
+}).openapi("UpsertRelationRequest");
+var UpdateRelationRequestSchema = object({
+	relationType: SpaceRelationTypeSchema.optional(),
+	label: string$1().nullable().optional(),
+	context: union([string$1(), record(string$1(), unknown())]).nullable().optional(),
+	metadata: record(string$1(), unknown()).optional(),
+	sortIndex: number$1().int().optional()
+}).openapi("UpdateRelationRequest");
+var UpsertCompositionRequestSchema = object({
+	id: string$1().optional(),
+	name: string$1().min(1),
+	description: string$1().nullable().optional(),
+	status: CompositionStatusSchema.optional(),
+	outputAssetId: string$1().nullable().optional(),
+	outputVariantId: string$1().nullable().optional(),
+	metadata: record(string$1(), unknown()).optional(),
+	sortIndex: number$1().int().optional()
+}).openapi("UpsertCompositionRequest");
+var UpdateCompositionRequestSchema = UpsertCompositionRequestSchema.omit({
+	id: true,
+	name: true
+}).extend({ name: string$1().min(1).optional() }).openapi("UpdateCompositionRequest");
+var UpsertCompositionItemRequestSchema = object({
+	id: string$1().optional(),
+	role: CompositionItemRoleSchema,
+	label: string$1().nullable().optional(),
+	assetId: string$1().nullable().optional(),
+	variantId: string$1().min(1),
+	metadata: record(string$1(), unknown()).optional(),
+	sortIndex: number$1().int().optional()
+}).openapi("UpsertCompositionItemRequest");
+var UpdateCompositionItemRequestSchema = object({
+	role: CompositionItemRoleSchema.optional(),
+	label: string$1().nullable().optional(),
+	assetId: string$1().nullable().optional(),
+	variantId: string$1().optional(),
+	metadata: record(string$1(), unknown()).optional(),
+	sortIndex: number$1().int().optional()
+}).openapi("UpdateCompositionItemRequest");
+var ListCollectionsResponseSchema = object({
+	success: literal(true),
+	collections: array(SpaceCollectionSchema)
+}).openapi("ListCollectionsResponse");
+var CollectionResponseSchema = object({
+	success: literal(true),
+	collection: SpaceCollectionSchema
+}).openapi("CollectionResponse");
+var ListCollectionItemsResponseSchema = object({
+	success: literal(true),
+	items: array(CollectionItemSchema)
+}).openapi("ListCollectionItemsResponse");
+var CollectionItemResponseSchema = object({
+	success: literal(true),
+	item: CollectionItemSchema
+}).openapi("CollectionItemResponse");
+var ListStyleReferenceCollectionsResponseSchema = object({
+	success: literal(true),
+	collections: array(StyleReferenceCollectionSchema)
+}).openapi("ListStyleReferenceCollectionsResponse");
+var ListStylePresetsResponseSchema = object({
+	success: literal(true),
+	presets: array(StylePresetSchema)
+}).openapi("ListStylePresetsResponse");
+var StylePresetResponseSchema = object({
+	success: literal(true),
+	preset: StylePresetSchema
+}).openapi("StylePresetResponse");
+var ListRelationsResponseSchema = object({
+	success: literal(true),
+	relations: array(SpaceRelationSchema)
+}).openapi("ListRelationsResponse");
+var RelationResponseSchema = object({
+	success: literal(true),
+	relation: SpaceRelationSchema
+}).openapi("RelationResponse");
+var ListCompositionsResponseSchema = object({
+	success: literal(true),
+	compositions: array(CompositionSchema)
+}).openapi("ListCompositionsResponse");
+var CompositionResponseSchema = object({
+	success: literal(true),
+	composition: CompositionSchema
+}).openapi("CompositionResponse");
+var ListCompositionItemsResponseSchema = object({
+	success: literal(true),
+	items: array(CompositionItemSchema)
+}).openapi("ListCompositionItemsResponse");
+var CompositionItemResponseSchema = object({
+	success: literal(true),
+	item: CompositionItemSchema
+}).openapi("CompositionItemResponse");
+var UsageSummaryQuerySchema = object({
+	from: string$1().optional(),
+	to: string$1().optional()
+});
+var PlatformUsageTypeSummarySchema = object({
+	usageType: PlatformUsageTypeSchema,
+	unit: PlatformUsageUnitSchema,
+	quantity: number$1().int(),
+	events: number$1().int().nonnegative()
+}).openapi("PlatformUsageTypeSummary");
+var PlatformUsageMediaKindSummarySchema = object({
+	mediaKind: MediaKindSchema.nullable(),
+	storageBytes: number$1().int(),
+	workflowRuns: number$1().int(),
+	deliveryBytes: number$1().int(),
+	events: number$1().int().nonnegative()
+}).openapi("PlatformUsageMediaKindSummary");
+var PlatformUsageSummaryResponseSchema = object({
+	success: literal(true),
+	spaceId: string$1(),
+	period: object({
+		from: string$1().nullable(),
+		to: string$1().nullable()
+	}),
+	totals: object({
+		storageBytes: number$1().int(),
+		workflowRuns: number$1().int(),
+		deliveryBytes: number$1().int()
+	}),
+	byType: array(PlatformUsageTypeSummarySchema),
+	byMediaKind: array(PlatformUsageMediaKindSummarySchema)
+}).openapi("PlatformUsageSummaryResponse");
+var ProviderSpendSummaryQuerySchema = object({
+	from: string$1().optional(),
+	to: string$1().optional(),
+	user_id: string$1().optional(),
+	userId: string$1().optional(),
+	space_id: string$1().optional(),
+	spaceId: string$1().optional(),
+	provider: string$1().optional(),
+	media_kind: MediaKindSchema.optional(),
+	mediaKind: MediaKindSchema.optional()
+});
+var ProviderSpendAggregateSchema = object({
+	amountMicroUsd: number$1().int(),
+	amountUsd: number$1(),
+	quantity: number$1(),
+	entries: number$1().int().nonnegative(),
+	unpricedEntries: number$1().int().nonnegative()
+}).openapi("ProviderSpendAggregate");
+var ProviderSpendSummaryResponseSchema = object({
+	success: literal(true),
+	period: object({
+		from: string$1().nullable(),
+		to: string$1().nullable()
+	}),
+	filters: object({
+		userId: number$1().int().nullable(),
+		spaceId: string$1().nullable(),
+		provider: string$1().nullable(),
+		mediaKind: MediaKindSchema.nullable()
+	}),
+	totals: ProviderSpendAggregateSchema,
+	byProvider: array(ProviderSpendAggregateSchema.extend({ provider: string$1() })),
+	byModel: array(ProviderSpendAggregateSchema.extend({
+		provider: string$1(),
+		providerModel: string$1()
+	})),
+	byMediaKind: array(ProviderSpendAggregateSchema.extend({ mediaKind: MediaKindSchema.nullable() })),
+	byMeterEventName: array(ProviderSpendAggregateSchema.extend({ meterEventName: string$1().nullable() })),
+	bySpace: array(ProviderSpendAggregateSchema.extend({ spaceId: string$1().nullable() })),
+	byAsset: array(ProviderSpendAggregateSchema.extend({
+		spaceId: string$1().nullable(),
+		assetId: string$1().nullable()
+	}))
+}).openapi("ProviderSpendSummaryResponse");
+var BillingEntitlementSchema = _enum([
+	"none",
+	"paid",
+	"internal"
+]).openapi("BillingEntitlement");
+var BillingPlanStatusSchema = _enum([
+	"inactive",
+	"active",
+	"internal"
+]).openapi("BillingPlanStatus");
+var BillingPlanStatusResponseSchema = object({
+	key: literal("paid_generation"),
+	displayName: string$1(),
+	status: BillingPlanStatusSchema,
+	checkoutAvailable: boolean$1(),
+	portalAvailable: boolean$1()
+}).openapi("BillingPlanStatusResponse");
+var BillingMeterStatusSchema = object({
+	name: string$1(),
+	consumed: number$1(),
+	credited: number$1(),
+	remaining: number$1(),
+	percentUsed: number$1(),
+	hasLimit: boolean$1(),
+	status: _enum([
+		"ok",
+		"warning",
+		"critical",
+		"exceeded"
+	])
+}).openapi("BillingMeterStatus");
+var BillingStatusResponseSchema = object({
+	configured: boolean$1(),
+	available: boolean$1(),
+	hasSubscription: boolean$1(),
+	entitlement: BillingEntitlementSchema,
+	plan: BillingPlanStatusResponseSchema,
+	meters: array(BillingMeterStatusSchema),
+	subscription: object({
+		status: string$1(),
+		periodStart: string$1().nullable().optional(),
+		renewsAt: string$1().nullable()
+	}).nullable(),
+	portalUrl: string$1().nullable(),
+	error: string$1().optional()
+}).openapi("BillingStatusResponse");
+var BillingUsageMeterSchema = object({
+	used: number$1(),
+	limit: number$1().nullable(),
+	remaining: number$1().nullable(),
+	costUsd: number$1().optional()
+}).openapi("BillingUsageMeter");
+var BillingUsageResponseSchema = object({
+	period: object({
+		start: string$1(),
+		end: string$1()
+	}),
+	usage: record(string$1(), BillingUsageMeterSchema),
+	estimatedCost: object({
+		amount: number$1(),
+		currency: string$1()
+	}).optional()
+}).openapi("BillingUsageResponse");
+var BillingUrlResponseSchema = object({ url: string$1() }).openapi("BillingUrlResponse");
+var BillingUrlQuerySchema = object({
+	return_url: string$1().optional(),
+	success_url: string$1().optional()
+});
 var ProductionRecordSchema = object({
 	id: string$1(),
 	production_id: string$1(),
@@ -19413,7 +20251,14 @@ var UploadMediaRequestSchema = object({
 	assetName: string$1().optional(),
 	assetType: string$1().optional(),
 	mediaKind: MediaKindSchema.optional(),
-	parentAssetId: string$1().optional(),
+	operation: string$1().optional(),
+	prompt: string$1().optional(),
+	model: string$1().optional(),
+	provider: string$1().optional(),
+	providerMetadata: string$1().optional(),
+	generationProvenance: string$1().optional(),
+	lineage: string$1().optional(),
+	activeVariantBehavior: string$1().optional(),
 	transcript: UploadFileSchema.optional(),
 	wordTimings: UploadFileSchema.optional(),
 	renderMetadata: UploadFileSchema.optional()
@@ -19421,14 +20266,9 @@ var UploadMediaRequestSchema = object({
 var UploadMediaResponseSchema = object({
 	success: literal(true),
 	variant: VariantSchema,
-	asset: AssetSchema.optional()
+	asset: AssetSchema.optional(),
+	lineage: array(LineageSchema).optional()
 }).openapi("UploadMediaResponse");
-var UploadStyleImageRequestSchema = object({ file: UploadFileSchema }).openapi("UploadStyleImageRequest");
-var UploadStyleImageResponseSchema = object({
-	success: literal(true),
-	imageKey: string$1(),
-	warning: string$1().optional()
-}).openapi("UploadStyleImageResponse");
 var VariantMediaParamsSchema = object({
 	spaceId: string$1().openapi({ param: {
 		name: "spaceId",
@@ -19479,6 +20319,24 @@ var apiEndpoints = {
 		jsonSchema: UpdateUserProfileRequestSchema,
 		responseSchema: UserProfileUpdateResponseSchema
 	},
+	"GET /api/user/provider-keys": {
+		method: "GET",
+		path: "/api/user/provider-keys",
+		responseSchema: ListProviderKeysResponseSchema
+	},
+	"PUT /api/user/provider-keys/:provider": {
+		method: "PUT",
+		path: "/api/user/provider-keys/:provider",
+		paramsSchema: ProviderKeyParamsSchema,
+		jsonSchema: UpsertProviderKeyRequestSchema,
+		responseSchema: ProviderKeyResponseSchema
+	},
+	"DELETE /api/user/provider-keys/:provider": {
+		method: "DELETE",
+		path: "/api/user/provider-keys/:provider",
+		paramsSchema: ProviderKeyParamsSchema,
+		responseSchema: ProviderKeyResponseSchema
+	},
 	"POST /api/spaces": {
 		method: "POST",
 		path: "/api/spaces",
@@ -19502,73 +20360,284 @@ var apiEndpoints = {
 		paramsSchema: SpaceIdParamsSchema,
 		responseSchema: ListSpaceAssetsResponseSchema
 	},
-	"GET /api/spaces/:id/productions": {
+	"GET /api/spaces/:id/collections": {
 		method: "GET",
-		path: "/api/spaces/:id/productions",
+		path: "/api/spaces/:id/collections",
 		paramsSchema: SpaceIdParamsSchema,
-		responseSchema: ListProductionsResponseSchema
+		responseSchema: ListCollectionsResponseSchema
 	},
-	"POST /api/spaces/:id/productions": {
+	"POST /api/spaces/:id/collections": {
 		method: "POST",
-		path: "/api/spaces/:id/productions",
+		path: "/api/spaces/:id/collections",
 		paramsSchema: SpaceIdParamsSchema,
-		jsonSchema: UpsertProductionRequestSchema,
-		responseSchema: ProductionResponseSchema
+		jsonSchema: UpsertCollectionRequestSchema,
+		responseSchema: CollectionResponseSchema
 	},
-	"GET /api/spaces/:id/productions/:productionId": {
-		method: "GET",
-		path: "/api/spaces/:id/productions/:productionId",
-		paramsSchema: ProductionIdParamsSchema,
-		responseSchema: ProductionDetailResponseSchema
+	"PATCH /api/spaces/:id/collections/:collectionId": {
+		method: "PATCH",
+		path: "/api/spaces/:id/collections/:collectionId",
+		paramsSchema: CollectionIdParamsSchema,
+		jsonSchema: UpdateCollectionRequestSchema,
+		responseSchema: CollectionResponseSchema
 	},
-	"DELETE /api/spaces/:id/productions/:productionId": {
+	"DELETE /api/spaces/:id/collections/:collectionId": {
 		method: "DELETE",
-		path: "/api/spaces/:id/productions/:productionId",
-		paramsSchema: ProductionIdParamsSchema,
+		path: "/api/spaces/:id/collections/:collectionId",
+		paramsSchema: CollectionIdParamsSchema,
 		responseSchema: SuccessResponseSchema
 	},
-	"POST /api/spaces/:id/productions/:productionId/shots": {
-		method: "POST",
-		path: "/api/spaces/:id/productions/:productionId/shots",
-		paramsSchema: ProductionIdParamsSchema,
-		jsonSchema: UpsertProductionShotRequestSchema,
-		responseSchema: ProductionShotResponseSchema
-	},
-	"DELETE /api/spaces/:id/productions/:productionId/shots/:childId": {
-		method: "DELETE",
-		path: "/api/spaces/:id/productions/:productionId/shots/:childId",
-		paramsSchema: ProductionChildParamsSchema,
-		responseSchema: SuccessResponseSchema
+	"GET /api/spaces/:id/collections/:collectionId/items": {
+		method: "GET",
+		path: "/api/spaces/:id/collections/:collectionId/items",
+		paramsSchema: CollectionIdParamsSchema,
+		responseSchema: ListCollectionItemsResponseSchema
 	},
-	"POST /api/spaces/:id/productions/:productionId/cues": {
+	"POST /api/spaces/:id/collections/:collectionId/items": {
 		method: "POST",
-		path: "/api/spaces/:id/productions/:productionId/cues",
-		paramsSchema: ProductionIdParamsSchema,
-		jsonSchema: UpsertProductionCueRequestSchema,
-		responseSchema: ProductionCueResponseSchema
+		path: "/api/spaces/:id/collections/:collectionId/items",
+		paramsSchema: CollectionIdParamsSchema,
+		jsonSchema: UpsertCollectionItemRequestSchema,
+		responseSchema: CollectionItemResponseSchema
 	},
-	"DELETE /api/spaces/:id/productions/:productionId/cues/:childId": {
-		method: "DELETE",
-		path: "/api/spaces/:id/productions/:productionId/cues/:childId",
-		paramsSchema: ProductionChildParamsSchema,
-		responseSchema: SuccessResponseSchema
+	"PATCH /api/spaces/:id/collections/:collectionId/items/:itemId": {
+		method: "PATCH",
+		path: "/api/spaces/:id/collections/:collectionId/items/:itemId",
+		paramsSchema: CollectionItemParamsSchema,
+		jsonSchema: UpdateCollectionItemRequestSchema,
+		responseSchema: CollectionItemResponseSchema
 	},
-	"POST /api/spaces/:id/productions/:productionId/placements": {
+	"POST /api/spaces/:id/collections/:collectionId/items/reorder": {
 		method: "POST",
-		path: "/api/spaces/:id/productions/:productionId/placements",
-		paramsSchema: ProductionIdParamsSchema,
-		jsonSchema: UpsertProductionPlacementRequestSchema,
-		responseSchema: ProductionPlacementResponseSchema
+		path: "/api/spaces/:id/collections/:collectionId/items/reorder",
+		paramsSchema: CollectionIdParamsSchema,
+		jsonSchema: ReorderItemsRequestSchema,
+		responseSchema: ListCollectionItemsResponseSchema
 	},
-	"DELETE /api/spaces/:id/productions/:productionId/placements/:childId": {
+	"DELETE /api/spaces/:id/collections/:collectionId/items/:itemId": {
 		method: "DELETE",
-		path: "/api/spaces/:id/productions/:productionId/placements/:childId",
-		paramsSchema: ProductionChildParamsSchema,
+		path: "/api/spaces/:id/collections/:collectionId/items/:itemId",
+		paramsSchema: CollectionItemParamsSchema,
 		responseSchema: SuccessResponseSchema
 	},
-	"GET /api/spaces/:id/productions/:productionId/records": {
+	"GET /api/spaces/:id/style-reference-collections": {
 		method: "GET",
-		path: "/api/spaces/:id/productions/:productionId/records",
+		path: "/api/spaces/:id/style-reference-collections",
+		paramsSchema: SpaceIdParamsSchema,
+		responseSchema: ListStyleReferenceCollectionsResponseSchema
+	},
+	"GET /api/spaces/:id/style-presets": {
+		method: "GET",
+		path: "/api/spaces/:id/style-presets",
+		paramsSchema: SpaceIdParamsSchema,
+		responseSchema: ListStylePresetsResponseSchema
+	},
+	"POST /api/spaces/:id/style-presets": {
+		method: "POST",
+		path: "/api/spaces/:id/style-presets",
+		paramsSchema: SpaceIdParamsSchema,
+		jsonSchema: UpsertStylePresetRequestSchema,
+		responseSchema: StylePresetResponseSchema
+	},
+	"PATCH /api/spaces/:id/style-presets/:presetId": {
+		method: "PATCH",
+		path: "/api/spaces/:id/style-presets/:presetId",
+		paramsSchema: StylePresetParamsSchema,
+		jsonSchema: UpdateStylePresetRequestSchema,
+		responseSchema: StylePresetResponseSchema
+	},
+	"DELETE /api/spaces/:id/style-presets/:presetId": {
+		method: "DELETE",
+		path: "/api/spaces/:id/style-presets/:presetId",
+		paramsSchema: StylePresetParamsSchema,
+		responseSchema: SuccessResponseSchema
+	},
+	"GET /api/spaces/:id/relations": {
+		method: "GET",
+		path: "/api/spaces/:id/relations",
+		paramsSchema: SpaceIdParamsSchema,
+		responseSchema: ListRelationsResponseSchema
+	},
+	"POST /api/spaces/:id/relations": {
+		method: "POST",
+		path: "/api/spaces/:id/relations",
+		paramsSchema: SpaceIdParamsSchema,
+		jsonSchema: UpsertRelationRequestSchema,
+		responseSchema: RelationResponseSchema
+	},
+	"PATCH /api/spaces/:id/relations/:relationId": {
+		method: "PATCH",
+		path: "/api/spaces/:id/relations/:relationId",
+		paramsSchema: RelationParamsSchema,
+		jsonSchema: UpdateRelationRequestSchema,
+		responseSchema: RelationResponseSchema
+	},
+	"DELETE /api/spaces/:id/relations/:relationId": {
+		method: "DELETE",
+		path: "/api/spaces/:id/relations/:relationId",
+		paramsSchema: RelationParamsSchema,
+		responseSchema: SuccessResponseSchema
+	},
+	"GET /api/spaces/:id/compositions": {
+		method: "GET",
+		path: "/api/spaces/:id/compositions",
+		paramsSchema: SpaceIdParamsSchema,
+		responseSchema: ListCompositionsResponseSchema
+	},
+	"POST /api/spaces/:id/compositions": {
+		method: "POST",
+		path: "/api/spaces/:id/compositions",
+		paramsSchema: SpaceIdParamsSchema,
+		jsonSchema: UpsertCompositionRequestSchema,
+		responseSchema: CompositionResponseSchema
+	},
+	"PATCH /api/spaces/:id/compositions/:compositionId": {
+		method: "PATCH",
+		path: "/api/spaces/:id/compositions/:compositionId",
+		paramsSchema: CompositionIdParamsSchema,
+		jsonSchema: UpdateCompositionRequestSchema,
+		responseSchema: CompositionResponseSchema
+	},
+	"DELETE /api/spaces/:id/compositions/:compositionId": {
+		method: "DELETE",
+		path: "/api/spaces/:id/compositions/:compositionId",
+		paramsSchema: CompositionIdParamsSchema,
+		responseSchema: SuccessResponseSchema
+	},
+	"GET /api/spaces/:id/compositions/:compositionId/items": {
+		method: "GET",
+		path: "/api/spaces/:id/compositions/:compositionId/items",
+		paramsSchema: CompositionIdParamsSchema,
+		responseSchema: ListCompositionItemsResponseSchema
+	},
+	"POST /api/spaces/:id/compositions/:compositionId/items": {
+		method: "POST",
+		path: "/api/spaces/:id/compositions/:compositionId/items",
+		paramsSchema: CompositionIdParamsSchema,
+		jsonSchema: UpsertCompositionItemRequestSchema,
+		responseSchema: CompositionItemResponseSchema
+	},
+	"PATCH /api/spaces/:id/compositions/:compositionId/items/:itemId": {
+		method: "PATCH",
+		path: "/api/spaces/:id/compositions/:compositionId/items/:itemId",
+		paramsSchema: CompositionItemParamsSchema,
+		jsonSchema: UpdateCompositionItemRequestSchema,
+		responseSchema: CompositionItemResponseSchema
+	},
+	"POST /api/spaces/:id/compositions/:compositionId/items/reorder": {
+		method: "POST",
+		path: "/api/spaces/:id/compositions/:compositionId/items/reorder",
+		paramsSchema: CompositionIdParamsSchema,
+		jsonSchema: ReorderItemsRequestSchema,
+		responseSchema: ListCompositionItemsResponseSchema
+	},
+	"DELETE /api/spaces/:id/compositions/:compositionId/items/:itemId": {
+		method: "DELETE",
+		path: "/api/spaces/:id/compositions/:compositionId/items/:itemId",
+		paramsSchema: CompositionItemParamsSchema,
+		responseSchema: SuccessResponseSchema
+	},
+	"GET /api/spaces/:id/usage/summary": {
+		method: "GET",
+		path: "/api/spaces/:id/usage/summary",
+		paramsSchema: SpaceIdParamsSchema,
+		querySchema: UsageSummaryQuerySchema,
+		responseSchema: PlatformUsageSummaryResponseSchema
+	},
+	"GET /api/billing/status": {
+		method: "GET",
+		path: "/api/billing/status",
+		responseSchema: BillingStatusResponseSchema
+	},
+	"GET /api/billing/usage": {
+		method: "GET",
+		path: "/api/billing/usage",
+		responseSchema: BillingUsageResponseSchema
+	},
+	"GET /api/billing/checkout": {
+		method: "GET",
+		path: "/api/billing/checkout",
+		querySchema: BillingUrlQuerySchema,
+		responseSchema: BillingUrlResponseSchema
+	},
+	"GET /api/billing/portal": {
+		method: "GET",
+		path: "/api/billing/portal",
+		querySchema: BillingUrlQuerySchema,
+		responseSchema: BillingUrlResponseSchema
+	},
+	"GET /api/billing/spend/summary": {
+		method: "GET",
+		path: "/api/billing/spend/summary",
+		querySchema: ProviderSpendSummaryQuerySchema,
+		responseSchema: ProviderSpendSummaryResponseSchema
+	},
+	"GET /api/spaces/:id/productions": {
+		method: "GET",
+		path: "/api/spaces/:id/productions",
+		paramsSchema: SpaceIdParamsSchema,
+		responseSchema: ListProductionsResponseSchema
+	},
+	"POST /api/spaces/:id/productions": {
+		method: "POST",
+		path: "/api/spaces/:id/productions",
+		paramsSchema: SpaceIdParamsSchema,
+		jsonSchema: UpsertProductionRequestSchema,
+		responseSchema: ProductionResponseSchema
+	},
+	"GET /api/spaces/:id/productions/:productionId": {
+		method: "GET",
+		path: "/api/spaces/:id/productions/:productionId",
+		paramsSchema: ProductionIdParamsSchema,
+		responseSchema: ProductionDetailResponseSchema
+	},
+	"DELETE /api/spaces/:id/productions/:productionId": {
+		method: "DELETE",
+		path: "/api/spaces/:id/productions/:productionId",
+		paramsSchema: ProductionIdParamsSchema,
+		responseSchema: SuccessResponseSchema
+	},
+	"POST /api/spaces/:id/productions/:productionId/shots": {
+		method: "POST",
+		path: "/api/spaces/:id/productions/:productionId/shots",
+		paramsSchema: ProductionIdParamsSchema,
+		jsonSchema: UpsertProductionShotRequestSchema,
+		responseSchema: ProductionShotResponseSchema
+	},
+	"DELETE /api/spaces/:id/productions/:productionId/shots/:childId": {
+		method: "DELETE",
+		path: "/api/spaces/:id/productions/:productionId/shots/:childId",
+		paramsSchema: ProductionChildParamsSchema,
+		responseSchema: SuccessResponseSchema
+	},
+	"POST /api/spaces/:id/productions/:productionId/cues": {
+		method: "POST",
+		path: "/api/spaces/:id/productions/:productionId/cues",
+		paramsSchema: ProductionIdParamsSchema,
+		jsonSchema: UpsertProductionCueRequestSchema,
+		responseSchema: ProductionCueResponseSchema
+	},
+	"DELETE /api/spaces/:id/productions/:productionId/cues/:childId": {
+		method: "DELETE",
+		path: "/api/spaces/:id/productions/:productionId/cues/:childId",
+		paramsSchema: ProductionChildParamsSchema,
+		responseSchema: SuccessResponseSchema
+	},
+	"POST /api/spaces/:id/productions/:productionId/placements": {
+		method: "POST",
+		path: "/api/spaces/:id/productions/:productionId/placements",
+		paramsSchema: ProductionIdParamsSchema,
+		jsonSchema: UpsertProductionPlacementRequestSchema,
+		responseSchema: ProductionPlacementResponseSchema
+	},
+	"DELETE /api/spaces/:id/productions/:productionId/placements/:childId": {
+		method: "DELETE",
+		path: "/api/spaces/:id/productions/:productionId/placements/:childId",
+		paramsSchema: ProductionChildParamsSchema,
+		responseSchema: SuccessResponseSchema
+	},
+	"GET /api/spaces/:id/productions/:productionId/records": {
+		method: "GET",
+		path: "/api/spaces/:id/productions/:productionId/records",
 		paramsSchema: ProductionIdParamsSchema,
 		responseSchema: ListProductionRecordsResponseSchema
 	},
@@ -19598,13 +20667,6 @@ var apiEndpoints = {
 		formSchema: UploadMediaRequestSchema,
 		responseSchema: UploadMediaResponseSchema
 	},
-	"POST /api/spaces/:id/style-images": {
-		method: "POST",
-		path: "/api/spaces/:id/style-images",
-		paramsSchema: SpaceIdParamsSchema,
-		formSchema: UploadStyleImageRequestSchema,
-		responseSchema: UploadStyleImageResponseSchema
-	},
 	"GET /api/spaces/:spaceId/variants/:variantId/media": {
 		method: "GET",
 		path: "/api/spaces/:spaceId/variants/:variantId/media",
@@ -19648,6 +20710,17 @@ function resolveUrl(path, baseUrl) {
 	if (baseUrl) return new URL(path, baseUrl).toString();
 	return path;
 }
+function appendQuery(path, query) {
+	if (!query) return path;
+	const params = new URLSearchParams();
+	for (const [key, value] of Object.entries(query)) {
+		if (value === void 0 || value === null) continue;
+		params.set(key, String(value));
+	}
+	const search = params.toString();
+	if (!search) return path;
+	return `${path}${path.includes("?") ? "&" : "?"}${search}`;
+}
 function buildFormData(form) {
 	const formData = new FormData();
 	for (const [key, value] of Object.entries(form)) {
@@ -19679,8 +20752,9 @@ async function apiFetch(key, ...args) {
 	const fetchImpl = options.fetch ?? fetch;
 	const params = "paramsSchema" in endpoint ? endpoint.paramsSchema.parse(options.params) : void 0;
 	const json = "jsonSchema" in endpoint ? endpoint.jsonSchema.parse(options.json) : void 0;
+	const query = "querySchema" in endpoint ? endpoint.querySchema.parse(options.query ?? {}) : void 0;
 	const form = "formSchema" in endpoint ? endpoint.formSchema.parse(options.form) : void 0;
-	const path = buildPath(endpoint.path, params);
+	const path = appendQuery(buildPath(endpoint.path, params), query);
 	const headers = new Headers(options.headers);
 	const init = {
 		...options,
@@ -19691,6 +20765,7 @@ async function apiFetch(key, ...args) {
 	delete init.baseUrl;
 	delete init.fetch;
 	delete init.params;
+	delete init.query;
 	delete init.json;
 	delete init.form;
 	if (json !== void 0) {
@@ -19710,7 +20785,7 @@ async function apiFetch(key, ...args) {
 }
 //#endregion
 //#region src/cli/commands/productions.ts
-var defaultDeps$7 = {
+var defaultDeps$10 = {
 	loadConfig: loadStoredConfig,
 	loadProjectConfig,
 	resolveBaseUrl,
@@ -19724,12 +20799,12 @@ async function handleProductions(parsed) {
 		await executeProductions(parsed);
 	} catch (error) {
 		console.error("Error:", error instanceof Error ? error.message : error);
-		printUsage$8();
+		printUsage$10();
 		process$1.exitCode = 1;
 	}
 }
-async function executeProductions(parsed, deps = defaultDeps$7) {
-	const ctx = await buildContext$4(parsed, deps);
+async function executeProductions(parsed, deps = defaultDeps$10) {
+	const ctx = await buildContext$7(parsed, deps);
 	const subcommand = parsed.positionals[0] || "list";
 	if (subcommand === "list") {
 		const records = await listProductionRecords(ctx, deps, readProductionId(parsed, 1));
@@ -19802,7 +20877,7 @@ async function placeProductionRecordForCli(input) {
 		}
 	})).record;
 }
-async function buildContext$4(parsed, deps) {
+async function buildContext$7(parsed, deps) {
 	const projectConfig = await deps.loadProjectConfig();
 	const env = resolveCommandEnvironment(parsed, projectConfig);
 	const spaceId = resolveCommandSpace(parsed, projectConfig);
@@ -19861,10 +20936,10 @@ function readProductionId(parsed, positionalIndex) {
 	return productionId;
 }
 function parsePlaceRequest(parsed) {
-	const productionId = readRequiredOption(parsed, "production-id", "productionId");
-	const variantId = readRequiredOption(parsed, "variant", "variantId");
-	const sceneLabel = readRequiredOption(parsed, "scene-label", "sceneLabel");
-	const timelineStartMs = parseNonNegativeInteger$1(readRequiredOption(parsed, "timeline-start-ms", "timelineStartMs"), "--timeline-start-ms");
+	const productionId = readRequiredOption$1(parsed, "production-id", "productionId");
+	const variantId = readRequiredOption$1(parsed, "variant", "variantId");
+	const sceneLabel = readRequiredOption$1(parsed, "scene-label", "sceneLabel");
+	const timelineStartMs = parseNonNegativeInteger$1(readRequiredOption$1(parsed, "timeline-start-ms", "timelineStartMs"), "--timeline-start-ms");
 	const durationValue = readOptionalOption$1(parsed, "duration-ms", "durationMs");
 	return {
 		id: readOptionalOption$1(parsed, "id", "id"),
@@ -19880,7 +20955,7 @@ function parsePlaceRequest(parsed) {
 		metadata: parseMetadataJson(readOptionalOption$1(parsed, "metadata-json", "metadataJson"))
 	};
 }
-function readRequiredOption(parsed, kebabName, camelName) {
+function readRequiredOption$1(parsed, kebabName, camelName) {
 	const value = readOptionalOption$1(parsed, kebabName, camelName);
 	if (value === void 0) throw new Error(`--${kebabName} is required`);
 	return value;
@@ -20025,7 +21100,7 @@ function parseJsonObject$1(value) {
 function shellQuote$1(value) {
 	return `'${value.replace(/'/g, "'\\''")}'`;
 }
-function printUsage$8() {
+function printUsage$10() {
 	console.log(`
 Usage:
   makefx productions list --production-id <id>
@@ -20230,6 +21305,7 @@ var WebSocketClient = class WebSocketClient {
 	chatHandlers = /* @__PURE__ */ new Map();
 	generateHandlers = /* @__PURE__ */ new Map();
 	batchHandlers = /* @__PURE__ */ new Map();
+	estimateHandlers = /* @__PURE__ */ new Map();
 	batchVariantToRequestId = /* @__PURE__ */ new Map();
 	variantCompletionHandlers = /* @__PURE__ */ new Map();
 	describeHandlers = /* @__PURE__ */ new Map();
@@ -20430,6 +21506,16 @@ var WebSocketClient = class WebSocketClient {
 				}
 				break;
 			}
+			case "generation:estimate": {
+				const estimateMsg = message;
+				const handler = this.estimateHandlers.get(estimateMsg.requestId);
+				if (handler) {
+					this.estimateHandlers.delete(estimateMsg.requestId);
+					clearTimeout(handler.timeout);
+					handler.resolve(estimateMsg);
+				}
+				break;
+			}
 			case "variant:updated": {
 				const variant = message.variant;
 				const batchRequestId = this.batchVariantToRequestId.get(variant.id);
@@ -20519,7 +21605,8 @@ var WebSocketClient = class WebSocketClient {
 				const error = /* @__PURE__ */ new Error(`${errorMsg.code}: ${errorMsg.message}`);
 				const mutationConsumed = this.failMutationWaiters(error);
 				const pipelineConsumed = this.failPipelineHandlers(error);
-				if (!(mutationConsumed || pipelineConsumed)) {
+				const estimateConsumed = this.failEstimateHandlers(error);
+				if (!(mutationConsumed || pipelineConsumed || estimateConsumed)) {
 					console.error(`[WebSocketClient] Server error: ${errorMsg.code} - ${errorMsg.message}`);
 					this.onError?.(new Error(errorMsg.message));
 				}
@@ -20616,6 +21703,15 @@ var WebSocketClient = class WebSocketClient {
 		this.tileSetToRequestId.clear();
 		return true;
 	}
+	failEstimateHandlers(error) {
+		if (this.estimateHandlers.size === 0) return false;
+		for (const [requestId, handler] of this.estimateHandlers) {
+			clearTimeout(handler.timeout);
+			this.estimateHandlers.delete(requestId);
+			handler.reject(error);
+		}
+		return true;
+	}
 	handleRotationPipelineMessage(message) {
 		if (message.type === "rotation:started") {
 			const handler = this.rotationHandlers.get(message.requestId);
@@ -20874,6 +21970,8 @@ var WebSocketClient = class WebSocketClient {
 					subjectDescription: params.subjectDescription,
 					aspectRatio: params.aspectRatio,
 					disableStyle: params.disableStyle,
+					stylePresetId: params.stylePresetId,
+					styleVariantIds: params.styleVariantIds,
 					generationMode: params.generationMode
 				});
 			} catch (err) {
@@ -20921,6 +22019,8 @@ var WebSocketClient = class WebSocketClient {
 					seedVariantId: params.seedVariantId,
 					aspectRatio: params.aspectRatio,
 					disableStyle: params.disableStyle,
+					stylePresetId: params.stylePresetId,
+					styleVariantIds: params.styleVariantIds,
 					generationMode: params.generationMode
 				});
 			} catch (err) {
@@ -20975,6 +22075,46 @@ var WebSocketClient = class WebSocketClient {
 			}, 12e4);
 		});
 	}
+	async sendGenerationEstimateRequest(params) {
+		const requestId = crypto.randomUUID();
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				if (this.estimateHandlers.has(requestId)) {
+					this.estimateHandlers.delete(requestId);
+					reject(/* @__PURE__ */ new Error("Generation estimate request timed out"));
+				}
+			}, 3e4);
+			this.estimateHandlers.set(requestId, {
+				resolve,
+				reject,
+				timeout
+			});
+			const message = {
+				type: "generation:estimate",
+				requestId,
+				operation: params.operation,
+				assetId: params.assetId,
+				assetType: params.assetType,
+				mediaKind: params.mediaKind,
+				prompt: params.prompt,
+				count: params.count,
+				model: params.model,
+				imageSize: params.imageSize,
+				musicProvider: params.musicProvider,
+				generateAudio: params.generateAudio,
+				videoResolution: params.videoResolution,
+				videoDurationSeconds: params.videoDurationSeconds,
+				videoTier: params.videoTier
+			};
+			try {
+				this.send(message);
+			} catch (err) {
+				this.estimateHandlers.delete(requestId);
+				clearTimeout(timeout);
+				reject(err);
+			}
+		});
+	}
 	/**
 	* Send a generate request and wait for result
 	*/
@@ -21011,8 +22151,9 @@ var WebSocketClient = class WebSocketClient {
 				model: params.model,
 				aspectRatio: params.aspectRatio,
 				imageSize: params.imageSize,
-				parentAssetId: params.parentAssetId,
 				disableStyle: params.disableStyle,
+				stylePresetId: params.stylePresetId,
+				styleVariantIds: params.styleVariantIds,
 				mediaKind: params.mediaKind,
 				voiceId: params.voiceId,
 				dialogueVoiceIds: params.dialogueVoiceIds,
@@ -21096,6 +22237,8 @@ var WebSocketClient = class WebSocketClient {
 				aspectRatio: params.aspectRatio,
 				imageSize: params.imageSize,
 				disableStyle: params.disableStyle,
+				stylePresetId: params.stylePresetId,
+				styleVariantIds: params.styleVariantIds,
 				mediaKind: params.mediaKind,
 				voiceId: params.voiceId,
 				dialogueVoiceIds: params.dialogueVoiceIds,
@@ -21148,8 +22291,9 @@ var WebSocketClient = class WebSocketClient {
 				model: params.model,
 				aspectRatio: params.aspectRatio,
 				imageSize: params.imageSize,
-				parentAssetId: params.parentAssetId,
 				disableStyle: params.disableStyle,
+				stylePresetId: params.stylePresetId,
+				styleVariantIds: params.styleVariantIds,
 				mediaKind: params.mediaKind,
 				voiceId: params.voiceId,
 				dialogueVoiceIds: params.dialogueVoiceIds,
@@ -21575,7 +22719,7 @@ function cliGenerationSupportsRefs(namespace) {
 //#endregion
 //#region src/cli/commands/forge.ts
 var CLI_GENERATION_MEDIA_KIND = getCliGenerationMediaKind("top-level");
-var defaultDeps$6 = {
+var defaultDeps$9 = {
 	loadConfig: loadStoredConfig,
 	loadProjectConfig,
 	resolveBaseUrl,
@@ -21585,6 +22729,7 @@ var defaultDeps$6 = {
 	downloadFile,
 	saveRunManifest,
 	placeProductionRecord: placeProductionRecordForCli,
+	fetch,
 	createRunId,
 	getWorkingDir: () => process$1.cwd(),
 	fileExists: async (filePath) => {
@@ -21596,6 +22741,43 @@ var defaultDeps$6 = {
 		}
 	}
 };
+var ESTIMATE_METER_LABELS = {
+	gemini_images: "Gemini image",
+	gemini_videos: "Veo video unit",
+	gemini_audio: "Lyria generation",
+	elevenlabs_audio: "ElevenLabs unit"
+};
+function formatEstimatedUsd(microUsd) {
+	if (!Number.isFinite(microUsd) || microUsd <= 0) return "$0.00";
+	if (microUsd < 1e4) return "<$0.01";
+	return `$${(microUsd / 1e6).toFixed(2)}`;
+}
+function formatEstimateQuantity(quantity, singular) {
+	const normalized = Number.isFinite(quantity) ? quantity : 0;
+	const suffix = normalized === 1 ? singular : `${singular}s`;
+	return `${normalized.toLocaleString()} ${suffix}`;
+}
+async function printPreflightEstimate(client, params) {
+	let result;
+	try {
+		result = await client.sendGenerationEstimateRequest(params);
+	} catch (error) {
+		console.warn(`Preflight estimate unavailable: ${error instanceof Error ? error.message : String(error)}`);
+		return;
+	}
+	if (!result.success || !result.estimate) {
+		console.warn(`Preflight estimate unavailable: ${result.error || "unknown error"}`);
+		return;
+	}
+	const estimate = result.estimate;
+	const meterLabel = ESTIMATE_METER_LABELS[estimate.meterEventName] ?? estimate.meterEventName;
+	const quotaLine = estimate.quota?.limit === null || estimate.quota?.limit === void 0 ? void 0 : `${estimate.quota.used.toLocaleString()} used / ${estimate.quota.limit.toLocaleString()} limit`;
+	console.log("Preflight estimate:");
+	console.log(`  Usage: ${formatEstimateQuantity(estimate.quotaQuantity, meterLabel)}, ${formatEstimateQuantity(estimate.platformWorkflowRuns, "workflow")}`);
+	console.log(`  Estimated provider cost: ${formatEstimatedUsd(estimate.providerCostMicroUsd)}${estimate.billingMode === "byok" ? " (BYOK)" : ""}`);
+	if (quotaLine) console.log(`  Quota: ${quotaLine}`);
+	if (!estimate.allowed) throw new Error(estimate.denyMessage || "Preflight check denied this generation request");
+}
 async function handleGenerate(parsed) {
 	await handleForgeCommand("generate", parsed);
 }
@@ -21610,18 +22792,18 @@ async function handleBatch(parsed) {
 }
 async function handleForgeCommand(command, parsed) {
 	try {
-		await executeForgeCommand(command, parsed, defaultDeps$6);
+		await executeForgeCommand(command, parsed, defaultDeps$9);
 	} catch (error) {
 		console.error("Error:", error instanceof Error ? error.message : error);
-		printUsage$7(command);
+		printUsage$9(command);
 		process$1.exitCode = 1;
 	}
 }
-async function executeForgeCommand(command, parsed, deps = defaultDeps$6, options = {}) {
+async function executeForgeCommand(command, parsed, deps = defaultDeps$9, options = {}) {
 	const mediaKind = options.mediaKind || CLI_GENERATION_MEDIA_KIND;
 	if (parsed.options.follow) {
 		if (command === "batch") throw new Error("--follow is only supported for single-output generation commands");
-		const ctx = await buildContext$3(parsed, deps);
+		const ctx = await buildContext$6(parsed, deps);
 		const client = await deps.createClient(ctx.env, ctx.spaceId);
 		try {
 			await client.connect();
@@ -21635,7 +22817,7 @@ async function executeForgeCommand(command, parsed, deps = defaultDeps$6, option
 	validateVideoAudioOptions(parsed, mediaKind);
 	parseVideoGenerationOptions(parsed, mediaKind);
 	if (command !== "batch") validateProductionMetadataOptions(parsed);
-	const ctx = await buildContext$3(parsed, deps);
+	const ctx = await buildContext$6(parsed, deps);
 	const client = await deps.createClient(ctx.env, ctx.spaceId);
 	try {
 		await client.connect();
@@ -21649,7 +22831,7 @@ async function executeForgeCommand(command, parsed, deps = defaultDeps$6, option
 		client.disconnect();
 	}
 }
-async function executeAudioCommand(command, parsed, deps = defaultDeps$6, options = {}) {
+async function executeAudioCommand(command, parsed, deps = defaultDeps$9, options = {}) {
 	const audioProfile = getCliGenerationProfile("audio");
 	if (!audioProfile.commands.includes(command)) throw new Error(`Audio generation does not support ${command}`);
 	const modeEntry = options.mode ? getMediaOperationEntry(options.mode) : void 0;
@@ -21662,7 +22844,7 @@ async function executeAudioCommand(command, parsed, deps = defaultDeps$6, option
 		audioMode: options.mode
 	});
 }
-async function executeVideoCommand(command, parsed, deps = defaultDeps$6) {
+async function executeVideoCommand(command, parsed, deps = defaultDeps$9) {
 	const videoProfile = getCliGenerationProfile("video");
 	if (!videoProfile.commands.includes(command)) throw new Error(`Video generation does not support ${command}`);
 	return executeForgeCommand(command, parsed, deps, {
@@ -21708,6 +22890,20 @@ async function executeGenerate(parsed, ctx, client, deps, mediaKind, followOptio
 	const imageOptions = parseImageGenerationOptions(parsed, mediaKind);
 	const videoAudioOptions = parseVideoAudioOptions(parsed, mediaKind);
 	const videoOptions = parseVideoGenerationOptions(parsed, mediaKind);
+	const styleSelection = await resolveStyleSelection(parsed, ctx, deps);
+	await printPreflightEstimate(client, {
+		operation: "generate",
+		assetType,
+		mediaKind,
+		prompt,
+		count: 1,
+		model: imageOptions.model,
+		imageSize: imageOptions.imageSize,
+		...musicProvider ? { musicProvider } : {},
+		...videoAudioOptions,
+		...videoOptions
+	});
+	printStyleSelection(styleSelection);
 	console.log(`Generating "${name}" in space ${ctx.spaceId}...`);
 	const audioVoiceOptions = mediaKind === "audio" ? parseAudioVoiceOptions(parsed) : {};
 	const result = await client.sendGenerateRequest({
@@ -21716,8 +22912,8 @@ async function executeGenerate(parsed, ctx, client, deps, mediaKind, followOptio
 		prompt,
 		...imageOptions,
 		aspectRatio: imageOptions.aspectRatio ?? videoOptions.aspectRatio,
-		parentAssetId: parsed.options.parent,
 		disableStyle: parsed.options["no-style"] === "true",
+		...styleSelection.stylePresetId ? { stylePresetId: styleSelection.stylePresetId } : {},
 		mediaKind,
 		...audioVoiceOptions,
 		...musicProvider ? { musicProvider } : {},
@@ -21785,6 +22981,20 @@ async function executeRefine(parsed, ctx, client, deps, mediaKind) {
 	const imageOptions = parseImageGenerationOptions(parsed, mediaKind);
 	const videoAudioOptions = parseVideoAudioOptions(parsed, mediaKind);
 	const videoOptions = parseVideoGenerationOptions(parsed, mediaKind);
+	const styleSelection = await resolveStyleSelection(parsed, ctx, deps);
+	await printPreflightEstimate(client, {
+		operation: "refine",
+		assetId: sourceVariant.asset_id,
+		assetType: sourceAsset?.type || void 0,
+		mediaKind,
+		prompt,
+		count: 1,
+		model: imageOptions.model,
+		imageSize: imageOptions.imageSize,
+		...videoAudioOptions,
+		...videoOptions
+	});
+	printStyleSelection(styleSelection);
 	console.log(`Refining variant ${sourceVariantId}...`);
 	const result = await client.sendRefineRequest({
 		assetId: sourceVariant.asset_id,
@@ -21793,6 +23003,7 @@ async function executeRefine(parsed, ctx, client, deps, mediaKind) {
 		...imageOptions,
 		aspectRatio: imageOptions.aspectRatio ?? videoOptions.aspectRatio,
 		disableStyle: parsed.options["no-style"] === "true",
+		...styleSelection.stylePresetId ? { stylePresetId: styleSelection.stylePresetId } : {},
 		mediaKind,
 		...videoAudioOptions,
 		...videoOptions,
@@ -21843,6 +23054,19 @@ async function executeDerive(parsed, ctx, client, deps, mediaKind, followOptions
 	});
 	const videoAudioOptions = parseVideoAudioOptions(parsed, mediaKind);
 	const videoOptions = parseVideoGenerationOptions(parsed, mediaKind);
+	const styleSelection = await resolveStyleSelection(parsed, ctx, deps);
+	await printPreflightEstimate(client, {
+		operation: "derive",
+		assetType,
+		mediaKind,
+		prompt,
+		count: 1,
+		model: imageOptions.model,
+		imageSize: imageOptions.imageSize,
+		...videoAudioOptions,
+		...videoOptions
+	});
+	printStyleSelection(styleSelection);
 	console.log(`Deriving "${name}" from ${referenceVariantIds.length} reference(s)...`);
 	const result = await client.sendGenerateRequest({
 		name,
@@ -21851,8 +23075,8 @@ async function executeDerive(parsed, ctx, client, deps, mediaKind, followOptions
 		referenceVariantIds,
 		...imageOptions,
 		aspectRatio: imageOptions.aspectRatio ?? videoOptions.aspectRatio,
-		parentAssetId: parsed.options.parent,
 		disableStyle: parsed.options["no-style"] === "true",
+		...styleSelection.stylePresetId ? { stylePresetId: styleSelection.stylePresetId } : {},
 		mediaKind,
 		...videoAudioOptions,
 		...videoOptions,
@@ -22047,7 +23271,20 @@ async function executeBatch(parsed, ctx, client, deps, mediaKind, saveBatchManif
 	const referenceVariantIds = refs.length > 0 ? await resolveReferenceVariantIds(refs, ctx, deps, state.variants, mediaKind) : void 0;
 	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
 	const runId = deps.createRunId();
-	console.log(`Batch generating ${count} ${mediaKind === "image" ? "image" : mediaKind === "video" ? "video" : "audio file"}(s) for "${name}"...`);
+	const styleSelection = await resolveStyleSelection(parsed, ctx, deps);
+	await printPreflightEstimate(client, {
+		operation: "batch",
+		assetType,
+		mediaKind,
+		prompt,
+		count,
+		model: imageOptions.model,
+		imageSize: imageOptions.imageSize,
+		...musicProvider ? { musicProvider } : {}
+	});
+	const mediaLabel = mediaKind === "image" ? "image" : mediaKind === "video" ? "video" : "audio file";
+	printStyleSelection(styleSelection);
+	console.log(`Batch generating ${count} ${mediaLabel}(s) for "${name}"...`);
 	const audioVoiceOptions = mediaKind === "audio" ? parseAudioVoiceOptions(parsed) : {};
 	const result = await client.sendBatchRequest({
 		name,
@@ -22058,8 +23295,8 @@ async function executeBatch(parsed, ctx, client, deps, mediaKind, saveBatchManif
 		referenceVariantIds,
 		...imageOptions,
 		aspectRatio: imageOptions.aspectRatio,
-		parentAssetId: parsed.options.parent,
 		disableStyle: parsed.options["no-style"] === "true",
+		...styleSelection.stylePresetId ? { stylePresetId: styleSelection.stylePresetId } : {},
 		mediaKind,
 		...audioVoiceOptions,
 		...musicProvider ? { musicProvider } : {}
@@ -22177,7 +23414,7 @@ async function placeProductionRecordFromScene(input) {
 		record
 	});
 }
-async function buildContext$3(parsed, deps) {
+async function buildContext$6(parsed, deps) {
 	const projectConfig = await deps.loadProjectConfig();
 	const env = resolveCommandEnvironment(parsed, projectConfig);
 	const spaceId = resolveCommandSpace(parsed, projectConfig);
@@ -22243,6 +23480,51 @@ function requestSpaceState(client) {
 		client.requestSync();
 	});
 }
+async function resolveStyleSelection(parsed, ctx, deps) {
+	const stylePresetRef = readStylePresetOption(parsed);
+	if (parsed.options["no-style"] === "true") {
+		if (stylePresetRef) throw new Error("--style-preset cannot be used with --no-style");
+		return {};
+	}
+	if (!stylePresetRef) return {};
+	const presets = (await apiFetch("GET /api/spaces/:id/style-presets", {
+		baseUrl: ctx.baseUrl,
+		fetch: deps.fetch ?? fetch,
+		params: { id: ctx.spaceId },
+		headers: {
+			"Authorization": `Bearer ${ctx.accessToken}`,
+			"Accept": "application/json"
+		}
+	})).presets;
+	const byId = presets.find((preset) => preset.id === stylePresetRef);
+	const byName = presets.filter((preset) => preset.name === stylePresetRef);
+	const preset = byId ?? (byName.length === 1 ? byName[0] : void 0);
+	if (!preset) {
+		if (byName.length > 1) throw new Error(`Style preset name is ambiguous: ${stylePresetRef}. Use a preset ID.`);
+		throw new Error(`Style preset not found: ${stylePresetRef}`);
+	}
+	if (!isTruthyFlag(preset.enabled)) throw new Error(`Style preset is disabled: ${preset.name} (${preset.id})`);
+	return {
+		stylePresetId: preset.id,
+		preset
+	};
+}
+function readStylePresetOption(parsed) {
+	return readOptionalOption(parsed, "style-preset", "stylePreset") ?? readOptionalOption(parsed, "preset", "preset");
+}
+function printStyleSelection(selection) {
+	if (selection.preset) {
+		const preset = selection.preset;
+		const defaultLabel = isTruthyFlag(preset.is_default) ? ", default" : "";
+		console.log(`Style preset: ${preset.name} (${preset.id}${defaultLabel})`);
+		console.log(`  References: ${preset.reference_count}`);
+		console.log(`  Collection: ${preset.collection_name || "-"}`);
+		return;
+	}
+}
+function isTruthyFlag(value) {
+	return value === true || value === 1;
+}
 async function downloadResult(result, outputPath, ctx, deps) {
 	const variant = result.variant;
 	if (!result.success || !variant) throw new Error(result.error || "Generation failed without a completed variant");
@@ -22528,7 +23810,7 @@ function cliImageSizeValues() {
 function cliImageAspectValues() {
 	return cliOptionValues(getImageModelCapabilities().supportedAspectRatios);
 }
-function printUsage$7(command) {
+function printUsage$9(command) {
 	if (command === "generate") {
 		console.log(`
 Usage:
@@ -22581,7 +23863,7 @@ function printBatchResult(result, outputDir, manifestPath, ctx, mediaKind) {
 }
 //#endregion
 //#region src/cli/commands/audio.ts
-var defaultDeps$5 = {
+var defaultDeps$8 = {
 	loadConfig: loadStoredConfig,
 	loadProjectConfig,
 	resolveBaseUrl,
@@ -22594,11 +23876,11 @@ async function handleAudio(parsed) {
 		await executeAudio(parsed);
 	} catch (error) {
 		console.error("Error:", error instanceof Error ? error.message : error);
-		printUsage$6();
+		printUsage$8();
 		process$1.exitCode = 1;
 	}
 }
-async function executeAudio(parsed, deps = defaultDeps$5) {
+async function executeAudio(parsed, deps = defaultDeps$8) {
 	const invocation = parseAudioInvocation(parsed.positionals);
 	if (invocation.command === "voices") return executeAudioVoices({
 		...parsed,
@@ -22671,7 +23953,7 @@ function printVoices(response, print) {
 function formatLabels(labels) {
 	return Object.entries(labels).map(([key, value]) => `${key}:${value}`).join(", ");
 }
-function printUsage$6() {
+function printUsage$8() {
 	const modes = AUDIO_FORGE_MEDIA_MODES.join("|");
 	console.log(`
 Usage:
@@ -22700,7 +23982,7 @@ async function handleVideo(parsed) {
 		});
 	} catch (error) {
 		console.error("Error:", error instanceof Error ? error.message : error);
-		printUsage$5();
+		printUsage$7();
 		process$1.exitCode = 1;
 	}
 }
@@ -22709,7 +23991,7 @@ function parseVideoCommand(value) {
 	if (value && commands.includes(value)) return value;
 	throw new Error("Video command is required: generate, refine, or derive");
 }
-function printUsage$5() {
+function printUsage$7() {
 	const aspectValues = VIDEO_GENERATION_ASPECT_RATIOS.join("|");
 	const resolutionValues = Array.from(new Set(VIDEO_GENERATION_TIERS.flatMap((tier) => getVideoGenerationResolutionsForTier(tier)))).join("|");
 	const durationValues = VIDEO_GENERATION_DURATION_SECONDS.join("|");
@@ -22741,17 +24023,17 @@ Production metadata:
 }
 //#endregion
 //#region src/cli/commands/init.ts
-var defaultDeps$4 = { saveProjectConfig };
+var defaultDeps$7 = { saveProjectConfig };
 async function handleInit(parsed) {
 	try {
 		await executeInit(parsed);
 	} catch (error) {
 		console.error("Error:", error instanceof Error ? error.message : error);
-		printUsage$4();
+		printUsage$6();
 		process$1.exitCode = 1;
 	}
 }
-async function executeInit(parsed, deps = defaultDeps$4) {
+async function executeInit(parsed, deps = defaultDeps$7) {
 	const environment = resolveCommandEnvironment(parsed);
 	const spaceId = resolveCommandSpace(parsed);
 	if (!spaceId) throw new Error("--space is required");
@@ -22777,7 +24059,7 @@ async function executeInit(parsed, deps = defaultDeps$4) {
 		spaceId
 	};
 }
-function printUsage$4() {
+function printUsage$6() {
 	console.log(`
 Usage:
   makefx init --space <id> [--env production|stage|local]
@@ -22786,7 +24068,7 @@ Usage:
 }
 //#endregion
 //#region src/cli/commands/runs.ts
-var defaultDeps$3 = {
+var defaultDeps$6 = {
 	loadProjectConfig,
 	listRunManifests,
 	readRunManifest,
@@ -22799,11 +24081,11 @@ async function handleRuns(parsed) {
 		await executeRuns(parsed);
 	} catch (error) {
 		console.error("Error:", error instanceof Error ? error.message : error);
-		printUsage$3();
+		printUsage$5();
 		process$1.exitCode = 1;
 	}
 }
-async function executeRuns(parsed, deps = defaultDeps$3) {
+async function executeRuns(parsed, deps = defaultDeps$6) {
 	const projectConfig = await deps.loadProjectConfig();
 	if (!projectConfig?.projectRoot) throw new Error("Make Effects project config not found. Run: makefx init --space <id>");
 	requireDebugAcknowledgement(parsed);
@@ -22921,7 +24203,7 @@ function formatCreated(value) {
 	if (Number.isNaN(date.getTime())) return value;
 	return value.replace("T", " ").replace(/\.\d{3}Z$/, "Z").slice(0, 20);
 }
-function printUsage$3() {
+function printUsage$5() {
 	console.log(`
 Usage:
   makefx runs --debug
@@ -22939,7 +24221,7 @@ For timed scene assembly, use:
 }
 //#endregion
 //#region src/cli/commands/assets.ts
-var defaultDeps$2 = {
+var defaultDeps$5 = {
 	loadConfig: loadStoredConfig,
 	loadProjectConfig,
 	resolveBaseUrl,
@@ -22962,15 +24244,15 @@ async function handleAssets(parsed) {
 		await executeAssets(parsed);
 	} catch (error) {
 		console.error("Error:", error instanceof Error ? error.message : error);
-		printUsage$2();
+		printUsage$4();
 		process$1.exitCode = 1;
 	}
 }
-async function executeAssets(parsed, deps = defaultDeps$2) {
-	const ctx = await buildContext$2(parsed, deps);
+async function executeAssets(parsed, deps = defaultDeps$5) {
+	const ctx = await buildContext$5(parsed, deps);
 	const subcommand = parsed.positionals[0] || "list";
 	if (subcommand === "list") {
-		const assets = await listAssets(ctx, deps);
+		const assets = await listAssets$1(ctx, deps);
 		if (parsed.options.json === "true") deps.print(JSON.stringify(assets.map(toAssetJson), null, 2));
 		else printAssetList(assets, deps.print);
 		return {
@@ -23046,7 +24328,7 @@ async function executeAssets(parsed, deps = defaultDeps$2) {
 function normalizeOption(value) {
 	return !value || value === "true" ? void 0 : value;
 }
-async function buildContext$2(parsed, deps) {
+async function buildContext$5(parsed, deps) {
 	const projectConfig = await deps.loadProjectConfig();
 	const env = resolveCommandEnvironment(parsed, projectConfig);
 	const spaceId = resolveCommandSpace(parsed, projectConfig);
@@ -23063,7 +24345,7 @@ async function buildContext$2(parsed, deps) {
 		force: parsed.options.force === "true"
 	};
 }
-async function listAssets(ctx, deps) {
+async function listAssets$1(ctx, deps) {
 	return (await fetchJson(ctx, deps, `/api/spaces/${ctx.spaceId}/assets`)).assets || [];
 }
 async function getAssetDetails(ctx, deps, assetId) {
@@ -23088,7 +24370,7 @@ async function resolveDownloadRef(ref, ctx, deps) {
 			requestPath: `/api/images/${ref}`
 		};
 	}
-	const assets = await listAssets(ctx, deps);
+	const assets = await listAssets$1(ctx, deps);
 	for (const asset of assets) {
 		const variant = (await getAssetDetails(ctx, deps, asset.id)).variants.find((candidate) => candidate.id === ref);
 		if (!variant) continue;
@@ -23146,7 +24428,6 @@ function printAssetDetails(details, ctx, print) {
 	print(`  Type:     ${asset.type || "unknown"}`);
 	print(`  Media:    ${asset.media_kind || "-"}`);
 	print(`  Active:   ${asset.active_variant_id || "-"}`);
-	print(`  Parent:   ${asset.parent_asset_id || "-"}`);
 	print(`  Created:  ${formatTimestamp(asset.created_at)}`);
 	print(`  Updated:  ${formatTimestamp(asset.updated_at)}`);
 	print(`  Web:      ${ctx.baseUrl}/spaces/${ctx.spaceId}/assets/${asset.id}`);
@@ -23195,7 +24476,6 @@ function toAssetJson(asset) {
 		type: asset.type,
 		media_kind: asset.media_kind || null,
 		activeVariantId: asset.active_variant_id,
-		parentAssetId: asset.parent_asset_id || null,
 		createdAt: asset.created_at || null,
 		updatedAt: asset.updated_at || null
 	};
@@ -23227,7 +24507,7 @@ function formatTimestamp(value) {
 	if (Number.isNaN(date.getTime())) return String(value);
 	return date.toISOString().replace("T", " ").replace(/\.\d{3}Z$/, "Z").slice(0, 20);
 }
-function printUsage$2() {
+function printUsage$4() {
 	console.log(`
 Usage:
   makefx assets
@@ -23242,7 +24522,7 @@ Usage:
 }
 //#endregion
 //#region src/cli/commands/variants.ts
-var defaultDeps$1 = {
+var defaultDeps$4 = {
 	loadConfig: loadStoredConfig,
 	loadProjectConfig,
 	resolveBaseUrl,
@@ -23254,12 +24534,12 @@ async function handleVariants(parsed) {
 		await executeVariants(parsed);
 	} catch (error) {
 		console.error("Error:", error instanceof Error ? error.message : error);
-		printUsage$1();
+		printUsage$3();
 		process$1.exitCode = 1;
 	}
 }
-async function executeVariants(parsed, deps = defaultDeps$1) {
-	const ctx = await buildContext$1(parsed, deps);
+async function executeVariants(parsed, deps = defaultDeps$4) {
+	const ctx = await buildContext$4(parsed, deps);
 	const subcommand = parsed.positionals[0];
 	if (subcommand === "delete") {
 		const variantId = requireVariantId(parsed, "delete");
@@ -23307,7 +24587,7 @@ function requireVariantId(parsed, verb) {
 	if (!variantId) throw new Error(`Variant ID is required: makefx variants ${verb} <variant-id>`);
 	return variantId;
 }
-async function buildContext$1(parsed, deps) {
+async function buildContext$4(parsed, deps) {
 	const projectConfig = await deps.loadProjectConfig();
 	const env = resolveCommandEnvironment(parsed, projectConfig);
 	const spaceId = resolveCommandSpace(parsed, projectConfig);
@@ -23330,7 +24610,7 @@ async function withVariantClient(ctx, deps, run) {
 		client.disconnect();
 	}
 }
-function printUsage$1() {
+function printUsage$3() {
 	console.log(`
 Usage:
   makefx variants delete <variant-id>
@@ -23346,6 +24626,809 @@ Options:
 `);
 }
 //#endregion
+//#region src/cli/commands/styles.ts
+var defaultDeps$3 = {
+	loadConfig: loadStoredConfig,
+	loadProjectConfig,
+	resolveBaseUrl,
+	fetch,
+	print: console.log
+};
+async function handleStyles(parsed) {
+	try {
+		await executeStyles(parsed);
+	} catch (error) {
+		console.error("Error:", error instanceof Error ? error.message : error);
+		printUsage$2();
+		process$1.exitCode = 1;
+	}
+}
+async function executeStyles(parsed, deps = defaultDeps$3) {
+	const namespace = parsed.positionals[0] || "presets";
+	if (namespace === "references" || namespace === "refs") return executeReferences(parsed, deps);
+	if (namespace === "collections" || namespace === "collection") return executeCollections(parsed, deps);
+	if (namespace === "presets" || namespace === "preset") return executePresets(parsed, deps);
+	throw new Error(`Unknown styles command: ${namespace}`);
+}
+async function executeReferences(parsed, deps) {
+	const ctx = await buildContext$3(parsed, deps);
+	const collectionFilter = readOption(parsed, "collection", "collectionId") || parsed.positionals[1];
+	const collections = await listStyleReferenceCollections(ctx, deps);
+	const selected = collectionFilter ? collections.filter((collection) => collection.id === collectionFilter || collection.name === collectionFilter) : collections;
+	if (collectionFilter && selected.length === 0) throw new Error(`Style reference collection not found: ${collectionFilter}`);
+	const references = [];
+	for (const collection of selected) {
+		const items = await listCollectionItems(ctx, deps, collection.id);
+		for (const item of items.filter((candidate) => candidate.role === "style_ref")) references.push({
+			collectionId: collection.id,
+			collectionName: collection.name,
+			item
+		});
+	}
+	if (parsed.options.json === "true") deps.print(JSON.stringify(references, null, 2));
+	else printReferences(references, deps.print);
+	return {
+		type: "references",
+		references
+	};
+}
+async function executeCollections(parsed, deps) {
+	const ctx = await buildContext$3(parsed, deps);
+	const action = parsed.positionals[1] || "list";
+	if (action === "list") {
+		const collections = await listStyleReferenceCollections(ctx, deps);
+		if (parsed.options.json === "true") deps.print(JSON.stringify(collections, null, 2));
+		else printCollections(collections, deps.print);
+		return {
+			type: "collections",
+			collections
+		};
+	}
+	if (action === "create") {
+		const name = parsed.positionals[2] || readRequiredOption(parsed, "name", "name");
+		const collection = await createCollection(ctx, deps, {
+			id: readOption(parsed, "id", "id"),
+			name,
+			description: nullableOption(parsed, "description", "description")
+		});
+		const items = await upsertStyleReferenceItems(ctx, deps, collection.id, parsed, false);
+		printCollectionMutation("Created", collection, items, deps.print, parsed.options.json === "true");
+		return {
+			type: "collection",
+			collection,
+			items
+		};
+	}
+	if (action === "update") {
+		const collectionId = parsed.positionals[2] || readRequiredOption(parsed, "id", "id");
+		const changes = {};
+		const name = readOption(parsed, "name", "name");
+		const description = nullableOption(parsed, "description", "description");
+		if (name !== void 0) changes.name = name;
+		if (description !== void 0) changes.description = description;
+		let collection;
+		if (Object.keys(changes).length > 0) collection = await updateCollection(ctx, deps, collectionId, changes);
+		const items = hasReferenceOptions(parsed) ? await upsertStyleReferenceItems(ctx, deps, collectionId, parsed, parsed.options.append !== "true") : void 0;
+		if (!collection) collection = (await listCollections(ctx, deps)).find((candidate) => candidate.id === collectionId);
+		if (!collection) throw new Error(`Collection not found: ${collectionId}`);
+		printCollectionMutation("Updated", collection, items, deps.print, parsed.options.json === "true");
+		return {
+			type: "collection",
+			collection,
+			items
+		};
+	}
+	throw new Error(`Unknown styles collections command: ${action}`);
+}
+async function executePresets(parsed, deps) {
+	const ctx = await buildContext$3(parsed, deps);
+	const action = parsed.positionals[1] || "list";
+	if (action === "list") {
+		const presets = await listStylePresets(ctx, deps);
+		if (parsed.options.json === "true") deps.print(JSON.stringify(presets, null, 2));
+		else printPresets(presets, deps.print);
+		return {
+			type: "presets",
+			presets
+		};
+	}
+	if (action === "create") {
+		const name = parsed.positionals[2] || readRequiredOption(parsed, "name", "name");
+		const response = await createStylePreset(ctx, deps, {
+			id: readOption(parsed, "id", "id"),
+			name,
+			description: nullableOption(parsed, "description", "description"),
+			stylePrompt: readOption(parsed, "prompt", "stylePrompt") ?? "",
+			collectionId: nullableOption(parsed, "collection", "collectionId"),
+			enabled: parsed.options.disable === "true" ? false : true,
+			isDefault: parsed.options.default === "true"
+		});
+		printPresetMutation("Created", response.preset, deps.print, parsed.options.json === "true");
+		return {
+			type: "preset",
+			preset: response.preset
+		};
+	}
+	if (action === "update") {
+		const response = await updateStylePreset(ctx, deps, parsed.positionals[2] || readRequiredOption(parsed, "id", "id"), buildPresetUpdate(parsed));
+		printPresetMutation("Updated", response.preset, deps.print, parsed.options.json === "true");
+		return {
+			type: "preset",
+			preset: response.preset
+		};
+	}
+	if (action === "enable" || action === "disable") {
+		const response = await updateStylePreset(ctx, deps, parsed.positionals[2] || readRequiredOption(parsed, "id", "id"), { enabled: action === "enable" });
+		printPresetMutation(action === "enable" ? "Enabled" : "Disabled", response.preset, deps.print, parsed.options.json === "true");
+		return {
+			type: "preset",
+			preset: response.preset
+		};
+	}
+	if (action === "delete" || action === "remove") {
+		const presetId = parsed.positionals[2] || readRequiredOption(parsed, "id", "id");
+		await deleteStylePreset(ctx, deps, presetId);
+		if (parsed.options.json === "true") deps.print(JSON.stringify({
+			success: true,
+			presetId
+		}, null, 2));
+		else deps.print(`Deleted style preset ${presetId}`);
+		return {
+			type: "delete-preset",
+			presetId
+		};
+	}
+	throw new Error(`Unknown styles presets command: ${action}`);
+}
+async function buildContext$3(parsed, deps) {
+	const projectConfig = await deps.loadProjectConfig();
+	const env = resolveCommandEnvironment(parsed, projectConfig);
+	const spaceId = resolveCommandSpace(parsed, projectConfig);
+	if (!spaceId) throw new Error("--space is required, or run: makefx init --space <id>");
+	const config = await deps.loadConfig(env);
+	if (!config) throw new Error(`Not logged in to ${env} environment. Run: ${loginCommandForEnvironment(env)}`);
+	if (config.token.expiresAt < Date.now()) throw new Error(`Token expired for ${env} environment. Run: ${loginCommandForEnvironment(env)}`);
+	if (env === "local") process$1.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+	return {
+		env,
+		spaceId,
+		baseUrl: deps.resolveBaseUrl(env),
+		accessToken: config.token.accessToken
+	};
+}
+async function listAssets(ctx, deps) {
+	return (await apiFetch("GET /api/spaces/:id/assets", {
+		baseUrl: ctx.baseUrl,
+		fetch: deps.fetch,
+		params: { id: ctx.spaceId },
+		headers: authHeaders(ctx)
+	})).assets;
+}
+async function listCollections(ctx, deps) {
+	return (await apiFetch("GET /api/spaces/:id/collections", {
+		baseUrl: ctx.baseUrl,
+		fetch: deps.fetch,
+		params: { id: ctx.spaceId },
+		headers: authHeaders(ctx)
+	})).collections;
+}
+async function listStyleReferenceCollections(ctx, deps) {
+	return (await apiFetch("GET /api/spaces/:id/style-reference-collections", {
+		baseUrl: ctx.baseUrl,
+		fetch: deps.fetch,
+		params: { id: ctx.spaceId },
+		headers: authHeaders(ctx)
+	})).collections;
+}
+async function listCollectionItems(ctx, deps, collectionId) {
+	return (await apiFetch("GET /api/spaces/:id/collections/:collectionId/items", {
+		baseUrl: ctx.baseUrl,
+		fetch: deps.fetch,
+		params: {
+			id: ctx.spaceId,
+			collectionId
+		},
+		headers: authHeaders(ctx)
+	})).items;
+}
+async function createCollection(ctx, deps, json) {
+	return (await apiFetch("POST /api/spaces/:id/collections", {
+		baseUrl: ctx.baseUrl,
+		fetch: deps.fetch,
+		params: { id: ctx.spaceId },
+		json,
+		headers: authHeaders(ctx)
+	})).collection;
+}
+async function updateCollection(ctx, deps, collectionId, json) {
+	return (await apiFetch("PATCH /api/spaces/:id/collections/:collectionId", {
+		baseUrl: ctx.baseUrl,
+		fetch: deps.fetch,
+		params: {
+			id: ctx.spaceId,
+			collectionId
+		},
+		json,
+		headers: authHeaders(ctx)
+	})).collection;
+}
+async function createCollectionItem(ctx, deps, collectionId, json) {
+	return (await apiFetch("POST /api/spaces/:id/collections/:collectionId/items", {
+		baseUrl: ctx.baseUrl,
+		fetch: deps.fetch,
+		params: {
+			id: ctx.spaceId,
+			collectionId
+		},
+		json,
+		headers: authHeaders(ctx)
+	})).item;
+}
+async function deleteCollectionItem(ctx, deps, collectionId, itemId) {
+	await apiFetch("DELETE /api/spaces/:id/collections/:collectionId/items/:itemId", {
+		baseUrl: ctx.baseUrl,
+		fetch: deps.fetch,
+		params: {
+			id: ctx.spaceId,
+			collectionId,
+			itemId
+		},
+		headers: authHeaders(ctx)
+	});
+}
+async function listStylePresets(ctx, deps) {
+	return (await apiFetch("GET /api/spaces/:id/style-presets", {
+		baseUrl: ctx.baseUrl,
+		fetch: deps.fetch,
+		params: { id: ctx.spaceId },
+		headers: authHeaders(ctx)
+	})).presets;
+}
+async function createStylePreset(ctx, deps, json) {
+	return apiFetch("POST /api/spaces/:id/style-presets", {
+		baseUrl: ctx.baseUrl,
+		fetch: deps.fetch,
+		params: { id: ctx.spaceId },
+		json,
+		headers: authHeaders(ctx)
+	});
+}
+async function updateStylePreset(ctx, deps, presetId, json) {
+	return apiFetch("PATCH /api/spaces/:id/style-presets/:presetId", {
+		baseUrl: ctx.baseUrl,
+		fetch: deps.fetch,
+		params: {
+			id: ctx.spaceId,
+			presetId
+		},
+		json,
+		headers: authHeaders(ctx)
+	});
+}
+async function deleteStylePreset(ctx, deps, presetId) {
+	await apiFetch("DELETE /api/spaces/:id/style-presets/:presetId", {
+		baseUrl: ctx.baseUrl,
+		fetch: deps.fetch,
+		params: {
+			id: ctx.spaceId,
+			presetId
+		},
+		headers: authHeaders(ctx)
+	});
+}
+async function upsertStyleReferenceItems(ctx, deps, collectionId, parsed, replaceExisting) {
+	const refs = await buildStyleReferenceItemRequests(ctx, deps, parsed);
+	if (refs.length === 0) return [];
+	if (replaceExisting) {
+		const existing = await listCollectionItems(ctx, deps, collectionId);
+		await Promise.all(existing.filter((item) => item.role === "style_ref").map((item) => deleteCollectionItem(ctx, deps, collectionId, item.id)));
+	}
+	const created = [];
+	for (let index = 0; index < refs.length; index += 1) created.push(await createCollectionItem(ctx, deps, collectionId, {
+		...refs[index],
+		role: "style_ref",
+		sortIndex: index
+	}));
+	return created;
+}
+async function buildStyleReferenceItemRequests(ctx, deps, parsed) {
+	const assets = parseCsvOptions(parsed, ["assets", "asset"]);
+	const variants = parseCsvOptions(parsed, ["variants", "variant"]);
+	const refs = parseCsvOptions(parsed, ["refs", "ref"]);
+	if (assets.length === 0 && variants.length === 0 && refs.length === 0) return [];
+	const allAssets = await listAssets(ctx, deps);
+	const assetById = new Map(allAssets.map((asset) => [asset.id, asset]));
+	const requests = [];
+	for (const assetId of [...assets, ...refs.filter((ref) => assetById.has(ref))]) {
+		const asset = assetById.get(assetId);
+		if (!asset) throw new Error(`Asset not found in space ${ctx.spaceId}: ${assetId}`);
+		if (!asset.active_variant_id) throw new Error(`Asset ${assetId} has no active variant to pin as a style reference`);
+		requests.push({
+			subjectType: "asset",
+			assetId,
+			pinnedVariantId: asset.active_variant_id
+		});
+	}
+	for (const variantId of [...variants, ...refs.filter((ref) => !assetById.has(ref))]) requests.push({
+		subjectType: "variant",
+		variantId
+	});
+	return dedupeItemRequests(requests);
+}
+function dedupeItemRequests(requests) {
+	const seen = /* @__PURE__ */ new Set();
+	return requests.filter((request) => {
+		const key = request.subjectType === "asset" ? `asset:${request.assetId}:${request.pinnedVariantId ?? ""}` : `variant:${request.variantId}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+function buildPresetUpdate(parsed) {
+	const update = {};
+	const name = readOption(parsed, "name", "name");
+	const description = nullableOption(parsed, "description", "description");
+	const stylePrompt = readOption(parsed, "prompt", "stylePrompt");
+	const collectionId = nullableOption(parsed, "collection", "collectionId");
+	if (name !== void 0) update.name = name;
+	if (description !== void 0) update.description = description;
+	if (stylePrompt !== void 0) update.stylePrompt = stylePrompt;
+	if (collectionId !== void 0) update.collectionId = collectionId;
+	if (parsed.options.enable === "true") update.enabled = true;
+	if (parsed.options.disable === "true") update.enabled = false;
+	if (parsed.options.default === "true") update.isDefault = true;
+	if (parsed.options["no-default"] === "true") update.isDefault = false;
+	if (Object.keys(update).length === 0) throw new Error("No preset updates provided");
+	return update;
+}
+function authHeaders(ctx) {
+	return {
+		"Authorization": `Bearer ${ctx.accessToken}`,
+		"Accept": "application/json"
+	};
+}
+function hasReferenceOptions(parsed) {
+	return [
+		"refs",
+		"ref",
+		"assets",
+		"asset",
+		"variants",
+		"variant"
+	].some((key) => Boolean(readRawOption(parsed, key)));
+}
+function parseCsvOptions(parsed, keys) {
+	return keys.flatMap((key) => parseCsv(readRawOption(parsed, key)));
+}
+function parseCsv(value) {
+	if (!value || value === "true") return [];
+	return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function readRequiredOption(parsed, kebabName, camelName) {
+	const value = readOption(parsed, kebabName, camelName);
+	if (value === void 0) throw new Error(`--${kebabName} is required`);
+	return value;
+}
+function readOption(parsed, kebabName, camelName) {
+	const value = readRawOption(parsed, kebabName) ?? readRawOption(parsed, camelName);
+	return !value || value === "true" ? void 0 : value;
+}
+function readRawOption(parsed, key) {
+	return parsed.options[key];
+}
+function nullableOption(parsed, kebabName, camelName) {
+	if (parsed.options["no-collection"] === "true" && (kebabName === "collection" || camelName === "collectionId")) return null;
+	const value = readOption(parsed, kebabName, camelName);
+	if (value === void 0) return void 0;
+	return value === "null" || value === "-" ? null : value;
+}
+function isEnabled(value) {
+	return value === true || value === 1;
+}
+function printReferences(references, print) {
+	if (references.length === 0) {
+		print("No style reference assets found.");
+		return;
+	}
+	print(`Found ${references.length} style reference asset(s):\n`);
+	print("Collection".padEnd(28) + "Subject".padEnd(10) + "Asset".padEnd(28) + "Variant".padEnd(28) + "Item");
+	print("-".repeat(108));
+	for (const reference of references) {
+		const item = reference.item;
+		print(truncate(reference.collectionName, 26).padEnd(28) + item.subject_type.padEnd(10) + truncate(item.asset_id || "-", 26).padEnd(28) + truncate(item.pinned_variant_id || item.variant_id || "-", 26).padEnd(28) + truncate(item.id, 26));
+	}
+}
+function printCollections(collections, print) {
+	if (collections.length === 0) {
+		print("No style reference collections found.");
+		return;
+	}
+	print(`Found ${collections.length} style reference collection(s):\n`);
+	print("References".padEnd(12) + "Presets".padEnd(10) + "Collection".padEnd(34) + "Name");
+	print("-".repeat(88));
+	for (const collection of collections) print(String(collection.reference_count).padEnd(12) + String(collection.preset_count).padEnd(10) + truncate(collection.id, 32).padEnd(34) + truncate(collection.name, 40));
+}
+function printPresets(presets, print) {
+	if (presets.length === 0) {
+		print("No style presets found.");
+		return;
+	}
+	print(`Found ${presets.length} style preset(s):\n`);
+	print("State".padEnd(14) + "References".padEnd(12) + "Preset".padEnd(30) + "Collection".padEnd(28) + "Name");
+	print("-".repeat(104));
+	for (const preset of presets) print(truncate(`${isEnabled(preset.enabled) ? "enabled" : "disabled"}${isEnabled(preset.is_default) ? ",default" : ""}`, 12).padEnd(14) + String(preset.reference_count).padEnd(12) + truncate(preset.id, 28).padEnd(30) + truncate(preset.collection_name || preset.collection_id || "-", 26).padEnd(28) + truncate(preset.name, 34));
+}
+function printCollectionMutation(verb, collection, items, print, asJson) {
+	if (asJson) {
+		print(JSON.stringify({
+			collection,
+			items
+		}, null, 2));
+		return;
+	}
+	print(`${verb} style reference collection ${collection.id}`);
+	print(`  Name:       ${collection.name}`);
+	if (items) print(`  References: ${items.filter((item) => item.role === "style_ref").length}`);
+}
+function printPresetMutation(verb, preset, print, asJson) {
+	if (asJson) {
+		print(JSON.stringify(preset, null, 2));
+		return;
+	}
+	print(`${verb} style preset ${preset.id}`);
+	print(`  Name:       ${preset.name}`);
+	print(`  Enabled:    ${isEnabled(preset.enabled) ? "yes" : "no"}`);
+	print(`  Default:    ${isEnabled(preset.is_default) ? "yes" : "no"}`);
+	print(`  Collection: ${preset.collection_name || preset.collection_id || "-"}`);
+	print(`  References: ${preset.reference_count}`);
+}
+function printUsage$2() {
+	console.log(`
+Usage:
+  makefx styles references [--collection <id-or-name>] [--json]
+  makefx styles collections list [--json]
+  makefx styles collections create <name> --refs <asset_or_variant,...>
+  makefx styles collections update <collection-id> [--name <name>] [--refs <asset_or_variant,...>] [--append]
+  makefx styles presets list [--json]
+  makefx styles presets create <name> --collection <collection-id> --prompt "style prompt" [--default]
+  makefx styles presets update <preset-id> [--name <name>] [--collection <collection-id>] [--prompt "style prompt"]
+  makefx styles presets enable <preset-id>
+  makefx styles presets disable <preset-id>
+  makefx styles presets delete <preset-id>
+
+Options:
+  --space <id>      Target space ID; defaults from the initialized project
+  --refs <ids>      Comma-separated asset IDs or variant IDs to use as style references
+  --assets <ids>    Comma-separated asset IDs; active variants are pinned
+  --variants <ids>  Comma-separated variant IDs
+  --json            Print machine-readable output
+  --env <env>       Environment (production|stage|local)
+  --local           Shortcut for --env local
+`);
+}
+//#endregion
+//#region src/cli/commands/usage.ts
+var defaultDeps$2 = {
+	loadConfig: loadStoredConfig,
+	loadProjectConfig,
+	resolveBaseUrl,
+	fetch,
+	print: console.log
+};
+async function handleUsage(parsed) {
+	try {
+		await executeUsage(parsed);
+	} catch (error) {
+		console.error("Error:", error instanceof Error ? error.message : error);
+		printUsage$1();
+		process$1.exitCode = 1;
+	}
+}
+async function executeUsage(parsed, deps = defaultDeps$2) {
+	const subcommand = parsed.positionals[0] || "summary";
+	if (subcommand !== "summary") throw new Error(`Unknown usage command: ${subcommand}`);
+	const summary = await fetchUsageSummary(await buildContext$2(parsed, deps), deps, {
+		from: optionValue$2(parsed.options.from),
+		to: optionValue$2(parsed.options.to)
+	});
+	if (parsed.options.json === "true") deps.print(JSON.stringify(summary, null, 2));
+	else printUsageSummary(summary, deps.print);
+	return {
+		type: "summary",
+		summary
+	};
+}
+async function buildContext$2(parsed, deps) {
+	const projectConfig = await deps.loadProjectConfig();
+	const env = resolveCommandEnvironment(parsed, projectConfig);
+	const spaceId = resolveCommandSpace(parsed, projectConfig);
+	if (!spaceId) throw new Error("--space is required, or run: makefx init --space <id>");
+	const config = await deps.loadConfig(env);
+	if (!config) throw new Error(`Not logged in to ${env} environment. Run: ${loginCommandForEnvironment(env)}`);
+	if (config.token.expiresAt < Date.now()) throw new Error(`Token expired for ${env} environment. Run: ${loginCommandForEnvironment(env)}`);
+	if (env === "local") process$1.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+	return {
+		env,
+		spaceId,
+		baseUrl: deps.resolveBaseUrl(env),
+		accessToken: config.token.accessToken
+	};
+}
+async function fetchUsageSummary(ctx, deps, options) {
+	const params = new URLSearchParams();
+	if (options.from) params.set("from", options.from);
+	if (options.to) params.set("to", options.to);
+	const query = params.toString();
+	const response = await deps.fetch(`${ctx.baseUrl}/api/spaces/${encodeURIComponent(ctx.spaceId)}/usage/summary${query ? `?${query}` : ""}`, { headers: {
+		"Authorization": `Bearer ${ctx.accessToken}`,
+		"Accept": "application/json"
+	} });
+	if (!response.ok) {
+		const text = await response.text();
+		throw new Error(`Request failed (${response.status}): ${text || response.statusText}`);
+	}
+	return response.json();
+}
+function optionValue$2(value) {
+	return !value || value === "true" ? void 0 : value;
+}
+function printUsageSummary(summary, print) {
+	print(`\nUsage summary for ${summary.spaceId}\n`);
+	print(`  Period:        ${formatPeriod$1(summary.period)}`);
+	print(`  Storage:       ${formatBytes(summary.totals.storageBytes)}`);
+	print(`  Workflow runs: ${summary.totals.workflowRuns}`);
+	print(`  Delivery:      ${formatBytes(summary.totals.deliveryBytes)}`);
+	if (summary.byMediaKind.length > 0) {
+		print("\nBy media kind:");
+		print("Media".padEnd(10) + "Storage".padEnd(14) + "Workflows".padEnd(12) + "Delivery".padEnd(14) + "Events");
+		print("-".repeat(58));
+		for (const row of summary.byMediaKind) print((row.mediaKind || "-").padEnd(10) + formatBytes(row.storageBytes).padEnd(14) + String(row.workflowRuns).padEnd(12) + formatBytes(row.deliveryBytes).padEnd(14) + String(row.events));
+	}
+}
+function formatPeriod$1(period) {
+	if (!period.from && !period.to) return "all time";
+	if (period.from && period.to) return `${period.from} to ${period.to}`;
+	if (period.from) return `from ${period.from}`;
+	return `through ${period.to}`;
+}
+function formatBytes(bytes) {
+	const sign = bytes < 0 ? "-" : "";
+	let value = Math.abs(bytes);
+	const units = [
+		"B",
+		"KiB",
+		"MiB",
+		"GiB",
+		"TiB"
+	];
+	let unitIndex = 0;
+	while (value >= 1024 && unitIndex < units.length - 1) {
+		value /= 1024;
+		unitIndex += 1;
+	}
+	return `${sign}${unitIndex === 0 ? String(value) : value.toFixed(value >= 10 ? 1 : 2)} ${units[unitIndex]}`;
+}
+function printUsage$1() {
+	console.log(`
+Usage:
+  makefx usage [summary] [--space <id>] [--from <date>] [--to <date>]
+  makefx usage --json
+
+Options:
+  --space <id>      Target space ID; defaults from the initialized project
+  --from <date>     Include usage at or after this date or ISO timestamp
+  --to <date>       Include usage at or before this date or ISO timestamp
+  --json            Print machine-readable output
+  --env <env>       Environment (production|stage|local)
+  --local           Shortcut for --env local
+`);
+}
+//#endregion
+//#region src/cli/commands/spend.ts
+var defaultDeps$1 = {
+	loadConfig: loadStoredConfig,
+	loadProjectConfig,
+	resolveBaseUrl,
+	fetch,
+	print: console.log
+};
+async function handleSpend(parsed) {
+	try {
+		await executeSpend(parsed);
+	} catch (error) {
+		console.error("Error:", error instanceof Error ? error.message : error);
+		printSpend();
+		process$1.exitCode = 1;
+	}
+}
+async function executeSpend(parsed, deps = defaultDeps$1) {
+	const subcommand = parsed.positionals[0] || "summary";
+	if (subcommand !== "summary") throw new Error(`Unknown spend command: ${subcommand}`);
+	const summary = await fetchSpendSummary(await buildContext$1(parsed, deps), deps, {
+		from: optionValue$1(parsed.options.from),
+		to: optionValue$1(parsed.options.to),
+		userId: optionValue$1(parsed.options["user-id"] ?? parsed.options.userId),
+		spaceId: optionValue$1(parsed.options["space-id"] ?? parsed.options.spaceId ?? parsed.options.space),
+		provider: optionValue$1(parsed.options.provider),
+		mediaKind: optionValue$1(parsed.options["media-kind"] ?? parsed.options.mediaKind)
+	});
+	if (parsed.options.json === "true") deps.print(JSON.stringify(summary, null, 2));
+	else printSpendSummary(summary, deps.print);
+	return {
+		type: "summary",
+		summary
+	};
+}
+async function buildContext$1(parsed, deps) {
+	const env = resolveCommandEnvironment(parsed, await deps.loadProjectConfig());
+	const config = await deps.loadConfig(env);
+	if (!config) throw new Error(`Not logged in to ${env} environment. Run: ${loginCommandForEnvironment(env)}`);
+	if (config.token.expiresAt < Date.now()) throw new Error(`Token expired for ${env} environment. Run: ${loginCommandForEnvironment(env)}`);
+	if (env === "local") process$1.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+	return {
+		env,
+		baseUrl: deps.resolveBaseUrl(env),
+		accessToken: config.token.accessToken
+	};
+}
+async function fetchSpendSummary(ctx, deps, options) {
+	const params = new URLSearchParams();
+	if (options.from) params.set("from", options.from);
+	if (options.to) params.set("to", options.to);
+	if (options.userId) params.set("user_id", options.userId);
+	if (options.spaceId) params.set("space_id", options.spaceId);
+	if (options.provider) params.set("provider", options.provider);
+	if (options.mediaKind) params.set("media_kind", options.mediaKind);
+	const query = params.toString();
+	const response = await deps.fetch(`${ctx.baseUrl}/api/billing/spend/summary${query ? `?${query}` : ""}`, { headers: {
+		"Authorization": `Bearer ${ctx.accessToken}`,
+		"Accept": "application/json"
+	} });
+	if (!response.ok) {
+		const text = await response.text();
+		throw new Error(`Request failed (${response.status}): ${text || response.statusText}`);
+	}
+	return response.json();
+}
+function optionValue$1(value) {
+	return !value || value === "true" ? void 0 : value;
+}
+function printSpendSummary(summary, print) {
+	print("\nProvider cost summary\n");
+	print(`  Period:       ${formatPeriod(summary.period)}`);
+	print(`  Filters:      ${formatFilters(summary.filters)}`);
+	print(`  Provider cost: ${formatUsd(summary.totals.amountMicroUsd)}`);
+	print(`  Entries:      ${summary.totals.entries}`);
+	print(`  Unpriced:     ${summary.totals.unpricedEntries}`);
+	print(`  Quantity:     ${formatNumber(summary.totals.quantity)}`);
+	if (summary.byProvider.length > 0) printSpendTable("\nBy provider:", [
+		"Provider",
+		"Cost",
+		"Entries",
+		"Unpriced",
+		"Quantity"
+	], summary.byProvider.map((row) => [
+		row.provider,
+		formatUsd(row.amountMicroUsd),
+		String(row.entries),
+		String(row.unpricedEntries),
+		formatNumber(row.quantity)
+	]), print);
+	if (summary.byModel.length > 0) printSpendTable("\nBy model:", [
+		"Provider",
+		"Model",
+		"Cost",
+		"Entries",
+		"Unpriced"
+	], summary.byModel.map((row) => [
+		row.provider,
+		row.providerModel,
+		formatUsd(row.amountMicroUsd),
+		String(row.entries),
+		String(row.unpricedEntries)
+	]), print);
+	if (summary.byMediaKind.length > 0) printSpendTable("\nBy media kind:", [
+		"Media",
+		"Cost",
+		"Entries",
+		"Unpriced",
+		"Quantity"
+	], summary.byMediaKind.map((row) => [
+		row.mediaKind || "-",
+		formatUsd(row.amountMicroUsd),
+		String(row.entries),
+		String(row.unpricedEntries),
+		formatNumber(row.quantity)
+	]), print);
+	if (summary.byMeterEventName.length > 0) printSpendTable("\nBy meter:", [
+		"Meter",
+		"Cost",
+		"Entries",
+		"Unpriced",
+		"Quantity"
+	], summary.byMeterEventName.map((row) => [
+		row.meterEventName || "-",
+		formatUsd(row.amountMicroUsd),
+		String(row.entries),
+		String(row.unpricedEntries),
+		formatNumber(row.quantity)
+	]), print);
+}
+function printSpendTable(title, headers, rows, print) {
+	print(title);
+	const widths = headers.map((header, index) => Math.max(header.length, ...rows.map((row) => row[index]?.length ?? 0)));
+	print(headers.map((header, index) => header.padEnd(widths[index] + 2)).join("").trimEnd());
+	print(widths.map((width) => "-".repeat(width)).join("  "));
+	for (const row of rows) print(row.map((value, index) => value.padEnd(widths[index] + 2)).join("").trimEnd());
+}
+function formatPeriod(period) {
+	if (!period.from && !period.to) return "all time";
+	if (period.from && period.to) return `${period.from} to ${period.to}`;
+	if (period.from) return `from ${period.from}`;
+	return `through ${period.to}`;
+}
+function formatFilters(filters) {
+	const parts = [
+		filters.userId !== null ? `user=${filters.userId}` : null,
+		filters.spaceId ? `space=${filters.spaceId}` : null,
+		filters.provider ? `provider=${filters.provider}` : null,
+		filters.mediaKind ? `media=${filters.mediaKind}` : null
+	].filter((part) => part !== null);
+	return parts.length > 0 ? parts.join(", ") : "none";
+}
+function formatUsd(amountMicroUsd) {
+	let trimmed = (amountMicroUsd / 1e6).toFixed(6).replace(/0+$/, "").replace(/\.$/, "");
+	if (!trimmed.includes(".")) trimmed = `${trimmed}.00`;
+	else if (trimmed.split(".")[1].length === 1) trimmed = `${trimmed}0`;
+	return `$${trimmed}`;
+}
+function formatNumber(value) {
+	return Number.isInteger(value) ? String(value) : value.toFixed(3).replace(/0+$/, "").replace(/\.$/, "");
+}
+function printSpend() {
+	console.log(`
+Usage:
+  makefx spend [summary] [--from <date>] [--to <date>]
+  makefx spend --user-id <id> --provider <name> --media-kind <image|audio|video>
+  makefx spend --json
+
+Options:
+  --from <date>        Include provider cost at or after this date or ISO timestamp
+  --to <date>          Include provider cost at or before this date or ISO timestamp
+  --user-id <id>       Filter to one user ID
+  --space-id <id>      Filter to one space ID
+  --space <id>         Alias for --space-id
+  --provider <name>    Filter to one provider
+  --media-kind <kind>  Filter to image, audio, or video provider cost
+  --json               Print machine-readable output
+  --env <env>          Environment (production|stage|local)
+  --local              Shortcut for --env local
+`);
+}
+//#endregion
+//#region src/shared/featureFlags.ts
+var TRUE_VALUES = new Set([
+	"1",
+	"true",
+	"yes",
+	"on"
+]);
+var ROTATION_FEATURE_FLAG = "MAKEFX_ROTATION_ENABLED";
+function isFeatureFlagEnabled(value) {
+	if (typeof value === "boolean") return value;
+	if (typeof value === "number") return value === 1;
+	if (typeof value !== "string") return false;
+	return TRUE_VALUES.has(value.trim().toLowerCase());
+}
+//#endregion
+//#region src/cli/lib/feature-flags.ts
+function isCliRotationEnabled(env = process.env) {
+	return isFeatureFlagEnabled(env[ROTATION_FEATURE_FLAG]);
+}
+function rotationDisabledMessage() {
+	return `Rotation features are disabled. Set ${ROTATION_FEATURE_FLAG}=true to enable this experimental surface.`;
+}
+//#endregion
 //#region src/cli/commands/pipelines.ts
 var ROTATION_CONFIGS = [
 	"4-directional",
@@ -23364,6 +25447,7 @@ var defaultDeps = {
 	loadProjectConfig,
 	resolveBaseUrl,
 	createClient: (env, spaceId) => WebSocketClient.create(env, spaceId),
+	isRotationEnabled: isCliRotationEnabled,
 	print: console.log
 };
 async function handleRotation(parsed) {
@@ -23377,12 +25461,15 @@ async function handlePipelineCommand(command, parsed) {
 		const result = await executePipelineCommand(command, parsed, defaultDeps);
 		if ("status" in result && (result.status === "failed" || result.status === "cancelled")) process$1.exitCode = 1;
 	} catch (error) {
-		console.error("Error:", error instanceof Error ? error.message : error);
-		printUsage(command);
+		const message = error instanceof Error ? error.message : String(error);
+		console.error("Error:", message);
+		if (message !== rotationDisabledMessage()) printUsage(command);
 		process$1.exitCode = 1;
 	}
 }
 async function executePipelineCommand(command, parsed, deps = defaultDeps) {
+	const rotationEnabled = deps.isRotationEnabled ?? isCliRotationEnabled;
+	if (command === "rotation" && !rotationEnabled()) throw new Error(rotationDisabledMessage());
 	const ctx = await buildContext(parsed, deps);
 	const client = await deps.createClient(ctx.env, ctx.spaceId);
 	try {
@@ -23584,6 +25671,10 @@ function printJsonOrText(json, result, text, deps) {
 }
 function printUsage(command) {
 	if (command === "rotation") {
+		if (!isCliRotationEnabled()) {
+			console.log(rotationDisabledMessage());
+			return;
+		}
 		console.log(`
 Usage:
   makefx rotation --variant <variant-id> [--config 4-directional|8-directional|turnaround]
@@ -23596,7 +25687,7 @@ Options:
   --subject <text>   Optional subject description for consistency prompts
   --aspect <ratio>   Optional generation aspect ratio
   --mode <mode>      sequential or single-shot (default: sequential)
-  --no-style         Disable the space style anchor
+  --no-style         Disable style preset injection for this pipeline
   --detach           Return after the pipeline starts instead of waiting for completion
   --timeout <sec>    Override the pipeline wait timeout
   --json             Print machine-readable output
@@ -23618,7 +25709,7 @@ Options:
   --seed-variant <id> Optional completed image variant to place at the center (sequential mode only)
   --aspect <ratio>    Optional generation aspect ratio
   --mode <mode>       sequential or single-shot (default: sequential)
-  --no-style          Disable the space style anchor
+  --no-style          Disable style preset injection for this pipeline
   --detach            Return after the pipeline starts instead of waiting for completion
   --timeout <sec>     Override the pipeline wait timeout
   --json              Print machine-readable output
@@ -23626,7 +25717,7 @@ Options:
 }
 //#endregion
 //#region src/cli/index.ts
-var CLI_VERSION = "0.1.3+21fbf493922f";
+var CLI_VERSION = "0.2.1+2f99bf2b725b";
 async function main() {
 	const argv = process$1.argv.slice(2);
 	if (argv[0] === "--") argv.shift();
@@ -23753,10 +25844,20 @@ function printCommandHelp(command, positionals) {
 		case "assets":
 			printAssetsHelp();
 			return;
+		case "usage":
+			printUsageHelp();
+			return;
+		case "spend":
+			printSpendHelp();
+			return;
 		case "variants":
 		case "variant":
 			printVariantsHelp();
 			return;
+		case "styles":
+		case "style":
+			printStylesHelp();
+			return;
 		case "rotation":
 			printRotationHelp();
 			return;
@@ -23775,6 +25876,11 @@ function printCommandHelp(command, positionals) {
 	}
 }
 function printHelp() {
+	const rotationHelp = isCliRotationEnabled() ? `  rotation --variant <variant-id>
+                                 Generate rotation views from a completed image variant
+  rotation cancel <rotation-set-id>
+                                 Cancel an active rotation pipeline` : "";
+	const rotationExample = isCliRotationEnabled() ? "  makefx rotation --variant variant_456 --config 8-directional\n" : "";
 	console.log(`
 Make Effects CLI
 
@@ -23802,10 +25908,10 @@ Project:
   variants star <variant-id>      Star a variant (unstar to clear)
   variants rate <variant-id> approved|rejected
                                  Rate a variant for quality curation
-  rotation --variant <variant-id>
-                                 Generate rotation views from a completed image variant
-  rotation cancel <rotation-set-id>
-                                 Cancel an active rotation pipeline
+  styles presets                  List style presets
+  styles collections              List style reference collections
+  styles references               List style reference assets
+${rotationHelp}
   tileset "prompt" --type terrain --grid 3x3
                                  Generate a consistent tile set
   tileset cancel <tile-set-id>    Cancel an active tile-set pipeline
@@ -23813,12 +25919,14 @@ Project:
                                  List Space-backed production placements
   productions export --production-id <id>
                                  Export production scene args from Space records
+  usage [summary] [--space <id>] Show platform storage and workflow consumption
+  spend [summary]               Show admin provider cost summary
 
 Billing (Polar.sh):
   billing status               Show sync status (pending, failed, synced events)
   billing check                Run operational checks for workers, meters, and sync health
   billing reconcile --user-id <id>
-                               Compare local billable usage with Polar usage
+                               Reconcile Polar, charge, provider, and platform usage
   billing retry-failed         Retry all failed events
 
 Spaces:
@@ -23834,7 +25942,10 @@ Listen:
 
 Upload:
   upload <file> --asset <id> [--space <id>]   Upload image, audio, or video to existing asset
-  upload <file> --name <name> [--space <id>]  Upload media and create new asset
+  upload <file> --name <name> [--space <id>]  Upload image, audio, or video as a new asset
+  upload <file> --collection <id>             Place uploaded media in a collection
+  upload <file> --collection-name <name>      Place uploaded media in an exact-name collection
+  upload <file> --manual-relation <spec>      Create a manual relation from uploaded media
 
 Forge:
   generate "prompt" --name <name> --type <type> -o <file>
@@ -23876,14 +25987,21 @@ Examples:
   makefx audio sfx generate "A short brass victory sting" --name "Victory Sting" -o victory.wav
   makefx video generate "A looping idle animation" --name "Idle Animation" --type animation --duration 6 --resolution 1080p --tier fast -o idle.mp4
   makefx productions export --production-id s01e01-a2
+  makefx upload hero.png --name "Hero" --collection collection_cast
+  makefx upload hero.png --name "Hero" --collection-name "Cast" --json
+  makefx upload thumbnail.png --asset asset_thumb --manual-relation thumbnail_for:asset:asset_target
   makefx assets
+  makefx usage --from 2026-06-01
+  makefx spend --from 2026-06-01 --provider gemini
   makefx assets download variant_123 -o variant.mp4
   makefx assets rename asset_123 "Hero (moving)"
   makefx assets set-active asset_123 variant_456
   makefx variants retry variant_456
   makefx variants delete variant_456
-  makefx rotation --variant variant_456 --config 8-directional
-  makefx tileset "grass and stone path tiles" --type terrain --grid 3x3
+  makefx styles collections create "Painterly refs" --refs asset_123,variant_456
+  makefx styles presets create "Painterly" --collection collection_123 --prompt "Painterly adventure game" --default
+  makefx generate "A market background" --style-preset Painterly --name "Market" --type scene -o market.png
+${rotationExample}  makefx tileset "grass and stone path tiles" --type terrain --grid 3x3
 `);
 }
 function printInitHelp() {
@@ -23918,7 +26036,7 @@ Usage:
 Subcommands:
   status           Show sync status (pending, failed, synced events)
   check            Run operational checks for workers, Polar meters, and sync health
-  reconcile        Compare local billable usage with Polar usage for one user
+  reconcile        Reconcile Polar, charge, provider, and platform usage for one user
   retry-failed     Reset failed events for retry (next cron will sync them)
 
 Options:
@@ -23948,7 +26066,7 @@ function printUploadHelp() {
 	console.log(`
 Usage:
   makefx upload <file> --asset <id> [--space <id>]     Upload media to existing asset
-  makefx upload <file> --name <name> [--space <id>]    Create new asset
+  makefx upload <file> --name <name> [--space <id>]    Upload media as a new asset
 
 Options:
   --space <id>      Target space ID; defaults from initialized project
@@ -23956,7 +26074,29 @@ 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
-  --parent <id>     Parent asset ID for new assets
+  --prompt <text>   Prompt provenance for uploaded media
+  --model <model>   Model provenance for uploaded media
+  --provider <name> Provider provenance for uploaded media
+  --provider-metadata <json>     Provider metadata JSON object
+  --generation-provenance <json> Extra provenance JSON object
+  --source-variant <id>          Existing source variant for upload lineage
+  --relation-type <type>         Lineage type: derived, refined, or forked (default: derived)
+  --active-variant-behavior <b>  if-missing, set-active, or keep
+  --collection <ids>             Comma-separated collection IDs for the uploaded asset or variant
+  --collection-name <names>      Comma-separated exact collection names for lookup
+  --collection-role <role>       Collection item role (default: member)
+  --collection-subject <type>    Collection subject: asset or variant (default: asset)
+  --collection-pinned-variant <id|uploaded|none>
+                                 Pin an asset collection item to the uploaded variant by default
+  --manual-relation <spec>       Comma-separated <type>:asset:<id> or <type>:variant:<id>
+  --manual-relation-subject <type>
+                                 Relation subject: uploaded asset or variant (default: variant)
+  --manual-relation-label <text> Optional manual relation label
+  --manual-relation-context <json|string>
+                                 Optional manual relation context
+  --manual-relation-metadata <json>
+                                 Optional manual relation metadata object
+  --json            Print machine-readable upload output with Space IDs
   --env <env>       Environment (production|stage|local)
   --local           Shortcut for --env local
 `);
@@ -23970,6 +26110,10 @@ Usage:
 
 ${imageCapabilityHelp()}
 
+Style:
+  --style-preset <id-or-name>  Use an enabled style preset for this generation
+  --no-style                   Disable style preset injection for this generation
+
 Production metadata:
   --scene-label <label> --timeline-start-ms <ms> --duration-ms <ms>
   --shot-id <id> --production-id <id>
@@ -23984,6 +26128,10 @@ Usage:
 
 ${imageCapabilityHelp()}
 
+Style:
+  --style-preset <id-or-name>  Use an enabled style preset for this refinement
+  --no-style                   Disable style preset injection for this refinement
+
 Production metadata:
   --scene-label <label> --timeline-start-ms <ms> --duration-ms <ms>
   --shot-id <id> --production-id <id>
@@ -23996,6 +26144,10 @@ Usage:
   makefx batch "prompt" --name <name> --type <type> --count <2-8> --output-dir <dir> [--model ${optionValues(IMAGE_MODEL_SELECTIONS)}] [--size ${imageSizeValues()}] [--aspect <ratio>]
 
 ${imageCapabilityHelp()}
+
+Style:
+  --style-preset <id-or-name>  Use an enabled style preset for this batch
+  --no-style                   Disable style preset injection for this batch
 `);
 		return;
 	}
@@ -24006,6 +26158,10 @@ Usage:
 
 ${imageCapabilityHelp()}
 
+Style:
+  --style-preset <id-or-name>  Use an enabled style preset for this derivation
+  --no-style                   Disable style preset injection for this derivation
+
 Production metadata:
   --scene-label <label> --timeline-start-ms <ms> --duration-ms <ms>
   --shot-id <id> --production-id <id>
@@ -24203,7 +26359,43 @@ Options:
   --local           Shortcut for --env local
 `);
 }
+function printStylesHelp() {
+	console.log(`
+Usage:
+  makefx styles references [--collection <id-or-name>] [--json]
+  makefx styles collections list [--json]
+  makefx styles collections create <name> --refs <asset_or_variant,...>
+  makefx styles collections update <collection-id> [--name <name>] [--refs <asset_or_variant,...>] [--append]
+  makefx styles presets list [--json]
+  makefx styles presets create <name> --collection <collection-id> --prompt "style prompt" [--default]
+  makefx styles presets update <preset-id> [--name <name>] [--collection <collection-id>] [--prompt "style prompt"]
+  makefx styles presets enable <preset-id>
+  makefx styles presets disable <preset-id>
+  makefx styles presets delete <preset-id>
+
+Generation:
+  makefx generate "prompt" --style-preset <id-or-name> --name <name> --type <type> -o <file>
+  makefx generate "prompt" --no-style --name <name> --type <type> -o <file>
+
+Model:
+  Style references are normal Space assets or exact variants grouped into style
+  collections. Style presets point to those collections plus a style prompt.
+
+Options:
+  --space <id>      Target space ID; defaults from the initialized project
+  --refs <ids>      Comma-separated asset IDs or variant IDs to use as style references
+  --assets <ids>    Comma-separated asset IDs; active variants are pinned
+  --variants <ids>  Comma-separated variant IDs
+  --json            Print machine-readable output
+  --env <env>       Environment (production|stage|local)
+  --local           Shortcut for --env local
+`);
+}
 function printRotationHelp() {
+	if (!isCliRotationEnabled()) {
+		console.log(rotationDisabledMessage());
+		return;
+	}
 	console.log(`
 Usage:
   makefx rotation --variant <variant-id> [--config 4-directional|8-directional|turnaround]
@@ -24216,7 +26408,7 @@ Options:
   --subject <text>   Optional subject description for consistency prompts
   --aspect <ratio>   Optional generation aspect ratio
   --mode <mode>      sequential or single-shot (default: sequential)
-  --no-style         Disable the space style anchor
+  --no-style         Disable style preset injection for this pipeline
   --detach           Return after the pipeline starts instead of waiting for completion
   --timeout <sec>    Override the pipeline wait timeout
   --json             Print machine-readable output
@@ -24238,7 +26430,7 @@ Options:
   --seed-variant <id> Optional completed image variant to place at the center (sequential mode only)
   --aspect <ratio>    Optional generation aspect ratio
   --mode <mode>       sequential or single-shot (default: sequential)
-  --no-style          Disable the space style anchor
+  --no-style          Disable style preset injection for this pipeline
   --detach            Return after the pipeline starts instead of waiting for completion
   --timeout <sec>     Override the pipeline wait timeout
   --json              Print machine-readable output
@@ -24266,6 +26458,41 @@ Usage:
   makefx assets download <variant-id|legacy-image-key> -o output-file
 `);
 }
+function printUsageHelp() {
+	console.log(`
+Usage:
+  makefx usage [summary] [--space <id>] [--from <date>] [--to <date>]
+  makefx usage --json
+
+Options:
+  --space <id>      Target space ID; defaults from the initialized project
+  --from <date>     Include usage at or after this date or ISO timestamp
+  --to <date>       Include usage at or before this date or ISO timestamp
+  --json            Print machine-readable output
+  --env <env>       Environment (production|stage|local)
+  --local           Shortcut for --env local
+`);
+}
+function printSpendHelp() {
+	console.log(`
+Usage:
+  makefx spend [summary] [--from <date>] [--to <date>]
+  makefx spend --user-id <id> --provider <name> --media-kind <image|audio|video>
+  makefx spend --json
+
+Options:
+  --from <date>        Include provider cost at or after this date or ISO timestamp
+  --to <date>          Include provider cost at or before this date or ISO timestamp
+  --user-id <id>       Filter to one user ID
+  --space-id <id>      Filter to one space ID
+  --space <id>         Alias for --space-id
+  --provider <name>    Filter to one provider
+  --media-kind <kind>  Filter to image, audio, or video provider cost
+  --json               Print machine-readable output
+  --env <env>          Environment (production|stage|local)
+  --local              Shortcut for --env local
+`);
+}
 async function dispatchCommand(command, parsed) {
 	switch (command) {
 		case "init":
@@ -24313,10 +26540,20 @@ async function dispatchCommand(command, parsed) {
 		case "assets":
 			await handleAssets(parsed);
 			break;
+		case "usage":
+			await handleUsage(parsed);
+			break;
+		case "spend":
+			await handleSpend(parsed);
+			break;
 		case "variants":
 		case "variant":
 			await handleVariants(parsed);
 			break;
+		case "styles":
+		case "style":
+			await handleStyles(parsed);
+			break;
 		case "rotation":
 			await handleRotation(parsed);
 			break;