makefx 0.1.3 → 0.2.0

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$13 = {
 	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$13) {
 	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,7 @@ var EXT_TO_MEDIA_TYPE = {
 	}
 };
 var ALLOWED_EXTENSIONS$1 = Object.keys(EXT_TO_MEDIA_TYPE).sort();
-var defaultDeps$8 = {
+var defaultDeps$12 = {
 	loadConfig: loadStoredConfig,
 	loadProjectConfig,
 	resolveBaseUrl,
@@ -5052,18 +5071,17 @@ 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$12();
 		process$1.exitCode = 1;
 	}
 }
-async function executeUpload(parsed, deps = defaultDeps$8) {
+async function executeUpload(parsed, deps = defaultDeps$12) {
 	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");
@@ -5079,7 +5097,7 @@ async function executeUpload(parsed, deps = defaultDeps$8) {
 	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`);
 		const fileBuffer = await deps.readFile(filePath);
 		const fileName = path.basename(filePath);
 		const formData = new FormData();
@@ -5090,7 +5108,6 @@ async function executeUpload(parsed, deps = defaultDeps$8) {
 		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}`);
@@ -5150,7 +5167,7 @@ function resolveMediaType(ext, requestedMediaKind) {
 	if (requestedMediaKind && requestedMediaKind !== mediaType.mediaKind) throw new Error(`--media-kind ${requestedMediaKind} does not match ${ext} (${mediaType.mediaKind})`);
 	return mediaType;
 }
-function printUsage$9() {
+function printUsage$12() {
 	console.log(`
 Usage:
   makefx upload <file> --asset <id> [--space <id>]     Upload media to existing asset
@@ -5162,7 +5179,6 @@ 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
   --env <env>       Environment (production|stage|local)
   --local           Shortcut for --env local
 
@@ -5171,7 +5187,877 @@ Examples:
   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
+`);
+}
+//#endregion
+//#region src/cli/commands/import.ts
+var defaultDeps$11 = {
+	loadConfig: loadStoredConfig,
+	loadProjectConfig,
+	resolveBaseUrl,
+	fetch,
+	readFile,
+	stat,
+	print: console.log
+};
+async function handleImport(parsed) {
+	try {
+		await executeImport(parsed);
+	} catch (error) {
+		console.error(error instanceof Error ? `Error: ${error.message}` : "Error: Import failed");
+		printUsage$11();
+		process$1.exitCode = 1;
+	}
+}
+async function executeImport(parsed, deps = defaultDeps$11) {
+	const manifestPath = parsed.positionals[0] || parsed.options.manifest;
+	if (!manifestPath || manifestPath === "true") throw new Error("Manifest path is required: makefx import <manifest.json>");
+	const ctx = await buildContext$8(parsed, deps);
+	const manifest = await readManifest(manifestPath, deps);
+	await validateLocalRecords(manifest.records, deps);
+	const plan = validateManifestPlan(manifest, await fetchSpaceState(ctx, deps));
+	const uploadOrder = buildUploadOrder(manifest.records);
+	if (parsed.options["dry-run"] === "true" || parsed.options.dryRun === "true") {
+		const result = {
+			dryRun: true,
+			records: uploadOrder.map((record) => ({
+				key: record.localKey,
+				file: record.displayPath,
+				target: record.assetId ?? `new:${record.assetName}`,
+				lineageInputs: record.lineage.length
+			})),
+			collections: plan.collections.map((collection) => ({
+				name: collection.name,
+				create: collection.create
+			})),
+			collectionItems: plan.collectionItems.length,
+			relations: plan.relations.length,
+			compositions: plan.compositions.map((composition) => ({
+				name: composition.name,
+				create: composition.create
+			})),
+			compositionItems: plan.compositionItems.length,
+			stylePresets: plan.stylePresets.map((preset) => ({
+				name: preset.name,
+				action: preset.action
+			}))
+		};
+		printResult$1(result, parsed, deps);
+		return result;
+	}
+	const uploadedByKey = /* @__PURE__ */ new Map();
+	const imported = [];
+	const jsonOutput = parsed.options.json === "true";
+	for (const record of uploadOrder) {
+		const lineage = record.lineage.map((input) => ({
+			parentVariantId: input.sourceVariantId ?? uploadedByKey.get(input.sourceFile)?.variantId,
+			relationType: input.relationType
+		}));
+		if (lineage.find((input) => !input.parentVariantId)) throw new Error(`Could not resolve same-batch lineage for ${record.localKey}`);
+		const response = await uploadRecord(ctx, deps, record, lineage, { quiet: jsonOutput });
+		uploadedByKey.set(record.localKey, {
+			assetId: response.variant.asset_id,
+			variantId: response.variant.id
+		});
+		imported.push({
+			key: record.localKey,
+			file: record.displayPath,
+			assetId: response.variant.asset_id,
+			variantId: response.variant.id,
+			lineageIds: (response.lineage ?? []).map((lineageRecord) => lineageRecord.id)
+		});
+	}
+	const result = {
+		dryRun: false,
+		records: imported,
+		...await applyOrganizationPlan(ctx, deps, plan, uploadedByKey)
+	};
+	printResult$1(result, parsed, deps);
+	return result;
+}
+async function buildContext$8(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 readManifest(manifestPath, deps) {
+	const manifestText = await deps.readFile(manifestPath, "utf8");
+	const manifestDir = path.dirname(path.resolve(manifestPath));
+	let parsed;
+	try {
+		parsed = JSON.parse(manifestText);
+	} catch (error) {
+		throw new Error(`Manifest is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const root = Array.isArray(parsed) ? {} : parsed;
+	const rawRecords = Array.isArray(parsed) ? parsed : parsed && typeof parsed === "object" ? root.records ?? root.files : null;
+	if (!Array.isArray(rawRecords)) throw new Error("Manifest must be an array or contain a records/files array");
+	const records = rawRecords.map((raw, index) => normalizeRecord(raw, index, manifestDir));
+	const keys = /* @__PURE__ */ new Set();
+	for (const record of records) {
+		if (keys.has(record.localKey)) throw new Error(`Duplicate local key in manifest: ${record.localKey}`);
+		keys.add(record.localKey);
+	}
+	return {
+		records,
+		collections: normalizeCollections(readArray(root.collections, "collections"), false),
+		styleCollections: normalizeStyleCollections(readArray(root.styleCollections, "styleCollections")),
+		collectionItems: [...records.flatMap((record) => record.collectionItems), ...normalizeCollectionItems(readArray(root.collectionItems, "collectionItems"), "collectionItems")],
+		relations: [...records.flatMap((record) => record.relations), ...normalizeRelations(readArray(root.relations, "relations"), "relations")],
+		compositions: normalizeCompositions(readArray(root.compositions, "compositions")),
+		compositionItems: [...records.flatMap((record) => record.compositionItems), ...normalizeCompositionItems(readArray(root.compositionItems, "compositionItems"), "compositionItems")],
+		stylePresets: normalizeStylePresets(readArray(root.stylePresets, "stylePresets"))
+	};
+}
+function normalizeRecord(raw, index, manifestDir) {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error(`Record ${index + 1} must be an object`);
+	const record = raw;
+	const displayPath = record.file ?? record.path;
+	if (!displayPath) throw new Error(`Record ${index + 1} is missing file`);
+	const filePath = path.resolve(manifestDir, displayPath);
+	const mediaType = resolveMediaType(path.extname(filePath).toLowerCase(), record.mediaKind);
+	const assetId = record.assetId ?? record.targetAssetId;
+	const assetName = record.assetName ?? record.name;
+	if (assetId && assetName) throw new Error(`Record ${index + 1} must set either assetId or name, not both`);
+	if (!assetId && !assetName) throw new Error(`Record ${index + 1} must set assetId for an existing asset or name for a new asset`);
+	const lineage = normalizeLineage(record.lineage ?? [], index);
+	const activeVariantBehavior = normalizeActiveBehavior(record.activeVariantBehavior, index);
+	const providerMetadata = record.providerMetadata ?? record.provider_metadata;
+	const generationProvenance = record.generationProvenance ?? record.generation_provenance ?? {};
+	validateObjectField(providerMetadata, `Record ${index + 1} providerMetadata`);
+	validateObjectField(generationProvenance, `Record ${index + 1} generationProvenance`);
+	const localKey = record.localKey ?? record.key ?? displayPath;
+	return {
+		index,
+		localKey,
+		filePath,
+		displayPath,
+		fileName: path.basename(filePath),
+		assetName,
+		assetType: record.assetType ?? record.type ?? "character",
+		assetId,
+		mediaKind: mediaType.mediaKind,
+		mimeType: mediaType.mimeType,
+		activeVariantBehavior,
+		prompt: record.prompt,
+		model: record.model,
+		provider: record.provider,
+		providerMetadata,
+		generationProvenance,
+		lineage,
+		collectionItems: normalizeCollectionItems([...readArray(record.collections, `Record ${index + 1} collections`), ...readArray(record.collectionItems, `Record ${index + 1} collectionItems`)], `Record ${index + 1} collections`, localKey),
+		relations: normalizeRelations(readArray(record.relations, `Record ${index + 1} relations`), `Record ${index + 1} relations`, localKey),
+		compositionItems: normalizeCompositionItems(readArray(record.compositionItems, `Record ${index + 1} compositionItems`), `Record ${index + 1} compositionItems`, localKey),
+		styleCollections: normalizeStyleCollections(readArray(record.styleCollections, `Record ${index + 1} styleCollections`), localKey)
+	};
+}
+function readArray(value, label) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value)) throw new Error(`${label} must be an array`);
+	return value;
+}
+function normalizeLineage(inputs, recordIndex) {
+	if (!Array.isArray(inputs)) throw new Error(`Record ${recordIndex + 1} lineage must be an array`);
+	return inputs.map((input, index) => {
+		if (!input || typeof input !== "object" || Array.isArray(input)) throw new Error(`Record ${recordIndex + 1} lineage[${index}] must be an object`);
+		const sourceVariantId = input.sourceVariantId ?? input.parentVariantId;
+		if (sourceVariantId && input.sourceFile || !sourceVariantId && !input.sourceFile) throw new Error(`Record ${recordIndex + 1} lineage[${index}] must set exactly one of sourceVariantId or sourceFile`);
+		if (input.relationType !== "derived" && input.relationType !== "refined" && input.relationType !== "forked") throw new Error(`Record ${recordIndex + 1} lineage[${index}] relationType must be derived, refined, or forked`);
+		return {
+			relationType: input.relationType,
+			...sourceVariantId ? { sourceVariantId } : { sourceFile: input.sourceFile }
+		};
+	});
+}
+function normalizeCollections(inputs, styleOnly) {
+	return inputs.map((input, index) => {
+		const collection = requireObject(input, `collections[${index}]`);
+		const name = collection.name ?? collection.collectionName ?? collection.collection;
+		if (!name || typeof name !== "string") throw new Error(`collections[${index}] name is required`);
+		if (collection.description !== void 0 && collection.description !== null && typeof collection.description !== "string") throw new Error(`collections[${index}] description must be a string or null`);
+		validateSortIndex(collection.sortIndex, `collections[${index}] sortIndex`);
+		return {
+			key: collection.id ?? name,
+			name,
+			description: collection.description,
+			sortIndex: collection.sortIndex,
+			create: styleOnly || collection.create === true || collection.createIfMissing === true
+		};
+	});
+}
+function normalizeStyleCollections(inputs, recordKey) {
+	return inputs.map((input, index) => {
+		if (typeof input === "string") return {
+			key: input,
+			name: input,
+			create: false,
+			refs: recordKey ? [recordKey] : []
+		};
+		const collection = requireObject(input, labelFor("styleCollections", index, recordKey));
+		const name = collection.name ?? collection.collectionName ?? collection.collection;
+		if (!name || typeof name !== "string") throw new Error(`${labelFor("styleCollections", index, recordKey)} name is required`);
+		validateSortIndex(collection.sortIndex, `${labelFor("styleCollections", index, recordKey)} sortIndex`);
+		const refs = [
+			...collection.refs ?? [],
+			...collection.records ?? [],
+			...recordKey ? [recordKey] : []
+		];
+		if (!refs.every((ref) => typeof ref === "string" && ref.trim())) throw new Error(`${labelFor("styleCollections", index, recordKey)} refs must be strings`);
+		return {
+			key: collection.id ?? name,
+			name,
+			description: collection.description,
+			sortIndex: collection.sortIndex,
+			create: collection.create === true || collection.createIfMissing === true,
+			refs
+		};
+	});
+}
+function normalizeCollectionItems(inputs, label, defaultRecordKey) {
+	return inputs.map((input, index) => {
+		const item = requireObject(input, `${label}[${index}]`);
+		const collectionName = item.collectionName ?? item.collection ?? item.collectionId;
+		if (!collectionName || typeof collectionName !== "string") throw new Error(`${label}[${index}] collection is required`);
+		if (item.role !== void 0 && typeof item.role !== "string") throw new Error(`${label}[${index}] role must be a string`);
+		const subjectType = normalizeSubjectType(item.subjectType ?? (item.variantId ? "variant" : "asset"), `${label}[${index}] subjectType`);
+		const recordKey = item.recordKey ?? item.sourceFile ?? defaultRecordKey;
+		validateSortIndex(item.sortIndex, `${label}[${index}] sortIndex`);
+		if (item.pinnedVariantId !== void 0 && item.pinnedVariantId !== null && typeof item.pinnedVariantId !== "string") throw new Error(`${label}[${index}] pinnedVariantId must be a string or null`);
+		return {
+			id: item.id,
+			collectionName,
+			role: item.role ?? "member",
+			subjectType,
+			assetId: item.assetId,
+			variantId: item.variantId,
+			recordKey,
+			pinnedVariantId: item.pinnedVariantId,
+			pinnedVariantBehavior: normalizePinnedVariantBehavior(item.pinnedVariantBehavior, `${label}[${index}] pinnedVariantBehavior`),
+			sortIndex: item.sortIndex
+		};
+	});
+}
+function normalizeRelations(inputs, label, defaultSubjectRecordKey) {
+	return inputs.map((input, index) => {
+		const relation = requireObject(input, `${label}[${index}]`);
+		const subject = relation.subject ? normalizeSubject(relation.subject, `${label}[${index}] subject`) : normalizeSubject({
+			subjectType: relation.subjectType,
+			assetId: relation.subjectAssetId,
+			variantId: relation.subjectVariantId,
+			recordKey: defaultSubjectRecordKey
+		}, `${label}[${index}] subject`);
+		const object = normalizeSubject(relation.object ?? relation.target ?? {
+			subjectType: relation.objectType,
+			assetId: relation.objectAssetId,
+			variantId: relation.objectVariantId
+		}, `${label}[${index}] object`);
+		const relationType = normalizeRelationType(relation.relationType, `${label}[${index}] relationType`);
+		validateObjectField(relation.metadata, `${label}[${index}] metadata`);
+		validateSortIndex(relation.sortIndex, `${label}[${index}] sortIndex`);
+		if (relation.label !== void 0 && relation.label !== null && typeof relation.label !== "string") throw new Error(`${label}[${index}] label must be a string or null`);
+		if (relation.context !== void 0 && relation.context !== null && typeof relation.context !== "string" && (typeof relation.context !== "object" || Array.isArray(relation.context))) throw new Error(`${label}[${index}] context must be a string, object, or null`);
+		return {
+			id: relation.id,
+			subject,
+			object,
+			relationType,
+			label: relation.label,
+			context: relation.context,
+			metadata: relation.metadata,
+			sortIndex: relation.sortIndex
+		};
+	});
+}
+function normalizeCompositions(inputs) {
+	return inputs.map((input, index) => {
+		const composition = requireObject(input, `compositions[${index}]`);
+		const name = composition.name ?? composition.compositionName ?? composition.composition;
+		if (!name || typeof name !== "string") throw new Error(`compositions[${index}] name is required`);
+		if (composition.description !== void 0 && composition.description !== null && typeof composition.description !== "string") throw new Error(`compositions[${index}] description must be a string or null`);
+		validateObjectField(composition.metadata, `compositions[${index}] metadata`);
+		validateSortIndex(composition.sortIndex, `compositions[${index}] sortIndex`);
+		const output = composition.output ? normalizeSubject(composition.output, `compositions[${index}] output`) : composition.outputRecordKey || composition.outputAssetId || composition.outputVariantId ? normalizeSubject({
+			subjectType: composition.outputVariantId || composition.outputRecordKey ? "variant" : "asset",
+			assetId: composition.outputAssetId ?? void 0,
+			variantId: composition.outputVariantId ?? void 0,
+			recordKey: composition.outputRecordKey
+		}, `compositions[${index}] output`) : void 0;
+		return {
+			key: composition.id ?? name,
+			name,
+			description: composition.description,
+			status: normalizeCompositionStatus(composition.status, `compositions[${index}] status`),
+			output,
+			metadata: composition.metadata,
+			sortIndex: composition.sortIndex,
+			create: composition.create === true || composition.createIfMissing === true
+		};
+	});
+}
+function normalizeCompositionItems(inputs, label, defaultRecordKey) {
+	return inputs.map((input, index) => {
+		const item = requireObject(input, `${label}[${index}]`);
+		const compositionName = item.compositionName ?? item.composition ?? item.compositionId;
+		if (!compositionName || typeof compositionName !== "string") throw new Error(`${label}[${index}] composition is required`);
+		const role = normalizeCompositionItemRole(item.role, `${label}[${index}] role`);
+		validateObjectField(item.metadata, `${label}[${index}] metadata`);
+		validateSortIndex(item.sortIndex, `${label}[${index}] sortIndex`);
+		if (item.label !== void 0 && item.label !== null && typeof item.label !== "string") throw new Error(`${label}[${index}] label must be a string or null`);
+		return {
+			id: item.id,
+			compositionName,
+			role,
+			label: item.label,
+			assetId: item.assetId,
+			variantId: item.variantId,
+			recordKey: item.recordKey ?? item.sourceFile ?? defaultRecordKey,
+			metadata: item.metadata,
+			sortIndex: item.sortIndex
+		};
+	});
+}
+function normalizeStylePresets(inputs) {
+	return inputs.map((input, index) => {
+		const preset = requireObject(input, `stylePresets[${index}]`);
+		const name = preset.name ?? preset.presetName;
+		if (!name || typeof name !== "string") throw new Error(`stylePresets[${index}] name is required`);
+		const stylePrompt = preset.stylePrompt ?? preset.prompt;
+		if (stylePrompt !== void 0 && typeof stylePrompt !== "string") throw new Error(`stylePresets[${index}] stylePrompt must be a string`);
+		if (preset.description !== void 0 && preset.description !== null && typeof preset.description !== "string") throw new Error(`stylePresets[${index}] description must be a string or null`);
+		if ([
+			preset.create,
+			preset.update,
+			preset.upsert
+		].filter((value) => value === true).length !== 1) throw new Error(`stylePresets[${index}] must set exactly one of create, update, or upsert`);
+		return {
+			id: preset.id,
+			name,
+			description: preset.description,
+			stylePrompt,
+			collectionName: preset.collectionName ?? preset.collection ?? void 0,
+			collectionId: preset.collectionId,
+			enabled: preset.enabled,
+			isDefault: preset.isDefault ?? preset.default,
+			action: preset.create ? "create" : preset.update ? "update" : "upsert"
+		};
+	});
+}
+function normalizeSubject(input, label) {
+	const subjectType = normalizeSubjectType(input.subjectType ?? input.type ?? (input.assetId ? "asset" : "variant"), `${label} subjectType`);
+	const recordKey = input.recordKey ?? input.sourceFile;
+	if (subjectType === "asset" && input.variantId && !recordKey && !input.assetId) throw new Error(`${label} asset subject must use assetId or recordKey`);
+	if (subjectType === "variant" && input.assetId && !input.variantId && !recordKey) throw new Error(`${label} variant subject must use variantId or recordKey`);
+	return {
+		subjectType,
+		assetId: input.assetId,
+		variantId: input.variantId,
+		recordKey
+	};
+}
+function normalizeSubjectType(value, label) {
+	if (value === "asset" || value === "variant") return value;
+	throw new Error(`${label} must be asset or variant`);
+}
+function normalizeRelationType(value, label) {
+	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 Error(`${label} is invalid`);
+}
+function normalizeCompositionItemRole(value, label) {
+	if ([
+		"output",
+		"background",
+		"character",
+		"prop",
+		"style_ref",
+		"overlay",
+		"map",
+		"thumbnail",
+		"custom"
+	].includes(value)) return value;
+	throw new Error(`${label} is invalid`);
+}
+function normalizeCompositionStatus(value, label) {
+	if (value === void 0) return void 0;
+	if (value === "draft" || value === "final") return value;
+	throw new Error(`${label} must be draft or final`);
+}
+function normalizePinnedVariantBehavior(value, label) {
+	if (!value || value === "imported") return "imported";
+	if (value === "none" || value === "unpin") return "none";
+	throw new Error(`${label} must be imported or none`);
+}
+function requireObject(value, label) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object`);
+	return value;
+}
+function validateSortIndex(value, label) {
+	if (value !== void 0 && !Number.isInteger(value)) throw new Error(`${label} must be an integer`);
+}
+function labelFor(section, index, recordKey) {
+	return recordKey ? `Record ${recordKey} ${section}[${index}]` : `${section}[${index}]`;
+}
+function normalizeActiveBehavior(value, recordIndex) {
+	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 Error(`Record ${recordIndex + 1} activeVariantBehavior must be if-missing, set-active, or keep`);
+}
+function validateObjectField(value, label) {
+	if (value === void 0) return;
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object`);
+}
+async function validateLocalRecords(records, deps) {
+	for (const record of records) {
+		let fileStat;
+		try {
+			fileStat = await deps.stat(record.filePath);
+		} catch (error) {
+			if (error.code === "ENOENT") throw new Error(`File not found for ${record.localKey}: ${record.displayPath}`);
+			throw error;
+		}
+		if (!fileStat.isFile()) throw new Error(`Manifest file is not a file for ${record.localKey}: ${record.displayPath}`);
+		if (fileStat.size > 10485760) throw new Error(`File too large for ${record.localKey} (${(fileStat.size / 1024 / 1024).toFixed(2)}MB). Maximum size: 10MB`);
+	}
+}
+async function fetchSpaceState(ctx, deps) {
+	const [assetsData, collectionsData, compositionsData, stylePresetsData] = await Promise.all([
+		fetchJson$1(ctx, deps, `/api/spaces/${ctx.spaceId}/assets`),
+		fetchJson$1(ctx, deps, `/api/spaces/${ctx.spaceId}/collections`),
+		fetchJson$1(ctx, deps, `/api/spaces/${ctx.spaceId}/compositions`),
+		fetchJson$1(ctx, deps, `/api/spaces/${ctx.spaceId}/style-presets`)
+	]);
+	const assets = assetsData.assets ?? [];
+	const variantsById = /* @__PURE__ */ new Map();
+	for (const asset of assets) {
+		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 {
+		assets,
+		variantsById,
+		collections: collectionsData.collections ?? [],
+		compositions: compositionsData.compositions ?? [],
+		stylePresets: stylePresetsData.presets ?? []
+	};
+}
+function validateSpaceReferences(records, state) {
+	const assetsById = new Map(state.assets.map((asset) => [asset.id, asset]));
+	const recordsByKey = new Map(records.map((record) => [record.localKey, record]));
+	for (const record of records) {
+		if (record.assetId) {
+			const asset = assetsById.get(record.assetId);
+			if (!asset) throw new Error(`Target asset not found for ${record.localKey}: ${record.assetId}`);
+			if (asset.media_kind && asset.media_kind !== record.mediaKind) throw new Error(`Target asset ${record.assetId} is ${asset.media_kind}, but ${record.localKey} is ${record.mediaKind}`);
+		}
+		for (const lineage of record.lineage) {
+			if (lineage.sourceVariantId && !state.variantsById.has(lineage.sourceVariantId)) throw new Error(`Source variant not found in space for ${record.localKey}: ${lineage.sourceVariantId}`);
+			if (lineage.sourceFile) {
+				const sourceRecord = recordsByKey.get(lineage.sourceFile);
+				if (!sourceRecord) throw new Error(`Source file key not found for ${record.localKey}: ${lineage.sourceFile}`);
+				if (sourceRecord.localKey === record.localKey) throw new Error(`Record ${record.localKey} cannot use itself as a lineage source`);
+			}
+		}
+	}
+}
+function validateManifestPlan(manifest, state) {
+	validateSpaceReferences(manifest.records, state);
+	const recordsByKey = new Map(manifest.records.map((record) => [record.localKey, record]));
+	const collectionsByName = new Map(state.collections.map((collection) => [collection.name, collection]));
+	const compositionsByName = new Map(state.compositions.map((composition) => [composition.name, composition]));
+	const stylePresetsByName = new Map(state.stylePresets.map((preset) => [preset.name, preset]));
+	const stylePresetsById = new Map(state.stylePresets.map((preset) => [preset.id, preset]));
+	const collections = dedupeCollections([
+		...manifest.collections,
+		...manifest.styleCollections,
+		...manifest.records.flatMap((record) => record.styleCollections)
+	]);
+	const collectionItems = [
+		...manifest.collectionItems,
+		...manifest.styleCollections.flatMap((collection) => styleCollectionItems(collection)),
+		...manifest.records.flatMap((record) => record.styleCollections.flatMap((collection) => styleCollectionItems(collection)))
+	];
+	const compositions = dedupeCompositions(manifest.compositions);
+	const compositionItems = manifest.compositionItems;
+	for (const collection of collections) if (!collectionsByName.has(collection.name) && !collection.create) throw new Error(`Collection not found: ${collection.name}. Add it to manifest collections with create: true.`);
+	for (const item of collectionItems) {
+		if (!collectionsByName.has(item.collectionName) && !collections.some((collection) => collection.name === item.collectionName && collection.create)) throw new Error(`Collection not found for collection item: ${item.collectionName}`);
+		validateCollectionSubject(item, recordsByKey, state);
+	}
+	for (const relation of manifest.relations) {
+		validateSubjectReference(relation.subject, recordsByKey, state, "Relation subject");
+		validateSubjectReference(relation.object, recordsByKey, state, "Relation object");
+	}
+	for (const composition of compositions) {
+		if (!compositionsByName.has(composition.name) && !composition.create) throw new Error(`Composition not found: ${composition.name}. Add it to manifest compositions with create: true.`);
+		if (composition.output) {
+			validateSubjectReference(composition.output, recordsByKey, state, `Composition ${composition.name} output`);
+			if (composition.output.subjectType !== "variant") throw new Error(`Composition ${composition.name} output must reference a variant`);
+		}
+	}
+	for (const item of compositionItems) {
+		if (!compositionsByName.has(item.compositionName) && !compositions.some((composition) => composition.name === item.compositionName && composition.create)) throw new Error(`Composition not found for composition item: ${item.compositionName}`);
+		if (item.recordKey) {
+			if (!recordsByKey.has(item.recordKey)) throw new Error(`Composition item references unknown same-batch record: ${item.recordKey}`);
+		} else if (!item.variantId) throw new Error(`Composition item for ${item.compositionName} must set variantId or recordKey`);
+		else if (!state.variantsById.has(item.variantId)) throw new Error(`Composition item references unknown variant: ${item.variantId}`);
+		if (item.assetId && !state.assets.some((asset) => asset.id === item.assetId)) throw new Error(`Composition item references unknown asset: ${item.assetId}`);
+	}
+	for (const preset of manifest.stylePresets) {
+		const existingPresetById = preset.id ? stylePresetsById.get(preset.id) : void 0;
+		const existingPresetByName = stylePresetsByName.get(preset.name);
+		const existingPreset = preset.id ? existingPresetById : existingPresetByName;
+		const createConflict = preset.id ? existingPresetById ?? existingPresetByName : existingPresetByName;
+		if (preset.action === "create" && createConflict) throw new Error(`Style preset already exists: ${preset.name}`);
+		if (preset.action === "update" && !existingPreset) throw new Error(`Style preset not found for update: ${preset.id ?? preset.name}`);
+		if (preset.collectionName) {
+			const willCreate = collections.some((collection) => collection.name === preset.collectionName && collection.create);
+			if (!collectionsByName.has(preset.collectionName) && !willCreate) throw new Error(`Style preset ${preset.name} references missing collection: ${preset.collectionName}`);
+		}
+	}
+	return {
+		...manifest,
+		collections,
+		collectionItems,
+		compositions,
+		compositionItems
+	};
+}
+function dedupeCollections(collections) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const collection of collections) {
+		const existing = byName.get(collection.name);
+		byName.set(collection.name, {
+			key: collection.key,
+			name: collection.name,
+			description: collection.description ?? existing?.description,
+			sortIndex: collection.sortIndex ?? existing?.sortIndex,
+			create: Boolean(existing?.create || collection.create)
+		});
+	}
+	return [...byName.values()];
+}
+function dedupeCompositions(compositions) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const composition of compositions) {
+		const existing = byName.get(composition.name);
+		byName.set(composition.name, {
+			...existing,
+			...composition,
+			create: Boolean(existing?.create || composition.create)
+		});
+	}
+	return [...byName.values()];
+}
+function styleCollectionItems(collection) {
+	return collection.refs.map((recordKey, index) => ({
+		collectionName: collection.name,
+		role: "style_ref",
+		subjectType: "asset",
+		recordKey,
+		pinnedVariantBehavior: "imported",
+		sortIndex: index
+	}));
+}
+function validateCollectionSubject(item, recordsByKey, state) {
+	if (item.recordKey) {
+		if (!recordsByKey.has(item.recordKey)) throw new Error(`Collection item references unknown same-batch record: ${item.recordKey}`);
+		return;
+	}
+	if (item.subjectType === "asset") {
+		if (!item.assetId) throw new Error(`Collection item for ${item.collectionName} must set assetId or recordKey`);
+		if (!state.assets.some((asset) => asset.id === item.assetId)) throw new Error(`Collection item references unknown asset: ${item.assetId}`);
+		if (item.pinnedVariantId && !state.variantsById.has(item.pinnedVariantId)) throw new Error(`Collection item references unknown pinned variant: ${item.pinnedVariantId}`);
+		return;
+	}
+	if (!item.variantId) throw new Error(`Collection item for ${item.collectionName} must set variantId or recordKey`);
+	if (!state.variantsById.has(item.variantId)) throw new Error(`Collection item references unknown variant: ${item.variantId}`);
+}
+function validateSubjectReference(subject, recordsByKey, state, label) {
+	if (subject.recordKey) {
+		if (!recordsByKey.has(subject.recordKey)) throw new Error(`${label} references unknown same-batch record: ${subject.recordKey}`);
+		return;
+	}
+	if (subject.subjectType === "asset") {
+		if (!subject.assetId) throw new Error(`${label} must set assetId or recordKey`);
+		if (!state.assets.some((asset) => asset.id === subject.assetId)) throw new Error(`${label} references unknown asset: ${subject.assetId}`);
+		return;
+	}
+	if (!subject.variantId) throw new Error(`${label} must set variantId or recordKey`);
+	if (!state.variantsById.has(subject.variantId)) throw new Error(`${label} references unknown variant: ${subject.variantId}`);
+}
+function buildUploadOrder(records) {
+	const pending = new Map(records.map((record) => [record.localKey, record]));
+	const uploaded = /* @__PURE__ */ new Set();
+	const order = [];
+	while (pending.size > 0) {
+		let progressed = false;
+		for (const [key, record] of pending) {
+			if (!record.lineage.every((lineage) => !lineage.sourceFile || uploaded.has(lineage.sourceFile))) continue;
+			order.push(record);
+			uploaded.add(key);
+			pending.delete(key);
+			progressed = true;
+		}
+		if (!progressed) throw new Error(`Same-batch lineage contains a cycle or unresolved dependency: ${[...pending.keys()].join(", ")}`);
+	}
+	return order;
+}
+async function uploadRecord(ctx, deps, record, lineage, options) {
+	const fileBuffer = await deps.readFile(record.filePath);
+	const formData = new FormData();
+	formData.append("file", new Blob([fileBuffer], { type: record.mimeType }), record.fileName);
+	formData.append("operation", "import");
+	formData.append("mediaKind", record.mediaKind);
+	formData.append("assetType", record.assetType);
+	formData.append("activeVariantBehavior", record.activeVariantBehavior);
+	formData.append("generationProvenance", JSON.stringify(record.generationProvenance));
+	if (record.assetId) formData.append("assetId", record.assetId);
+	else formData.append("assetName", record.assetName);
+	if (record.prompt) formData.append("prompt", record.prompt);
+	if (record.model) formData.append("model", record.model);
+	if (record.provider) formData.append("provider", record.provider);
+	if (record.providerMetadata) formData.append("providerMetadata", JSON.stringify(record.providerMetadata));
+	if (lineage.length > 0) formData.append("lineage", JSON.stringify(lineage));
+	if (!options.quiet) deps.print(`Importing ${record.displayPath}...`);
+	const response = await deps.fetch(`${ctx.baseUrl}/api/spaces/${ctx.spaceId}/upload`, {
+		method: "POST",
+		headers: { Authorization: `Bearer ${ctx.accessToken}` },
+		body: formData
+	});
+	const data = await response.json();
+	if (!response.ok) throw new Error(`Import failed for ${record.localKey}: ${"error" in data ? data.error : response.statusText}`);
+	return data;
+}
+async function applyOrganizationPlan(ctx, deps, plan, uploadedByKey) {
+	const collectionIds = [];
+	const collectionItemIds = [];
+	const relationIds = [];
+	const compositionIds = [];
+	const compositionItemIds = [];
+	const stylePresetIds = [];
+	const collections = await fetchJson$1(ctx, deps, `/api/spaces/${ctx.spaceId}/collections`);
+	const collectionsByName = new Map((collections.collections ?? []).map((collection) => [collection.name, collection]));
+	for (const collection of plan.collections) if (!collectionsByName.has(collection.name) && collection.create) {
+		const created = await postJson(ctx, deps, `/api/spaces/${ctx.spaceId}/collections`, {
+			name: collection.name,
+			description: collection.description,
+			sortIndex: collection.sortIndex
+		});
+		collectionsByName.set(created.collection.name, created.collection);
+		collectionIds.push(created.collection.id);
+	}
+	for (const item of plan.collectionItems) {
+		const collection = collectionsByName.get(item.collectionName);
+		if (!collection) throw new Error(`Collection not found during import: ${item.collectionName}`);
+		const created = await postJson(ctx, deps, `/api/spaces/${ctx.spaceId}/collections/${encodeURIComponent(collection.id)}/items`, resolveCollectionItemRequest(item, uploadedByKey));
+		collectionItemIds.push(created.item.id);
+	}
+	for (const relation of plan.relations) {
+		const created = await postJson(ctx, deps, `/api/spaces/${ctx.spaceId}/relations`, {
+			id: relation.id,
+			subject: resolveSubject(relation.subject, uploadedByKey),
+			object: resolveSubject(relation.object, uploadedByKey),
+			relationType: relation.relationType,
+			label: relation.label,
+			context: relation.context,
+			metadata: relation.metadata,
+			sortIndex: relation.sortIndex
+		});
+		relationIds.push(created.relation.id);
+	}
+	const compositions = await fetchJson$1(ctx, deps, `/api/spaces/${ctx.spaceId}/compositions`);
+	const compositionsByName = new Map((compositions.compositions ?? []).map((composition) => [composition.name, composition]));
+	for (const composition of plan.compositions) if (!compositionsByName.has(composition.name) && composition.create) {
+		const output = composition.output ? resolveSubject(composition.output, uploadedByKey) : void 0;
+		const created = await postJson(ctx, deps, `/api/spaces/${ctx.spaceId}/compositions`, {
+			name: composition.name,
+			description: composition.description,
+			status: composition.status,
+			outputAssetId: output?.assetId,
+			outputVariantId: output?.variantId,
+			metadata: composition.metadata,
+			sortIndex: composition.sortIndex
+		});
+		compositionsByName.set(created.composition.name, created.composition);
+		compositionIds.push(created.composition.id);
+	}
+	for (const item of plan.compositionItems) {
+		const composition = compositionsByName.get(item.compositionName);
+		if (!composition) throw new Error(`Composition not found during import: ${item.compositionName}`);
+		const created = await postJson(ctx, deps, `/api/spaces/${ctx.spaceId}/compositions/${encodeURIComponent(composition.id)}/items`, resolveCompositionItemRequest(item, uploadedByKey));
+		compositionItemIds.push(created.item.id);
+	}
+	const presets = await fetchJson$1(ctx, deps, `/api/spaces/${ctx.spaceId}/style-presets`);
+	const presetsByName = new Map((presets.presets ?? []).map((preset) => [preset.name, preset]));
+	const presetsById = new Map((presets.presets ?? []).map((preset) => [preset.id, preset]));
+	for (const preset of plan.stylePresets) {
+		const collectionId = preset.collectionId === null ? null : preset.collectionId ?? (preset.collectionName ? collectionsByName.get(preset.collectionName)?.id : void 0);
+		if (preset.collectionName && collectionId === void 0) throw new Error(`Style preset ${preset.name} references missing collection during import: ${preset.collectionName}`);
+		const request = {
+			id: preset.id,
+			name: preset.name,
+			description: preset.description,
+			stylePrompt: preset.stylePrompt,
+			collectionId,
+			enabled: preset.enabled,
+			isDefault: preset.isDefault
+		};
+		const existing = preset.id ? presetsById.get(preset.id) : presetsByName.get(preset.name);
+		if (preset.action === "update" || preset.action === "upsert" && existing) {
+			const updated = await patchJson(ctx, deps, `/api/spaces/${ctx.spaceId}/style-presets/${encodeURIComponent(existing.id)}`, request);
+			stylePresetIds.push(updated.preset.id);
+			presetsByName.set(updated.preset.name, updated.preset);
+			presetsById.set(updated.preset.id, updated.preset);
+		} else {
+			const created = await postJson(ctx, deps, `/api/spaces/${ctx.spaceId}/style-presets`, request);
+			stylePresetIds.push(created.preset.id);
+			presetsByName.set(created.preset.name, created.preset);
+			presetsById.set(created.preset.id, created.preset);
+		}
+	}
+	return {
+		collectionIds,
+		collectionItemIds,
+		relationIds,
+		compositionIds,
+		compositionItemIds,
+		stylePresetIds
+	};
+}
+function resolveCollectionItemRequest(item, uploadedByKey) {
+	const subject = item.recordKey ? resolveSubject({
+		subjectType: item.subjectType,
+		recordKey: item.recordKey
+	}, uploadedByKey) : {
+		subjectType: item.subjectType,
+		assetId: item.assetId,
+		variantId: item.variantId
+	};
+	return {
+		id: item.id,
+		...subject,
+		role: item.role,
+		pinnedVariantId: item.pinnedVariantBehavior === "none" ? item.pinnedVariantId ?? null : item.pinnedVariantId ?? (item.recordKey ? uploadedByKey.get(item.recordKey).variantId : void 0),
+		sortIndex: item.sortIndex
+	};
+}
+function resolveCompositionItemRequest(item, uploadedByKey) {
+	const uploaded = item.recordKey ? uploadedByKey.get(item.recordKey) : void 0;
+	if (item.recordKey && !uploaded) throw new Error(`Could not resolve same-batch composition item: ${item.recordKey}`);
+	return {
+		id: item.id,
+		role: item.role,
+		label: item.label,
+		assetId: item.assetId ?? uploaded?.assetId,
+		variantId: item.variantId ?? uploaded.variantId,
+		metadata: item.metadata,
+		sortIndex: item.sortIndex
+	};
+}
+function resolveSubject(subject, uploadedByKey) {
+	if (!subject.recordKey) return {
+		subjectType: subject.subjectType,
+		assetId: subject.assetId,
+		variantId: subject.variantId
+	};
+	const uploaded = uploadedByKey.get(subject.recordKey);
+	if (!uploaded) throw new Error(`Could not resolve same-batch reference: ${subject.recordKey}`);
+	return subject.subjectType === "asset" ? {
+		subjectType: "asset",
+		assetId: uploaded.assetId
+	} : {
+		subjectType: "variant",
+		variantId: uploaded.variantId
+	};
+}
+async function postJson(ctx, deps, requestPath, json) {
+	return sendJson(ctx, deps, "POST", requestPath, json);
+}
+async function patchJson(ctx, deps, requestPath, json) {
+	return sendJson(ctx, deps, "PATCH", requestPath, json);
+}
+async function sendJson(ctx, deps, method, requestPath, json) {
+	const response = await deps.fetch(`${ctx.baseUrl}${requestPath}`, {
+		method,
+		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;
+}
+function stripUndefined(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
+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 printResult$1(result, parsed, deps) {
+	if (parsed.options.json === "true") {
+		deps.print(JSON.stringify(result, null, 2));
+		return;
+	}
+	if (result.dryRun) {
+		deps.print(`Dry run passed for ${result.records.length} import records.`);
+		const organizationCount = result.collections.length + result.collectionItems + result.relations + result.compositions.length + result.compositionItems + result.stylePresets.length;
+		if (organizationCount > 0) deps.print(`  Organization changes: ${organizationCount}`);
+		return;
+	}
+	deps.print(`Imported ${result.records.length} records.`);
+	for (const record of result.records) deps.print(`  ${record.key}: asset ${record.assetId}, variant ${record.variantId}`);
+	const organizationCount = result.collectionIds.length + result.collectionItemIds.length + result.relationIds.length + result.compositionIds.length + result.compositionItemIds.length + result.stylePresetIds.length;
+	if (organizationCount > 0) deps.print(`  Organization records: ${organizationCount}`);
+}
+function printUsage$11() {
+	console.log(`
+Usage:
+  makefx import <manifest.json> [--space <id>]
+  makefx import <manifest.json> --dry-run [--json]
+
+Manifest:
+  Top-level array, or { "records": [...] }. Each record sets file plus either
+  assetId for an existing asset or name for a new asset. Records can include
+  prompt, model, provider, providerMetadata, and generationProvenance for
+  immutable import provenance. Lineage entries use sourceVariantId or sourceFile
+  with relationType derived, refined, or forked; lineage is not editable
+  organization state. Optional collections, collectionItems, relations,
+  compositions, compositionItems, styleCollections, and stylePresets sections
+  organize imported records after upload. Style references are normal assets in
+  collections and presets point to those collections. Missing
+  collections/compositions are only created when their manifest entry sets
+  create: true.
 `);
 }
 //#endregion
@@ -19110,7 +19996,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 +20025,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 +20105,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,28 +20160,472 @@ 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 ProductionRecordSchema = object({
+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(),
-	production_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(),
-	asset_id: string$1(),
-	media_kind: MediaKindSchema,
-	shot_id: string$1().nullable(),
-	scene_label: string$1(),
-	timeline_start_ms: number$1().int().nonnegative(),
-	duration_ms: number$1().int().nonnegative().nullable(),
-	motion_prompt: string$1().nullable(),
-	source_refs: string$1(),
-	source_variant_ids: string$1(),
 	metadata: string$1(),
+	sort_index: number$1().int(),
 	created_by: string$1(),
 	created_at: number$1(),
 	updated_at: number$1()
-}).openapi("ProductionRecord");
+}).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(),
+	variant_id: string$1(),
+	asset_id: string$1(),
+	media_kind: MediaKindSchema,
+	shot_id: string$1().nullable(),
+	scene_label: string$1(),
+	timeline_start_ms: number$1().int().nonnegative(),
+	duration_ms: number$1().int().nonnegative().nullable(),
+	motion_prompt: string$1().nullable(),
+	source_refs: string$1(),
+	source_variant_ids: string$1(),
+	metadata: string$1(),
+	created_by: string$1(),
+	created_at: number$1(),
+	updated_at: number$1()
+}).openapi("ProductionRecord");
 var PlaceProductionRecordRequestSchema = object({
 	id: string$1().optional(),
 	productionId: string$1().min(1),
@@ -19413,7 +20777,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 +20792,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 +20845,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,6 +20886,217 @@ var apiEndpoints = {
 		paramsSchema: SpaceIdParamsSchema,
 		responseSchema: ListSpaceAssetsResponseSchema
 	},
+	"GET /api/spaces/:id/collections": {
+		method: "GET",
+		path: "/api/spaces/:id/collections",
+		paramsSchema: SpaceIdParamsSchema,
+		responseSchema: ListCollectionsResponseSchema
+	},
+	"POST /api/spaces/:id/collections": {
+		method: "POST",
+		path: "/api/spaces/:id/collections",
+		paramsSchema: SpaceIdParamsSchema,
+		jsonSchema: UpsertCollectionRequestSchema,
+		responseSchema: CollectionResponseSchema
+	},
+	"PATCH /api/spaces/:id/collections/:collectionId": {
+		method: "PATCH",
+		path: "/api/spaces/:id/collections/:collectionId",
+		paramsSchema: CollectionIdParamsSchema,
+		jsonSchema: UpdateCollectionRequestSchema,
+		responseSchema: CollectionResponseSchema
+	},
+	"DELETE /api/spaces/:id/collections/:collectionId": {
+		method: "DELETE",
+		path: "/api/spaces/:id/collections/:collectionId",
+		paramsSchema: CollectionIdParamsSchema,
+		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/collections/:collectionId/items": {
+		method: "POST",
+		path: "/api/spaces/:id/collections/:collectionId/items",
+		paramsSchema: CollectionIdParamsSchema,
+		jsonSchema: UpsertCollectionItemRequestSchema,
+		responseSchema: CollectionItemResponseSchema
+	},
+	"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/collections/:collectionId/items/reorder": {
+		method: "POST",
+		path: "/api/spaces/:id/collections/:collectionId/items/reorder",
+		paramsSchema: CollectionIdParamsSchema,
+		jsonSchema: ReorderItemsRequestSchema,
+		responseSchema: ListCollectionItemsResponseSchema
+	},
+	"DELETE /api/spaces/:id/collections/:collectionId/items/:itemId": {
+		method: "DELETE",
+		path: "/api/spaces/:id/collections/:collectionId/items/:itemId",
+		paramsSchema: CollectionItemParamsSchema,
+		responseSchema: SuccessResponseSchema
+	},
+	"GET /api/spaces/:id/style-reference-collections": {
+		method: "GET",
+		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",
@@ -19598,13 +21193,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 +21236,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 +21278,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 +21291,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 +21311,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 +21325,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 +21403,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 +21462,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 +21481,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 +21626,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 +21831,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 +22032,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 +22131,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 +22229,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 +22496,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 +22545,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 +22601,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 +22677,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 +22763,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 +22817,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 +23245,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 +23255,7 @@ var defaultDeps$6 = {
 	downloadFile,
 	saveRunManifest,
 	placeProductionRecord: placeProductionRecordForCli,
+	fetch,
 	createRunId,
 	getWorkingDir: () => process$1.cwd(),
 	fileExists: async (filePath) => {
@@ -21596,6 +23267,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 +23318,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 +23343,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 +23357,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 +23370,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 +23416,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 +23438,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 +23507,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 +23529,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 +23580,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 +23601,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 +23797,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 +23821,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 +23940,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 +24006,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 +24336,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 +24389,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 +24402,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 +24479,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 +24508,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 +24517,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 +24549,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 +24585,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 +24594,7 @@ Usage:
 }
 //#endregion
 //#region src/cli/commands/runs.ts
-var defaultDeps$3 = {
+var defaultDeps$6 = {
 	loadProjectConfig,
 	listRunManifests,
 	readRunManifest,
@@ -22799,11 +24607,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 +24729,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 +24747,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 +24770,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 +24854,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 +24871,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 +24896,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 +24954,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 +25002,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 +25033,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 +25048,7 @@ Usage:
 }
 //#endregion
 //#region src/cli/commands/variants.ts
-var defaultDeps$1 = {
+var defaultDeps$4 = {
 	loadConfig: loadStoredConfig,
 	loadProjectConfig,
 	resolveBaseUrl,
@@ -23254,12 +25060,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 +25113,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 +25136,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 +25152,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 +25973,7 @@ var defaultDeps = {
 	loadProjectConfig,
 	resolveBaseUrl,
 	createClient: (env, spaceId) => WebSocketClient.create(env, spaceId),
+	isRotationEnabled: isCliRotationEnabled,
 	print: console.log
 };
 async function handleRotation(parsed) {
@@ -23377,12 +25987,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 +26197,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 +26213,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 +26235,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 +26243,7 @@ Options:
 }
 //#endregion
 //#region src/cli/index.ts
-var CLI_VERSION = "0.1.3+21fbf493922f";
+var CLI_VERSION = "0.2.0+a98a786097bf";
 async function main() {
 	const argv = process$1.argv.slice(2);
 	if (argv[0] === "--") argv.shift();
@@ -23735,6 +26352,9 @@ function printCommandHelp(command, positionals) {
 		case "upload":
 			printUploadHelp();
 			return;
+		case "import":
+			printImportHelp();
+			return;
 		case "generate":
 		case "refine":
 		case "derive":
@@ -23753,10 +26373,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 +26405,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 +26437,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 +26448,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:
@@ -23835,6 +26472,7 @@ 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
+  import <manifest.json> [--space <id>]       Import media with provenance, lineage, and organization metadata
 
 Forge:
   generate "prompt" --name <name> --type <type> -o <file>
@@ -23876,14 +26514,20 @@ 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 import import-manifest.json --dry-run --json
+  makefx import external-renders.json --space space_123
   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 +26562,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:
@@ -23956,11 +26600,35 @@ 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
   --env <env>       Environment (production|stage|local)
   --local           Shortcut for --env local
 `);
 }
+function printImportHelp() {
+	console.log(`
+Usage:
+  makefx import <manifest.json> [--space <id>]
+  makefx import <manifest.json> --dry-run [--json]
+
+Options:
+  --space <id>      Target space ID; defaults from initialized project
+  --dry-run         Validate manifest, files, targets, membership, lineage, and organization references
+  --json            Print machine-readable import or dry-run output
+  --env <env>       Environment (production|stage|local)
+  --local           Shortcut for --env local
+
+Manifest:
+  Records import files with prompt, model, provider, providerMetadata, and
+  generationProvenance. Lineage entries record immutable source provenance using
+  sourceFile or sourceVariantId; use collections, relations, and compositions
+  for editable organization metadata. Style references are normal assets grouped
+  into collections and selected through style presets.
+
+Examples:
+  makefx import external-renders.json --dry-run --json
+  makefx import external-renders.json --space space_123
+`);
+}
 function printForgeHelp(command) {
 	if (command === "generate") {
 		console.log(`
@@ -23970,6 +26638,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 +26656,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 +26672,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 +26686,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 +26887,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 +26936,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 +26958,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 +26986,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":
@@ -24289,6 +27044,9 @@ async function dispatchCommand(command, parsed) {
 		case "upload":
 			await handleUpload(parsed);
 			break;
+		case "import":
+			await handleImport(parsed);
+			break;
 		case "generate":
 			await handleGenerate(parsed);
 			break;
@@ -24313,10 +27071,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;