makefx 0.2.0 → 0.2.1

package/makefx.mjs

@@ -839,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$13 = {
+var defaultDeps$12 = {
 	loadConfig: loadStoredConfig,
 	resolveBaseUrl,
 	saveProjectConfig,
@@ -854,7 +854,7 @@ async function handleSpaces(parsed) {
 		process$1.exitCode = 1;
 	}
 }
-async function executeSpaces(parsed, deps = defaultDeps$13) {
+async function executeSpaces(parsed, deps = defaultDeps$12) {
 	const env = resolveCommandEnvironment(parsed);
 	const showDetails = parsed.options.details === "true";
 	const spaceId = parsed.options.id;
@@ -5056,7 +5056,28 @@ var EXT_TO_MEDIA_TYPE = {
 	}
 };
 var ALLOWED_EXTENSIONS$1 = Object.keys(EXT_TO_MEDIA_TYPE).sort();
-var defaultDeps$12 = {
+function resolveMediaType(ext, requestedMediaKind) {
+	const mediaType = EXT_TO_MEDIA_TYPE[ext];
+	if (!mediaType) throw new Error(`Invalid file type "${ext}". Allowed types: ${ALLOWED_EXTENSIONS$1.join(", ")}`);
+	if (requestedMediaKind !== void 0 && requestedMediaKind !== "image" && requestedMediaKind !== "audio" && requestedMediaKind !== "video") throw new Error("Invalid --media-kind. Expected image, audio, or video");
+	if (ext === ".webm" && requestedMediaKind === "audio") return {
+		mediaKind: "audio",
+		mimeType: "audio/webm"
+	};
+	if (requestedMediaKind && requestedMediaKind !== mediaType.mediaKind) throw new Error(`--media-kind ${requestedMediaKind} does not match ${ext} (${mediaType.mediaKind})`);
+	return mediaType;
+}
+//#endregion
+//#region src/cli/commands/upload.ts
+/**
+* Upload Command - Upload one media file to create variants
+*
+* Usage:
+*   makefx upload <file> --space <id> --asset <id>     Upload to existing asset
+*   makefx upload <file> --space <id> --name <name>    Upload as new asset
+*   makefx upload <file> --space <id> --name <name> --type <type>
+*/
+var defaultDeps$11 = {
 	loadConfig: loadStoredConfig,
 	loadProjectConfig,
 	resolveBaseUrl,
@@ -5071,11 +5092,13 @@ 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$12();
+		if (error instanceof UploadUsageError) printUsage$11();
 		process$1.exitCode = 1;
 	}
 }
-async function executeUpload(parsed, deps = defaultDeps$12) {
+async function executeUpload(parsed, deps = defaultDeps$11) {
+	const filePath = parsed.positionals[0];
+	if (!filePath) throw new UploadUsageError("File path is required");
 	const projectConfig = await deps.loadProjectConfig();
 	const env = resolveCommandEnvironment(parsed, projectConfig);
 	const spaceId = resolveCommandSpace(parsed, projectConfig);
@@ -5083,36 +5106,97 @@ async function executeUpload(parsed, deps = defaultDeps$12) {
 	const assetName = parsed.options.name;
 	const assetType = parsed.options.type || "character";
 	const requestedMediaKind = parsed.options["media-kind"] || parsed.options.mediaKind;
-	const filePath = parsed.positionals[0];
-	if (!filePath) throw new UploadUsageError("File path is required");
+	const prompt = parsed.options.prompt;
+	const model = parsed.options.model;
+	const provider = parsed.options.provider;
+	const rawProviderMetadata = parsed.options["provider-metadata"] ?? parsed.options.providerMetadata ?? parsed.options.provider_metadata;
+	const rawGenerationProvenance = parsed.options["generation-provenance"] ?? parsed.options.generationProvenance ?? parsed.options.generation_provenance;
+	const sourceVariantId = parsed.options["source-variant"] ?? parsed.options.sourceVariantId ?? parsed.options.parentVariantId;
+	const rawRelationType = parsed.options["relation-type"] ?? parsed.options.relationType;
+	const rawActiveVariantBehavior = parsed.options["active-variant-behavior"] ?? parsed.options.activeVariantBehavior;
+	const rawCollectionIds = parsed.options.collection ?? parsed.options.collections;
+	const rawCollectionNames = parsed.options["collection-name"] ?? parsed.options.collectionName;
+	const rawCollectionRole = parsed.options["collection-role"] ?? parsed.options.collectionRole;
+	const rawCollectionSubject = parsed.options["collection-subject"] ?? parsed.options.collectionSubject;
+	const rawCollectionPinnedVariant = parsed.options["collection-pinned-variant"] ?? parsed.options.collectionPinnedVariant;
+	const rawManualRelation = parsed.options["manual-relation"] ?? parsed.options.manualRelation;
+	const rawManualRelationSubject = parsed.options["manual-relation-subject"] ?? parsed.options.manualRelationSubject;
+	const rawManualRelationLabel = parsed.options["manual-relation-label"] ?? parsed.options.manualRelationLabel;
+	const rawManualRelationContext = parsed.options["manual-relation-context"] ?? parsed.options.manualRelationContext;
+	const rawManualRelationMetadata = parsed.options["manual-relation-metadata"] ?? parsed.options.manualRelationMetadata;
+	const jsonOutput = parsed.options.json === "true";
+	if (parsed.options["dry-run"] === "true" || parsed.options.dryRun === "true") throw new UploadUsageError("--dry-run is not supported for direct file upload");
 	if (!spaceId) throw new UploadUsageError("--space is required, or run: makefx init --space <id>");
 	if (!assetId && !assetName) throw new UploadUsageError("Either --asset or --name is required");
+	if (!sourceVariantId && (parsed.options["relation-type"] || parsed.options.relationType)) throw new UploadUsageError("--relation-type requires --source-variant");
+	const providerMetadata = parseJsonObjectOption(rawProviderMetadata, "--provider-metadata");
+	const generationProvenance = parseJsonObjectOption(rawGenerationProvenance, "--generation-provenance");
+	const relationType = normalizeRelationType(rawRelationType);
+	const activeVariantBehavior = normalizeActiveVariantBehavior(rawActiveVariantBehavior);
+	const collectionPlacements = parseCollectionPlacements({
+		collectionIds: rawCollectionIds,
+		collectionNames: rawCollectionNames,
+		role: rawCollectionRole,
+		subjectType: rawCollectionSubject,
+		pinnedVariant: rawCollectionPinnedVariant
+	});
+	const manualRelations = parseManualRelations({
+		relations: rawManualRelation,
+		subjectType: rawManualRelationSubject,
+		label: rawManualRelationLabel,
+		context: rawManualRelationContext,
+		metadata: rawManualRelationMetadata
+	});
 	const mediaType = resolveMediaType(path.extname(filePath).toLowerCase(), requestedMediaKind);
 	const config = await deps.loadConfig(env);
 	if (!config) throw new Error(`Not logged in to ${env} environment. Run: ${loginCommandForEnvironment(env)}`);
 	if (config.token.expiresAt < Date.now()) throw new Error(`Token expired for ${env} environment. Run: ${loginCommandForEnvironment(env)}`);
 	const baseUrl = deps.resolveBaseUrl(env);
 	const accessToken = config.token.accessToken;
+	const ctx = {
+		spaceId,
+		baseUrl,
+		accessToken
+	};
 	if (env === "local") process$1.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
 	try {
 		const fileStat = await deps.stat(filePath);
 		if (!fileStat.isFile()) throw new Error(`"${filePath}" is not a file`);
 		if (fileStat.size > 10485760) throw new Error(`File too large (${(fileStat.size / 1024 / 1024).toFixed(2)}MB). Maximum size: 10MB`);
+		await preflightUploadOrganization(ctx, deps, {
+			assetId,
+			sourceVariantId,
+			collectionPlacements,
+			manualRelations
+		});
 		const fileBuffer = await deps.readFile(filePath);
 		const fileName = path.basename(filePath);
 		const formData = new FormData();
 		const blob = new Blob([fileBuffer], { type: mediaType.mimeType });
 		formData.append("file", blob, fileName);
 		formData.append("mediaKind", mediaType.mediaKind);
+		formData.append("activeVariantBehavior", activeVariantBehavior);
 		if (assetId) formData.append("assetId", assetId);
 		else {
 			formData.append("assetName", assetName);
 			formData.append("assetType", assetType);
 		}
-		deps.print(`\nUploading "${fileName}" to space ${spaceId}...`);
-		deps.print(`  Media kind: ${mediaType.mediaKind}`);
-		if (assetId) deps.print(`  Target asset: ${assetId}`);
-		else deps.print(`  Creating asset: "${assetName}" (${assetType})`);
+		if (prompt) formData.append("prompt", prompt);
+		if (model) formData.append("model", model);
+		if (provider) formData.append("provider", provider);
+		if (providerMetadata) formData.append("providerMetadata", JSON.stringify(providerMetadata));
+		if (generationProvenance) formData.append("generationProvenance", JSON.stringify(generationProvenance));
+		if (sourceVariantId) formData.append("lineage", JSON.stringify([{
+			parentVariantId: sourceVariantId,
+			relationType
+		}]));
+		if (!jsonOutput) {
+			deps.print(`\nUploading "${fileName}" to space ${spaceId}...`);
+			deps.print(`  Media kind: ${mediaType.mediaKind}`);
+			if (assetId) deps.print(`  Target asset: ${assetId}`);
+			else deps.print(`  Creating asset: "${assetName}" (${assetType})`);
+			if (sourceVariantId) deps.print(`  Source variant: ${sourceVariantId} (${relationType})`);
+		}
 		const response = await deps.fetch(`${baseUrl}/api/spaces/${spaceId}/upload`, {
 			method: "POST",
 			headers: { "Authorization": `Bearer ${accessToken}` },
@@ -5121,6 +5205,29 @@ async function executeUpload(parsed, deps = defaultDeps$12) {
 		const data = await response.json();
 		if (!response.ok) throw new Error(`Upload failed: ${"error" in data ? data.error : response.statusText}`);
 		const upload = data;
+		let organization = {
+			collectionItemIds: [],
+			relationIds: []
+		};
+		try {
+			organization = await applyUploadOrganization(ctx, deps, upload, {
+				collectionPlacements,
+				manualRelations
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			throw new Error(`Upload created asset ${upload.variant.asset_id} and variant ${upload.variant.id}, but organization failed: ${message}`);
+		}
+		const result = {
+			asset: upload.asset,
+			variant: upload.variant,
+			lineage: upload.lineage,
+			organization
+		};
+		if (jsonOutput) {
+			deps.print(JSON.stringify(result, null, 2));
+			return result;
+		}
 		deps.print("\nUpload successful!\n");
 		if (upload.asset) {
 			deps.print("New Asset:");
@@ -5138,6 +5245,11 @@ async function executeUpload(parsed, deps = defaultDeps$12) {
 		if (upload.variant.image_key) deps.print(`  Image:    ${upload.variant.image_key}`);
 		if (upload.variant.thumb_key) deps.print(`  Thumb:    ${upload.variant.thumb_key}`);
 		if (upload.variant.media_mime_type) deps.print(`  MIME:     ${upload.variant.media_mime_type}`);
+		if (organization.collectionItemIds.length > 0 || organization.relationIds.length > 0) {
+			deps.print("\nOrganization:");
+			if (organization.collectionItemIds.length > 0) deps.print(`  Collection items: ${organization.collectionItemIds.join(", ")}`);
+			if (organization.relationIds.length > 0) deps.print(`  Relations:        ${organization.relationIds.join(", ")}`);
+		}
 		if (upload.variant.recipe) try {
 			const recipe = JSON.parse(upload.variant.recipe);
 			deps.print("\nRecipe:");
@@ -5147,429 +5259,45 @@ async function executeUpload(parsed, deps = defaultDeps$12) {
 		} catch {}
 		deps.print("\nTo inspect:");
 		deps.print(`  makefx assets show ${upload.variant.asset_id} --space ${spaceId}`);
-		return {
-			asset: upload.asset,
-			variant: upload.variant
-		};
+		return result;
 	} catch (error) {
 		if (error.code === "ENOENT") throw new Error(`File not found: ${filePath}`);
 		throw error;
 	}
 }
-function resolveMediaType(ext, requestedMediaKind) {
-	const mediaType = EXT_TO_MEDIA_TYPE[ext];
-	if (!mediaType) throw new Error(`Invalid file type "${ext}". Allowed types: ${ALLOWED_EXTENSIONS$1.join(", ")}`);
-	if (requestedMediaKind !== void 0 && requestedMediaKind !== "image" && requestedMediaKind !== "audio" && requestedMediaKind !== "video") throw new Error("Invalid --media-kind. Expected image, audio, or video");
-	if (ext === ".webm" && requestedMediaKind === "audio") return {
-		mediaKind: "audio",
-		mimeType: "audio/webm"
-	};
-	if (requestedMediaKind && requestedMediaKind !== mediaType.mediaKind) throw new Error(`--media-kind ${requestedMediaKind} does not match ${ext} (${mediaType.mediaKind})`);
-	return mediaType;
-}
-function printUsage$12() {
-	console.log(`
-Usage:
-  makefx upload <file> --asset <id> [--space <id>]     Upload media to existing asset
-  makefx upload <file> --name <name> [--space <id>]    Create new asset
-
-Options:
-  --space <id>      Target space ID; defaults from initialized project
-  --asset <id>      Target asset ID (upload as new variant)
-  --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
-  --env <env>       Environment (production|stage|local)
-  --local           Shortcut for --env local
-
-Examples:
-  makefx upload hero.png --space abc123 --name "Hero Character"
-  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
-`);
-}
-//#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));
+function parseJsonObjectOption(value, optionName) {
+	if (value === void 0) return void 0;
 	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);
+		parsed = JSON.parse(value);
+	} catch {
+		throw new UploadUsageError(`${optionName} must be valid JSON`);
 	}
-	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
-		};
-	});
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new UploadUsageError(`${optionName} must be a JSON object`);
+	return parsed;
 }
-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 parseJsonObjectOrStringOption(value, optionName) {
+	if (value === void 0) return void 0;
+	if (!value.trim().startsWith("{")) return value;
+	return parseJsonObjectOption(value, optionName);
 }
-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 normalizeRelationType(value) {
+	if (!value) return "derived";
+	if (value === "derived" || value === "refined" || value === "forked") return value;
+	throw new UploadUsageError("--relation-type must be derived, refined, or forked");
 }
-function 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 normalizeActiveVariantBehavior(value) {
+	if (!value || value === "if-missing" || value === "if_missing") return "if-missing";
+	if (value === "set-active" || value === "set_active") return "set-active";
+	if (value === "keep") return "keep";
+	throw new UploadUsageError("--active-variant-behavior must be if-missing, set-active, or keep");
 }
-function normalizeSubjectType(value, label) {
+function normalizeSpaceSubjectType(value, optionName, defaultValue) {
+	if (!value) return defaultValue;
 	if (value === "asset" || value === "variant") return value;
-	throw new Error(`${label} must be asset or variant`);
+	throw new UploadUsageError(`${optionName} must be asset or variant`);
 }
-function normalizeRelationType(value, label) {
+function normalizeManualRelationType(value, optionName) {
 	if ([
 		"appears_in",
 		"background_for",
@@ -5582,425 +5310,156 @@ function normalizeRelationType(value, label) {
 		"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`);
+	throw new UploadUsageError(`${optionName} relation type 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 parseCsvOption$1(value, optionName) {
+	if (!value) return [];
+	if (value === "true") throw new UploadUsageError(`${optionName} requires a value`);
+	return value.split(",").map((entry) => entry.trim()).filter(Boolean);
 }
-function requireObject(value, label) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object`);
+function parseCollectionPlacements(input) {
+	const collectionIds = parseCsvOption$1(input.collectionIds, "--collection");
+	const collectionNames = parseCsvOption$1(input.collectionNames, "--collection-name");
+	if (collectionIds.length === 0 && collectionNames.length === 0) return [];
+	const subjectType = normalizeSpaceSubjectType(input.subjectType, "--collection-subject", "asset");
+	if (subjectType === "variant" && input.pinnedVariant && input.pinnedVariant !== "true") throw new UploadUsageError("--collection-pinned-variant can only be used when --collection-subject is asset");
+	const pinnedVariantId = normalizeCollectionPinnedVariant(input.pinnedVariant);
+	const placement = {
+		role: input.role && input.role !== "true" ? input.role : "member",
+		subjectType,
+		pinnedVariantId
+	};
+	return [...collectionIds.map((collectionId) => ({
+		...placement,
+		collectionId
+	})), ...collectionNames.map((collectionName) => ({
+		...placement,
+		collectionName
+	}))];
+}
+function normalizeCollectionPinnedVariant(value) {
+	if (!value || value === "true" || value === "uploaded") return void 0;
+	if (value === "none" || value === "unpin") return null;
 	return value;
 }
-function 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`);
-	}
+function parseManualRelations(input) {
+	const relationSpecs = parseCsvOption$1(input.relations, "--manual-relation");
+	if (relationSpecs.length === 0) return [];
+	const subjectType = normalizeSpaceSubjectType(input.subjectType, "--manual-relation-subject", "variant");
+	const context = parseJsonObjectOrStringOption(input.context, "--manual-relation-context");
+	const metadata = parseJsonObjectOption(input.metadata, "--manual-relation-metadata");
+	return relationSpecs.map((spec) => {
+		const parts = spec.split(":");
+		if (parts.length !== 3) throw new UploadUsageError("--manual-relation entries must use <relation-type>:asset:<asset-id> or <relation-type>:variant:<variant-id>");
+		const [relationTypeValue, objectTypeValue, objectId] = parts;
+		const objectType = normalizeSpaceSubjectType(objectTypeValue, "--manual-relation object type", "asset");
+		if (!objectId) throw new UploadUsageError("--manual-relation object id is required");
+		return {
+			relationType: normalizeManualRelationType(relationTypeValue, "--manual-relation"),
+			object: objectType === "asset" ? {
+				subjectType: "asset",
+				assetId: objectId
+			} : {
+				subjectType: "variant",
+				variantId: objectId
+			},
+			subjectType,
+			label: input.label && input.label !== "true" ? input.label : void 0,
+			context,
+			metadata
+		};
+	});
 }
-async function 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 ?? [];
+async function preflightUploadOrganization(ctx, deps, options) {
+	const needsCollections = options.collectionPlacements.length > 0;
+	const needsAssetState = Boolean(options.sourceVariantId) || options.manualRelations.length > 0 || options.collectionPlacements.some((placement) => placement.pinnedVariantId);
+	const [collections, state] = await Promise.all([needsCollections ? fetchJson$1(ctx, deps, `/api/spaces/${ctx.spaceId}/collections`) : void 0, needsAssetState ? fetchAssetState(ctx, deps) : void 0]);
+	if (collections) {
+		const collectionList = collections.collections ?? [];
+		const collectionIds = new Set(collectionList.map((collection) => collection.id));
+		for (const placement of options.collectionPlacements) {
+			if (placement.collectionId && !collectionIds.has(placement.collectionId)) throw new Error(`Collection not found: ${placement.collectionId}`);
+			if (!placement.collectionName) continue;
+			const matches = collectionList.filter((collection) => collection.name === placement.collectionName);
+			if (matches.length === 0) throw new Error(`Collection not found by exact name: ${placement.collectionName}`);
+			if (matches.length > 1) throw new Error(`Collection name is ambiguous: ${placement.collectionName}; use --collection <id>`);
+			placement.collectionId = matches[0].id;
+		}
+	}
+	if (!state) return;
+	if (options.sourceVariantId && !state.variantsById.has(options.sourceVariantId)) throw new Error(`Source variant not found in space: ${options.sourceVariantId}`);
+	for (const placement of options.collectionPlacements) {
+		if (!placement.pinnedVariantId) continue;
+		const pinned = state.variantsById.get(placement.pinnedVariantId);
+		if (!pinned) throw new Error(`Collection pinned variant not found: ${placement.pinnedVariantId}`);
+		if (placement.subjectType === "asset") {
+			if (!options.assetId) throw new Error("--collection-pinned-variant cannot reference an existing variant when creating a new asset");
+			if (pinned.asset_id !== options.assetId) throw new Error("--collection-pinned-variant must reference a variant on the target asset");
+		}
+	}
+	for (const relation of options.manualRelations) if (relation.object.subjectType === "asset") {
+		if (!relation.object.assetId || !state.assetsById.has(relation.object.assetId)) throw new Error(`Manual relation object asset not found: ${relation.object.assetId ?? ""}`);
+	} else if (!relation.object.variantId || !state.variantsById.has(relation.object.variantId)) throw new Error(`Manual relation object variant not found: ${relation.object.variantId ?? ""}`);
+}
+async function fetchAssetState(ctx, deps) {
+	const assets = (await fetchJson$1(ctx, deps, `/api/spaces/${ctx.spaceId}/assets`)).assets ?? [];
 	const variantsById = /* @__PURE__ */ new Map();
-	for (const asset of assets) {
+	await Promise.all(assets.map(async (asset) => {
 		const details = await fetchJson$1(ctx, deps, `/api/spaces/${ctx.spaceId}/assets/${encodeURIComponent(asset.id)}`);
 		for (const variant of details.variants ?? []) variantsById.set(variant.id, variant);
-	}
-	return {
-		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
 	}));
+	return {
+		assetsById: new Map(assets.map((asset) => [asset.id, asset])),
+		variantsById
+	};
 }
-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 = [];
+async function applyUploadOrganization(ctx, deps, upload, options) {
 	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));
+	const uploadedSubject = {
+		assetId: upload.variant.asset_id,
+		variantId: upload.variant.id
+	};
+	for (const placement of options.collectionPlacements) {
+		if (!placement.collectionId) throw new Error(`Collection name was not resolved: ${placement.collectionName ?? ""}`);
+		const body = placement.subjectType === "asset" ? {
+			subjectType: "asset",
+			assetId: uploadedSubject.assetId,
+			role: placement.role,
+			pinnedVariantId: placement.pinnedVariantId === void 0 ? uploadedSubject.variantId : placement.pinnedVariantId
+		} : {
+			subjectType: "variant",
+			variantId: uploadedSubject.variantId,
+			role: placement.role
+		};
+		const created = await postJson(ctx, deps, `/api/spaces/${ctx.spaceId}/collections/${encodeURIComponent(placement.collectionId)}/items`, body);
 		collectionItemIds.push(created.item.id);
 	}
-	for (const relation of plan.relations) {
+	for (const relation of options.manualRelations) {
 		const created = await postJson(ctx, deps, `/api/spaces/${ctx.spaceId}/relations`, {
-			id: relation.id,
-			subject: resolveSubject(relation.subject, uploadedByKey),
-			object: resolveSubject(relation.object, uploadedByKey),
+			subject: relation.subjectType === "asset" ? {
+				subjectType: "asset",
+				assetId: uploadedSubject.assetId
+			} : {
+				subjectType: "variant",
+				variantId: uploadedSubject.variantId
+			},
+			object: relation.object,
 			relationType: relation.relationType,
 			label: relation.label,
 			context: relation.context,
-			metadata: relation.metadata,
-			sortIndex: relation.sortIndex
+			metadata: relation.metadata
 		});
 		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
+		relationIds
 	};
 }
 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,
+		method: "POST",
 		headers: {
 			Authorization: `Bearer ${ctx.accessToken}`,
 			Accept: "application/json",
@@ -6012,9 +5471,6 @@ async function sendJson(ctx, deps, method, requestPath, json) {
 	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}`,
@@ -6024,40 +5480,58 @@ async function fetchJson$1(ctx, deps, requestPath) {
 	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 stripUndefined(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
 }
 function printUsage$11() {
 	console.log(`
 Usage:
-  makefx import <manifest.json> [--space <id>]
-  makefx import <manifest.json> --dry-run [--json]
+  makefx upload <file> --asset <id> [--space <id>]     Upload media to existing asset
+  makefx upload <file> --name <name> [--space <id>]    Upload media as a new asset
+
+Options:
+  --space <id>      Target space ID; defaults from initialized project
+  --asset <id>      Target asset ID (upload as new variant)
+  --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
+  --prompt <text>   Prompt provenance for uploaded media
+  --model <model>   Model provenance for uploaded media
+  --provider <name> Provider provenance for uploaded media
+  --provider-metadata <json>     Provider metadata JSON object
+  --generation-provenance <json> Extra provenance JSON object
+  --source-variant <id>          Existing source variant for upload lineage
+  --relation-type <type>         Lineage type: derived, refined, or forked (default: derived)
+  --active-variant-behavior <b>  if-missing, set-active, or keep
+  --collection <ids>             Comma-separated collection IDs for the uploaded asset or variant
+  --collection-name <names>      Comma-separated exact collection names for lookup
+  --collection-role <role>       Collection item role (default: member)
+  --collection-subject <type>    Collection subject: asset or variant (default: asset)
+  --collection-pinned-variant <id|uploaded|none>
+                                 Pin an asset collection item to the uploaded variant by default
+  --manual-relation <spec>       Comma-separated <type>:asset:<id> or <type>:variant:<id>
+  --manual-relation-subject <type>
+                                 Relation subject: uploaded asset or variant (default: variant)
+  --manual-relation-label <text> Optional manual relation label
+  --manual-relation-context <json|string>
+                                 Optional manual relation context
+  --manual-relation-metadata <json>
+                                 Optional manual relation metadata object
+  --json            Print machine-readable upload output with Space IDs
+  --env <env>       Environment (production|stage|local)
+  --local           Shortcut for --env local
 
-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.
+Examples:
+  makefx upload hero.png --space abc123 --name "Hero Character"
+  makefx upload hero.png --space abc123 --name "Hero" --prompt "external render" --provider blender
+  makefx upload paintover.png --space abc123 --asset def456 --source-variant var123 --relation-type refined
+  makefx upload hero.png --space abc123 --name "Hero" --collection collection_cast --collection-role character
+  makefx upload hero.png --space abc123 --name "Hero" --collection-name "Cast" --collection-role character
+  makefx upload thumbnail.png --space abc123 --asset asset_thumb --manual-relation thumbnail_for:asset:asset_target
+  makefx upload theme.mp3 --space abc123 --name "Theme Music" --type audio
+  makefx upload cutscene.mp4 --space abc123 --name "Opening Cutscene" --type video
+  makefx upload variant.jpg --space abc123 --asset def456
+  makefx upload hero.png --space abc123 --name "Hero" --json
 `);
 }
 //#endregion
@@ -26243,7 +25717,7 @@ Options:
 }
 //#endregion
 //#region src/cli/index.ts
-var CLI_VERSION = "0.2.0+a98a786097bf";
+var CLI_VERSION = "0.2.1+2f99bf2b725b";
 async function main() {
 	const argv = process$1.argv.slice(2);
 	if (argv[0] === "--") argv.shift();
@@ -26352,9 +25826,6 @@ function printCommandHelp(command, positionals) {
 		case "upload":
 			printUploadHelp();
 			return;
-		case "import":
-			printImportHelp();
-			return;
 		case "generate":
 		case "refine":
 		case "derive":
@@ -26471,8 +25942,10 @@ Listen:
 
 Upload:
   upload <file> --asset <id> [--space <id>]   Upload image, audio, or video to existing asset
-  upload <file> --name <name> [--space <id>]  Upload media and create new asset
-  import <manifest.json> [--space <id>]       Import media with provenance, lineage, and organization metadata
+  upload <file> --name <name> [--space <id>]  Upload image, audio, or video as a new asset
+  upload <file> --collection <id>             Place uploaded media in a collection
+  upload <file> --collection-name <name>      Place uploaded media in an exact-name collection
+  upload <file> --manual-relation <spec>      Create a manual relation from uploaded media
 
 Forge:
   generate "prompt" --name <name> --type <type> -o <file>
@@ -26514,8 +25987,9 @@ 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 upload hero.png --name "Hero" --collection collection_cast
+  makefx upload hero.png --name "Hero" --collection-name "Cast" --json
+  makefx upload thumbnail.png --asset asset_thumb --manual-relation thumbnail_for:asset:asset_target
   makefx assets
   makefx usage --from 2026-06-01
   makefx spend --from 2026-06-01 --provider gemini
@@ -26592,7 +26066,7 @@ function printUploadHelp() {
 	console.log(`
 Usage:
   makefx upload <file> --asset <id> [--space <id>]     Upload media to existing asset
-  makefx upload <file> --name <name> [--space <id>]    Create new asset
+  makefx upload <file> --name <name> [--space <id>]    Upload media as a new asset
 
 Options:
   --space <id>      Target space ID; defaults from initialized project
@@ -26600,35 +26074,33 @@ 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
+  --prompt <text>   Prompt provenance for uploaded media
+  --model <model>   Model provenance for uploaded media
+  --provider <name> Provider provenance for uploaded media
+  --provider-metadata <json>     Provider metadata JSON object
+  --generation-provenance <json> Extra provenance JSON object
+  --source-variant <id>          Existing source variant for upload lineage
+  --relation-type <type>         Lineage type: derived, refined, or forked (default: derived)
+  --active-variant-behavior <b>  if-missing, set-active, or keep
+  --collection <ids>             Comma-separated collection IDs for the uploaded asset or variant
+  --collection-name <names>      Comma-separated exact collection names for lookup
+  --collection-role <role>       Collection item role (default: member)
+  --collection-subject <type>    Collection subject: asset or variant (default: asset)
+  --collection-pinned-variant <id|uploaded|none>
+                                 Pin an asset collection item to the uploaded variant by default
+  --manual-relation <spec>       Comma-separated <type>:asset:<id> or <type>:variant:<id>
+  --manual-relation-subject <type>
+                                 Relation subject: uploaded asset or variant (default: variant)
+  --manual-relation-label <text> Optional manual relation label
+  --manual-relation-context <json|string>
+                                 Optional manual relation context
+  --manual-relation-metadata <json>
+                                 Optional manual relation metadata object
+  --json            Print machine-readable upload output with Space IDs
   --env <env>       Environment (production|stage|local)
   --local           Shortcut for --env local
 `);
 }
-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(`
@@ -27044,9 +26516,6 @@ async function dispatchCommand(command, parsed) {
 		case "upload":
 			await handleUpload(parsed);
 			break;
-		case "import":
-			await handleImport(parsed);
-			break;
 		case "generate":
 			await handleGenerate(parsed);
 			break;