Upload folder using huggingface_hub

6.17.1/workflowcanvas/Index.svelte

@@ -0,0 +1,57 @@
+<script lang="ts">
+	import { Gradio } from "@gradio/utils";
+	import { get } from "svelte/store";
+	import WorkflowCanvas from "./workflow/WorkflowCanvas.svelte";
+	import { workflow, sanitize_for_save } from "./workflow/workflow-store";
+
+	let _props = $props();
+	const gradio = new Gradio<Record<string, never>, { value: string | null }>(
+		_props
+	);
+
+	let serverObj = $derived(gradio.shared?.server ?? {});
+	let initialValue = $derived(gradio.props.value ?? null);
+
+	$effect(() => {
+		if (!serverObj?.save_workflow) return;
+
+		function handlePageHide() {
+			const gradioConfig = (window as any).gradio_config;
+			const componentId = gradioConfig?.components?.find(
+				(c: any) => c.type === "workflowcanvas"
+			)?.id;
+			if (!componentId) return;
+			const client = gradio.shared?.client;
+			if (!client) return;
+			const root = gradioConfig?.root ?? "";
+			const apiPrefix = gradioConfig?.api_prefix ?? "/gradio_api";
+			fetch(`${root}${apiPrefix}/component_server/`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					data: [JSON.stringify(sanitize_for_save(get(workflow)))],
+					component_id: componentId,
+					fn_name: "save_workflow",
+					session_hash: client.session_hash
+				}),
+				keepalive: true
+			}).catch(() => {});
+		}
+
+		window.addEventListener("pagehide", handlePageHide);
+		return () => window.removeEventListener("pagehide", handlePageHide);
+	});
+</script>
+
+<div class="workflow-fullscreen">
+	<WorkflowCanvas server={serverObj} {initialValue} />
+</div>
+
+<style>
+	.workflow-fullscreen {
+		position: fixed;
+		inset: 0;
+		z-index: 100;
+		background: #0c0d10;
+	}
+</style>

6.17.1/workflowcanvas/package.json

@@ -0,0 +1,34 @@
+{
+	"name": "@gradio/workflowcanvas",
+	"version": "0.2.0",
+	"description": "Gradio Workflow Canvas component",
+	"type": "module",
+	"author": "",
+	"license": "Apache-2.0",
+	"private": false,
+	"main_changeset": true,
+	"main": "Index.svelte",
+	"exports": {
+		".": {
+			"gradio": "./Index.svelte",
+			"svelte": "./dist/Index.svelte",
+			"types": "./dist/Index.svelte.d.ts",
+			"default": "./dist/Index.svelte"
+		},
+		"./package.json": "./package.json"
+	},
+	"dependencies": {
+		"@gradio/atoms": "workspace:^",
+		"@gradio/client": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/utils": "workspace:^",
+		"@huggingface/hub": "^1.0.0",
+		"svelte": "^5.48.0"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"peerDependencies": {
+		"svelte": "^5.48.0"
+	}
+}

6.17.1/workflowcanvas/workflow/NodeModelPicker.svelte

@@ -0,0 +1,1338 @@
+<script lang="ts">
+	import { categorizeSpace, TASK_SCHEMAS } from "./node-library";
+	import { fetchSpaceApi, normalizeOperatorPorts } from "./space-api";
+	import { FEATURED_SPACES, FEATURED_MODELS } from "./featured";
+	import type { ModalityConfig, SubTab } from "./workflow-modalities";
+	import SearchIcon from "./icons/SearchIcon.svelte";
+	import CloseIcon from "./icons/CloseIcon.svelte";
+	import OpenLinkIcon from "./icons/OpenLinkIcon.svelte";
+
+	interface SpaceResult {
+		id: string;
+		title: string;
+		description: string;
+		likes: number;
+		running: boolean;
+		category: string | null;
+		pipeline_tag?: string;
+	}
+
+	type Source = "spaces" | "models" | "datasets";
+
+	interface Props {
+		mode: "create" | "update";
+		modality: ModalityConfig;
+		nodeId?: string;
+		server?: Record<string, any>;
+		hfToken?: string;
+		anchorX?: number;
+		anchorY?: number;
+		initialSource?: Source;
+		initialSubtab?: string;
+		oncreate: (template: any) => void;
+		onupdate: (nodeId: string, template: any) => void;
+		onclose: () => void;
+		onerror?: (message: string) => void;
+	}
+
+	let {
+		mode,
+		modality,
+		nodeId,
+		server = {},
+		hfToken = "",
+		anchorX = undefined,
+		anchorY = undefined,
+		initialSource = undefined,
+		initialSubtab = undefined,
+		oncreate,
+		onupdate,
+		onclose,
+		onerror
+	}: Props = $props();
+
+	let source = $state<Source>(
+		initialSource ?? (modality.key === "data" ? "datasets" : "spaces")
+	);
+	const is_dataset = $derived(source === "datasets");
+	const is_model = $derived(source === "models");
+	const is_spaces = $derived(source === "spaces");
+	const show_source_toggle = $derived(modality.key !== "data");
+
+	const search_placeholder = $derived.by(() => {
+		const kind = is_dataset ? "datasets" : is_model ? "models" : "spaces";
+		// Data modality is its own thing — no per-modality qualifier needed.
+		if (modality.key === "data") return `Search ${kind}...`;
+		return `Search ${modality.label.toLowerCase()} ${kind}...`;
+	});
+
+	// In "models" mode the HF API can only filter by pipeline_tag, so subtabs
+	// whose only constraint is a free-text query (e.g. Enhance, Remove BG) are
+	// hidden — they wouldn't return anything meaningful from the models API.
+	const visible_subtabs = $derived(
+		is_model
+			? modality.subtabs.filter((st) => {
+					if (st.key === "all") return true;
+					const model_tag_list = st.modelTags ?? st.pipelineTags;
+					return model_tag_list.length > 0;
+				})
+			: modality.subtabs
+	);
+
+	function set_source(next: Source): void {
+		if (next === source) return;
+		// Reset emptiness flags up front so the auto-switch effect can't
+		// fire on a stale value mid-source-change (same race as the
+		// subtab onclick).
+		trending_empty = null;
+		new_empty = null;
+		source = next;
+		// If the active subtab disappears in the new source, fall back to "all"
+		if (!visible_subtabs.some((st) => st.key === active_subtab.key)) {
+			active_subtab = visible_subtabs[0] ?? modality.subtabs[0];
+		}
+		if (active_content_tab === "search") {
+			search_query = "";
+			active_content_tab = "trending";
+		}
+	}
+
+	const AVATAR_COLORS = [
+		"#f97316",
+		"#8b5cf6",
+		"#3b82f6",
+		"#10b981",
+		"#ec4899",
+		"#f59e0b",
+		"#06b6d4",
+		"#84cc16"
+	];
+	function avatar_color(id: string): string {
+		let h = 5381;
+		for (let i = 0; i < id.length; i++) h = ((h << 5) + h) ^ id.charCodeAt(i);
+		return AVATAR_COLORS[Math.abs(h) % AVATAR_COLORS.length];
+	}
+	function avatar_initial(id: string): string {
+		return (id.split("/").pop() || id)[0].toUpperCase();
+	}
+
+	type ContentTab = "featured" | "trending" | "new" | "search";
+
+	let active_subtab = $state<SubTab>(
+		(initialSubtab && modality.subtabs.find((s) => s.key === initialSubtab)) ||
+			modality.subtabs[0]
+	);
+	let active_content_tab = $state<ContentTab>(
+		// Datasets API doesn't have a featured list, jump straight to search/trending.
+		// When entering with a specific subtab, Featured ignores subtab filters, so
+		// go to trending so the subtab actually narrows results.
+		modality.key === "data" || initialSubtab ? "trending" : "featured"
+	);
+	let zero_gpu_only = $state(false);
+
+	const featured_results = $derived.by(() => {
+		if (source === "datasets") return [];
+		const list = source === "models" ? FEATURED_MODELS : FEATURED_SPACES;
+		const cats = modality.acceptedCategories ?? [modality.category];
+		return list
+			.filter((item) => cats.includes(item.modality))
+			.map((item) => ({
+				id: item.id,
+				title: item.title,
+				description: item.description,
+				likes: item.likes ?? 0,
+				running: true,
+				category: item.modality,
+				pipeline_tag: item.pipeline_tag
+			}));
+	});
+
+	// If the active tab is known-empty, fall through to the next available
+	// one so the panel never sits on a blank tab. Cascade: featured →
+	// trending → new → search.
+	$effect(() => {
+		if (active_content_tab === "featured" && featured_results.length === 0) {
+			active_content_tab = "trending";
+		} else if (active_content_tab === "trending" && trending_empty === true) {
+			active_content_tab = new_empty === true ? "search" : "new";
+		} else if (active_content_tab === "new" && new_empty === true) {
+			active_content_tab = trending_empty === true ? "search" : "trending";
+		}
+	});
+	let search_query = $state("");
+	let results = $state<SpaceResult[]>([]);
+	let loading = $state(false);
+	let loading_space_id = $state<string | null>(null);
+
+	// Track per-tab emptiness so we can hide Trending / New when a fetch
+	// confirms there are no matching results. Reset to null (unknown) when
+	// any filter changes that affects the fetch, so the next fetch can
+	// re-evaluate. Featured tabs are handled separately via featured_results.
+	let trending_empty = $state<boolean | null>(null);
+	let new_empty = $state<boolean | null>(null);
+
+	const display_results = $derived(
+		active_content_tab === "featured" ? featured_results : results
+	);
+	let search_timeout: ReturnType<typeof setTimeout> | null = null;
+	let fetch_token = 0;
+
+	function parse_results(raw: any): SpaceResult[] {
+		if (!Array.isArray(raw)) return [];
+		return raw.map((s: any) => {
+			const desc =
+				s.cardData?.short_description || s.ai_short_description || "";
+			return {
+				id: s.id,
+				title: s.cardData?.title || s.title || s.id.split("/").pop() || s.id,
+				description: desc,
+				likes: s.likes ?? 0,
+				running: s.runtime?.stage === "RUNNING",
+				category: categorizeSpace(
+					s.cardData?.pipeline_tag || s.pipeline_tag,
+					s.cardData?.tags,
+					desc,
+					s.id
+				),
+				pipeline_tag: s.cardData?.pipeline_tag || s.pipeline_tag || undefined
+			};
+		});
+	}
+
+	async function fetch_results() {
+		if (is_dataset) {
+			await fetch_datasets(search_query);
+			return;
+		}
+		if (is_model) {
+			await fetch_models(search_query);
+			return;
+		}
+		if (!server?.search_spaces) {
+			results = [];
+			return;
+		}
+		const token = ++fetch_token;
+		loading = true;
+		try {
+			// Spaces use the per-subtab `spaceTags` override when present
+			// (category names like "image-editing") and fall back to
+			// `pipelineTags` for subtabs where the model pipeline tag
+			// works as a Space category too (e.g. text-to-image).
+			const space_tag_list =
+				active_subtab.spaceTags ?? active_subtab.pipelineTags;
+			const space_tag = space_tag_list.length > 0 ? space_tag_list[0] : "";
+
+			let kind: string;
+			let query: string;
+
+			if (active_content_tab === "search") {
+				kind = "search";
+				query = search_query;
+			} else if (active_subtab.query) {
+				// Always forward the subtab's freeform query alongside the
+				// category. The server prefers `category=` when valid and
+				// falls back to `q=` when the category isn't a real HF
+				// Space category (e.g. `automatic-speech-recognition`).
+				kind = active_content_tab === "new" ? "new" : "trending";
+				query = active_subtab.query;
+			} else {
+				kind = active_content_tab === "new" ? "new" : "trending";
+				query = "";
+			}
+
+			const raw = await server.search_spaces([
+				kind,
+				query,
+				space_tag,
+				"",
+				zero_gpu_only
+			]);
+			const data = typeof raw === "string" ? JSON.parse(raw) : raw;
+			let parsed = parse_results(data);
+
+			// Keep results that match the modality OR are uncategorised
+			// (most Gradio Spaces lack a pipeline_tag on their card).
+			if (active_content_tab !== "search" && !space_tag) {
+				const cats = modality.acceptedCategories ?? [modality.category];
+				parsed = parsed.filter((s) => !s.category || cats.includes(s.category));
+			}
+
+			if (token !== fetch_token) return;
+			results = parsed.slice(0, 20);
+		} catch {
+			if (token === fetch_token) results = [];
+		} finally {
+			if (token === fetch_token) loading = false;
+		}
+	}
+
+	async function fetch_datasets(query: string) {
+		if (!server?.search_datasets) {
+			results = [];
+			loading = false;
+			return;
+		}
+		const token = ++fetch_token;
+		loading = true;
+		try {
+			const raw = await server.search_datasets([query]);
+			if (token !== fetch_token) return;
+			const data = typeof raw === "string" ? JSON.parse(raw) : raw;
+			if (!Array.isArray(data)) {
+				results = [];
+				return;
+			}
+			results = data.slice(0, 20).map((d: any) => ({
+				id: d.id,
+				title: d.id.split("/").pop() || d.id,
+				description: d.description || d.cardData?.summary || "",
+				likes: d.likes ?? 0,
+				running: true,
+				category: "data",
+				pipeline_tag: undefined
+			}));
+		} catch {
+			if (token === fetch_token) results = [];
+		} finally {
+			if (token === fetch_token) loading = false;
+		}
+	}
+
+	async function fetch_models(q: string) {
+		if (!server?.search_models) {
+			results = [];
+			loading = false;
+			return;
+		}
+		const token = ++fetch_token;
+		loading = true;
+		try {
+			// Models use the per-subtab `modelTags` override when present
+			// and fall back to `pipelineTags`. `spaceTags` is ignored here
+			// because Space category names (e.g. "image-editing") aren't
+			// valid model pipeline tags.
+			const model_tag_list =
+				active_subtab.modelTags ?? active_subtab.pipelineTags;
+			const pipeline_tag = model_tag_list[0] ?? "";
+			let kind: string;
+			if (active_content_tab === "search") {
+				kind = "search";
+			} else {
+				kind = active_content_tab === "new" ? "new" : "trending";
+				q = "";
+			}
+			const raw = await server.search_models([kind, q, pipeline_tag, ""]);
+			if (token !== fetch_token) return;
+			const data = typeof raw === "string" ? JSON.parse(raw) : raw;
+			if (!Array.isArray(data)) {
+				results = [];
+				return;
+			}
+			results = data
+				.filter((m: any) => m.pipeline_tag && TASK_SCHEMAS[m.pipeline_tag])
+				.slice(0, 24)
+				.map((m: any) => ({
+					id: m.id,
+					title: m.id.split("/").pop() || m.id,
+					description: m.pipeline_tag || "",
+					likes: m.likes ?? 0,
+					running: true,
+					category: "model",
+					pipeline_tag: m.pipeline_tag
+				}));
+		} catch {
+			if (token === fetch_token) results = [];
+		} finally {
+			if (token === fetch_token) loading = false;
+		}
+	}
+
+	// Fetch when tab/subtab/mode changes (Featured is static, no API call).
+	// After each fetch, record whether the active tab came back empty so we
+	// can hide it from the tab strip.
+	$effect(() => {
+		active_subtab;
+		active_content_tab;
+		is_dataset;
+		is_model;
+		zero_gpu_only;
+		if (active_content_tab !== "search" && active_content_tab !== "featured") {
+			const captured = active_content_tab;
+			void fetch_results().then(() => {
+				if (captured === "trending") trending_empty = results.length === 0;
+				else if (captured === "new") new_empty = results.length === 0;
+			});
+		} else if (active_content_tab === "search" && search_query.length >= 2) {
+			void fetch_results();
+		}
+	});
+
+	function handle_search_input(e: Event) {
+		search_query = (e.currentTarget as HTMLInputElement).value;
+		if (search_timeout) clearTimeout(search_timeout);
+		if (is_dataset) {
+			loading = true;
+			search_timeout = setTimeout(() => void fetch_datasets(search_query), 150);
+			return;
+		}
+		if (is_model) {
+			if (search_query.length < 2) {
+				if (active_content_tab === "search") results = [];
+				return;
+			}
+			active_content_tab = "search";
+			loading = true;
+			search_timeout = setTimeout(() => void fetch_models(search_query), 150);
+			return;
+		}
+		if (search_query.length < 2) {
+			if (active_content_tab === "search") results = [];
+			return;
+		}
+		active_content_tab = "search";
+		loading = true;
+		search_timeout = setTimeout(() => void fetch_results(), 150);
+	}
+
+	function select_model(item: SpaceResult) {
+		if (!item.pipeline_tag) return;
+		const schema = TASK_SCHEMAS[item.pipeline_tag];
+		const template = {
+			label: item.id.split("/").pop() || item.id,
+			kind: "transform" as const,
+			source: "model" as const,
+			model_id: item.id,
+			pipeline_tag: item.pipeline_tag,
+			inputs: normalizeOperatorPorts(modality, schema?.inputs ?? []),
+			outputs: normalizeOperatorPorts(modality, schema?.outputs ?? []),
+			width: 280,
+			height: 90
+		};
+		if (mode === "update" && nodeId) {
+			onupdate(nodeId, template);
+		} else {
+			oncreate(template);
+		}
+		onclose();
+	}
+
+	async function select_space(space: SpaceResult) {
+		if (loading_space_id) return;
+		loading_space_id = space.id;
+		try {
+			const api_info = await fetchSpaceApi(space.id);
+			const template = {
+				label: space.title || space.id.split("/").pop() || space.id,
+				kind: "transform" as const,
+				source: "space" as const,
+				space_id: space.id,
+				pipeline_tag: space.pipeline_tag,
+				endpoint: api_info.endpoint,
+				endpoints: api_info.endpoints,
+				inputs: normalizeOperatorPorts(modality, api_info.inputs),
+				outputs: normalizeOperatorPorts(modality, api_info.outputs),
+				width: api_info.width,
+				height: 90
+			};
+			if (mode === "update" && nodeId) {
+				onupdate(nodeId, template);
+			} else {
+				oncreate(template);
+			}
+			onclose();
+		} catch (err) {
+			loading_space_id = null;
+			const msg = err instanceof Error ? err.message : "Couldn't load space";
+			const label = space.title || space.id;
+			onerror?.(`${label}: ${msg}`);
+		}
+	}
+
+	function feature_to_port_type(feature: any): string {
+		const t = feature?.type;
+		if (!t) return "json";
+		if (t._type === "Image" || t.dtype === "image") return "image";
+		if (t._type === "Audio" || t.dtype === "audio") return "audio";
+		if (t._type === "Video" || t.dtype === "video") return "video";
+		if (t._type === "ClassLabel") return "text";
+		if (t._type === "Translation" || t._type === "TranslationVariableLanguages")
+			return "text";
+		if (t._type === "Value") {
+			if (t.dtype === "string") return "text";
+			if (t.dtype?.includes("int") || t.dtype?.includes("float"))
+				return "number";
+			if (t.dtype === "bool") return "boolean";
+		}
+		return "json";
+	}
+
+	async function select_dataset(dataset: SpaceResult) {
+		loading_space_id = dataset.id;
+		let outputs: Array<{ id: string; label: string; type: string }> = [
+			{ id: "out_0", label: "Data", type: "json" }
+		];
+		let config = "default";
+		let split = "train";
+		try {
+			if (server?.get_dataset_schema) {
+				const raw = await server.get_dataset_schema([dataset.id]);
+				const schema = typeof raw === "string" ? JSON.parse(raw) : raw;
+				if (
+					!schema.error &&
+					Array.isArray(schema.features) &&
+					schema.features.length > 0
+				) {
+					config = schema.config ?? "default";
+					split = schema.split ?? "train";
+					const ports = schema.features.map((f: any, i: number) => ({
+						id: `out_${i}`,
+						label: f.name,
+						type: feature_to_port_type(f)
+					}));
+					if (ports.length > 0) outputs = ports;
+				}
+			}
+		} catch {
+		} finally {
+			loading_space_id = null;
+		}
+		oncreate({
+			label: dataset.title || dataset.id.split("/").pop() || dataset.id,
+			kind: "transform" as const,
+			source: "dataset" as const,
+			dataset_id: dataset.id,
+			dataset_config: config,
+			dataset_split: split,
+			// Single scalar input: row index. Inline-editable when not wired
+			// (the standard `.port-inline-config` block handles the widget);
+			// accepts upstream numbers/fns when wired.
+			inputs: [
+				{
+					id: "row_index",
+					label: "Row",
+					type: "number" as const,
+					default_value: 0
+				}
+			],
+			outputs,
+			width: 240,
+			height: 90
+		});
+		onclose();
+	}
+
+	function hub_url(id: string): string {
+		if (is_dataset) return `https://huggingface.co/datasets/${id}`;
+		if (is_model) return `https://huggingface.co/${id}`;
+		return `https://huggingface.co/spaces/${id}`;
+	}
+
+	function handle_row_click(item: SpaceResult) {
+		if (is_dataset) {
+			void select_dataset(item);
+		} else if (is_model) {
+			select_model(item);
+		} else {
+			select_space(item);
+		}
+	}
+
+	function format_likes(n: number): string {
+		if (n >= 1000) return `${(n / 1000).toFixed(1)}k`;
+		return String(n);
+	}
+</script>
+
+<!-- svelte-ignore a11y_no_static_element_interactions -->
+<div class="picker-overlay" onclick={onclose}>
+	<!-- svelte-ignore a11y_no_static_element_interactions -->
+	<div
+		class="picker-panel"
+		class:picker-panel-anchored={anchorX !== undefined}
+		style={anchorX !== undefined
+			? `left:${anchorX}px; top:${anchorY ?? 0}px;`
+			: ""}
+		onclick={(e) => e.stopPropagation()}
+		onwheel={(e) => e.stopPropagation()}
+	>
+		<!-- Search row — input only. Mode tabs (Featured / Trending / New)
+		     live in the subtab strip below so they share visual weight
+		     with the modality categories (Generate / Edit / …). -->
+		<div class="picker-search-row">
+			<div class="picker-search-wrap">
+				<span class="search-icon">
+					<SearchIcon />
+				</span>
+				<input
+					class="picker-search"
+					type="text"
+					placeholder={search_placeholder}
+					value={search_query}
+					oninput={handle_search_input}
+					autofocus
+				/>
+				<button
+					class="picker-close-inline"
+					onclick={onclose}
+					aria-label="Close"
+				>
+					<CloseIcon />
+				</button>
+			</div>
+		</div>
+
+		<!-- Source toggle (Spaces / Models) — hidden for datasets -->
+		{#if show_source_toggle}
+			<div class="picker-source-row">
+				<button
+					class="picker-source-btn"
+					class:active={source === "spaces"}
+					onclick={() => set_source("spaces")}>Spaces</button
+				>
+				<button
+					class="picker-source-btn"
+					class:active={source === "models"}
+					onclick={() => set_source("models")}>Models</button
+				>
+			</div>
+		{/if}
+
+		<!-- Modality subtabs: which kind of Space (Generate / Edit / …). -->
+		{#if !is_dataset && visible_subtabs.length > 1}
+			<div class="picker-subtabs">
+				{#each visible_subtabs as st}
+					<button
+						class="picker-subtab"
+						class:active={active_subtab.key === st.key}
+						onclick={() => {
+							// Reset emptiness flags BEFORE writing active_subtab /
+							// active_content_tab. Otherwise the auto-switch effect
+							// can fire first and read a stale `trending_empty=true`
+							// from the previous subtab, bumping active_content_tab
+							// to "search" — which then fetches the wrong list.
+							trending_empty = null;
+							new_empty = null;
+							active_subtab = st;
+							if (active_content_tab !== "search")
+								active_content_tab = "trending";
+						}}
+					>
+						{st.label}
+					</button>
+				{/each}
+			</div>
+		{/if}
+
+		<!-- Content modes: how the list is sorted (Featured / Trending / New).
+		     Smaller and lighter than the category subtabs so they read as
+		     a secondary sort control, not a competing category. -->
+		{#if !is_dataset}
+			<div class="picker-mode-row">
+				<span class="picker-mode-label">Sort:</span>
+				{#if featured_results.length > 0}
+					<button
+						class="picker-mode-btn"
+						class:active={active_content_tab === "featured"}
+						onclick={() => {
+							active_content_tab = "featured";
+							search_query = "";
+						}}>Featured</button
+					>
+				{/if}
+				{#if trending_empty !== true}
+					<button
+						class="picker-mode-btn"
+						class:active={active_content_tab === "trending"}
+						onclick={() => {
+							active_content_tab = "trending";
+							search_query = "";
+						}}>Trending</button
+					>
+				{/if}
+				{#if new_empty !== true}
+					<button
+						class="picker-mode-btn"
+						class:active={active_content_tab === "new"}
+						onclick={() => {
+							active_content_tab = "new";
+							search_query = "";
+						}}>New ✦</button
+					>
+				{/if}
+				{#if is_spaces}
+					<label
+						class="picker-zerogpu-toggle"
+						title="Show only ZeroGPU Spaces — these scale with your HF credits and rarely hit quota"
+					>
+						<input type="checkbox" bind:checked={zero_gpu_only} />
+						<span>ZeroGPU only</span>
+					</label>
+				{/if}
+			</div>
+		{/if}
+
+		<!-- Results -->
+		<div class="picker-results" class:picker-results-stale={loading}>
+			{#if loading && display_results.length === 0 && active_content_tab !== "featured"}
+				<div class="picker-loading">
+					<span class="spinner"></span>
+				</div>
+			{:else if display_results.length === 0}
+				<div class="picker-empty">
+					{active_content_tab === "search"
+						? "Nothing found"
+						: active_content_tab === "featured"
+							? `No featured ${source} for ${modality.label.toLowerCase()} yet`
+							: `No ${modality.label.toLowerCase()} ${source} found`}
+				</div>
+			{:else}
+				{#each display_results as space (space.id)}
+					<!-- svelte-ignore a11y_no_static_element_interactions -->
+					<div
+						class="space-row"
+						class:loading={loading_space_id === space.id}
+						onclick={() => handle_row_click(space)}
+						role="button"
+						tabindex="0"
+					>
+						<div
+							class="space-avatar"
+							style="background:linear-gradient(135deg, {avatar_color(
+								space.id
+							)}, {avatar_color(space.id + '_2')})"
+						>
+							{avatar_initial(space.id)}
+						</div>
+						<div class="space-row-left">
+							<div class="space-name-row">
+								<span class="space-name"
+									>{space.title ||
+										(space.id.split("/").pop() ?? space.id)}</span
+								>
+								{#if active_content_tab === "featured"}
+									<span class="space-badge space-badge-featured">Featured</span>
+								{/if}
+								{#if space.pipeline_tag}
+									<span class="space-badge">{space.pipeline_tag}</span>
+								{/if}
+							</div>
+							{#if space.description}
+								<div class="space-desc">{space.description}</div>
+							{/if}
+						</div>
+						<div class="space-row-right">
+							{#if loading_space_id === space.id}
+								<span class="spinner small"></span>
+							{:else if space.likes > 0}
+								<span class="space-likes">♥ {format_likes(space.likes)}</span>
+							{/if}
+							<a
+								class="space-row-link"
+								href={hub_url(space.id)}
+								target="_blank"
+								rel="noopener noreferrer"
+								title="Open on HuggingFace"
+								aria-label="Open on HuggingFace"
+								onclick={(e) => e.stopPropagation()}
+								onmousedown={(e) => e.stopPropagation()}
+							>
+								<OpenLinkIcon />
+							</a>
+						</div>
+					</div>
+				{/each}
+			{/if}
+		</div>
+	</div>
+</div>
+
+<style>
+	/* Reuse toast-in animation from WorkflowCanvas.css */
+	@keyframes wf-toast-in {
+		from {
+			opacity: 0;
+			transform: translateY(6px);
+		}
+		to {
+			opacity: 1;
+			transform: translateY(0);
+		}
+	}
+	.picker-overlay {
+		position: absolute;
+		inset: 0;
+		z-index: 50;
+		pointer-events: none;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		/* Compensate for the bottom bar (~60px) so the panel is centered in
+		 * the visible canvas area, not the raw viewport. Extra few px of
+		 * bottom padding keeps the optical center balanced against the top
+		 * toolbar. */
+		padding-bottom: 72px;
+		padding-top: 8px;
+		box-sizing: border-box;
+	}
+
+	.picker-panel {
+		pointer-events: auto;
+		width: 520px;
+		/* Lock the panel to a fixed height so switching tabs (Featured /
+		 * Trending / New) doesn't make the modal jump up and down. The
+		 * results list scrolls inside; on short viewports we cap to leave
+		 * room for the toolbar and bottom bar. */
+		height: min(620px, calc(100vh - 160px));
+		background: #13141c;
+		border: 1px solid #2a2b36;
+		border-radius: 16px;
+		box-shadow:
+			0 20px 60px rgba(0, 0, 0, 0.6),
+			0 0 0 1px rgba(255, 255, 255, 0.04);
+		display: flex;
+		flex-direction: column;
+		overflow: hidden;
+		animation: wf-toast-in 0.12s ease-out;
+	}
+
+	.picker-panel-anchored {
+		position: absolute;
+	}
+
+	.picker-close-inline {
+		position: absolute;
+		right: 8px;
+		top: 50%;
+		transform: translateY(-50%);
+		width: 22px;
+		height: 22px;
+		border: none;
+		border-radius: 50%;
+		background: transparent;
+		color: #5c5e6a;
+		font-size: 16px;
+		line-height: 1;
+		cursor: pointer;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		flex-shrink: 0;
+		padding: 0;
+		transition:
+			background 0.15s,
+			color 0.15s;
+	}
+
+	.picker-close-inline:hover {
+		background: #1e1f2a;
+		color: #a0a2ae;
+	}
+
+	:global(body:not(.dark)) .picker-close-inline {
+		color: #8b8d98;
+	}
+
+	:global(body:not(.dark)) .picker-close-inline:hover {
+		background: rgba(0, 0, 0, 0.06);
+		color: #3e4050;
+	}
+
+	.picker-search-row {
+		padding: 14px 16px 0;
+		flex-shrink: 0;
+	}
+
+	.picker-search-wrap {
+		position: relative;
+		display: flex;
+		align-items: center;
+	}
+
+	.picker-mode-row {
+		display: flex;
+		align-items: center;
+		gap: 4px;
+		padding: 6px 16px 0;
+		flex-shrink: 0;
+	}
+
+	.picker-mode-label {
+		font-family: "Manrope", sans-serif;
+		font-size: 10px;
+		font-weight: 700;
+		text-transform: uppercase;
+		letter-spacing: 0.06em;
+		color: #4a4d57;
+		margin-right: 4px;
+	}
+
+	.picker-mode-btn {
+		padding: 3px 8px;
+		border: none;
+		border-radius: 14px;
+		background: transparent;
+		color: #6b6e78;
+		font-family: "Manrope", sans-serif;
+		font-size: 11px;
+		font-weight: 500;
+		cursor: pointer;
+		transition:
+			background 0.1s,
+			color 0.1s;
+	}
+
+	.picker-mode-btn:hover {
+		color: #c8c9d2;
+		background: rgba(255, 255, 255, 0.04);
+	}
+
+	.picker-mode-btn.active {
+		color: #f97316;
+		background: rgba(249, 115, 22, 0.08);
+	}
+
+	.picker-zerogpu-toggle {
+		margin-left: auto;
+		display: inline-flex;
+		align-items: center;
+		gap: 5px;
+		font-size: 10.5px;
+		color: #6b6e78;
+		cursor: pointer;
+		user-select: none;
+	}
+
+	.picker-zerogpu-toggle input {
+		accent-color: #f97316;
+		cursor: pointer;
+		margin: 0;
+	}
+
+	.picker-zerogpu-toggle:hover {
+		color: #a0a2ae;
+	}
+
+	:global(body:not(.dark)) .picker-zerogpu-toggle {
+		color: #6b6e78;
+	}
+
+	:global(body:not(.dark)) .picker-zerogpu-toggle:hover {
+		color: #3e4050;
+	}
+
+	:global(body:not(.dark)) .picker-mode-label {
+		color: #8b8d98;
+	}
+
+	:global(body:not(.dark)) .picker-mode-btn {
+		color: #8b8d98;
+	}
+
+	:global(body:not(.dark)) .picker-mode-btn:hover {
+		color: #3e4050;
+		background: rgba(0, 0, 0, 0.04);
+	}
+
+	:global(body:not(.dark)) .picker-mode-btn.active {
+		color: #ea580c;
+		background: rgba(249, 115, 22, 0.1);
+	}
+
+	.search-icon {
+		position: absolute;
+		left: 13px;
+		display: inline-flex;
+		color: #4a4d57;
+		pointer-events: none;
+		flex-shrink: 0;
+	}
+
+	.picker-search {
+		flex: 1;
+		min-width: 0;
+		padding: 11px 40px 11px 36px;
+		background: #0c0d10;
+		border: 1px solid #2a2b36;
+		border-radius: 10px;
+		font-family: "Manrope", sans-serif;
+		font-size: 14px;
+		color: #d5d6de;
+		outline: none;
+		transition:
+			border-color 0.15s,
+			box-shadow 0.15s;
+	}
+
+	.picker-search::placeholder {
+		color: #3e4050;
+	}
+
+	.picker-search:focus {
+		border-color: #f97316;
+		box-shadow: 0 0 0 3px rgba(249, 115, 22, 0.1);
+	}
+
+	.picker-source-row {
+		display: flex;
+		gap: 4px;
+		padding: 8px 10px 0;
+		flex-shrink: 0;
+	}
+
+	.picker-source-btn {
+		flex: 1;
+		padding: 6px 10px;
+		border: 1px solid #1e1f2a;
+		border-radius: 6px;
+		background: transparent;
+		color: #6b6e78;
+		font-family: "Manrope", sans-serif;
+		font-size: 11.5px;
+		font-weight: 600;
+		cursor: pointer;
+		transition:
+			background 0.15s,
+			color 0.15s,
+			border-color 0.15s;
+	}
+
+	.picker-source-btn:hover {
+		background: rgba(255, 255, 255, 0.04);
+		color: #c8c9d2;
+	}
+
+	.picker-source-btn.active {
+		background: rgba(249, 115, 22, 0.12);
+		border-color: rgba(249, 115, 22, 0.35);
+		color: #f97316;
+	}
+
+	:global(body:not(.dark)) .picker-source-btn {
+		border-color: #e2e4ea;
+		color: #6b6e78;
+	}
+
+	:global(body:not(.dark)) .picker-source-btn:hover {
+		background: #f0f1f5;
+		color: #1a1b25;
+	}
+
+	:global(body:not(.dark)) .picker-source-btn.active {
+		background: rgba(249, 115, 22, 0.1);
+		border-color: rgba(249, 115, 22, 0.35);
+		color: #d65500;
+	}
+
+	.picker-subtabs {
+		display: flex;
+		gap: 2px;
+		padding: 8px 10px 0;
+		flex-shrink: 0;
+		flex-wrap: wrap;
+	}
+
+	.picker-subtab {
+		padding: 4px 10px;
+		border: 1px solid transparent;
+		border-radius: 20px;
+		background: transparent;
+		color: #5c5e6a;
+		font-family: "Manrope", sans-serif;
+		font-size: 11px;
+		font-weight: 600;
+		cursor: pointer;
+		transition:
+			background 0.15s,
+			color 0.15s,
+			border-color 0.15s;
+	}
+
+	.picker-subtab:hover {
+		background: rgba(255, 255, 255, 0.05);
+		color: #a0a2ae;
+	}
+
+	.picker-subtab.active {
+		background: rgba(249, 115, 22, 0.12);
+		border-color: rgba(249, 115, 22, 0.3);
+		color: #f97316;
+	}
+
+	.picker-tabs {
+		display: flex;
+		gap: 0;
+		padding: 8px 10px 0;
+		border-bottom: 1px solid #1e1f2a;
+		flex-shrink: 0;
+	}
+
+	.picker-tab {
+		padding: 6px 14px;
+		border: none;
+		border-bottom: 2px solid transparent;
+		background: transparent;
+		color: #5c5e6a;
+		font-family: "Manrope", sans-serif;
+		font-size: 12px;
+		font-weight: 600;
+		cursor: pointer;
+		margin-bottom: -1px;
+		transition:
+			color 0.15s,
+			border-color 0.15s;
+	}
+
+	.picker-tab:hover {
+		color: #a0a2ae;
+	}
+
+	.picker-tab.active {
+		color: #d5d6de;
+		border-bottom-color: #f97316;
+	}
+
+	.picker-results {
+		flex: 1;
+		overflow-y: auto;
+		padding: 6px 8px 10px;
+		scrollbar-width: thin;
+		scrollbar-color: #2a2b36 transparent;
+		transition: opacity 0.12s ease;
+	}
+
+	.picker-results-stale {
+		opacity: 0.55;
+	}
+
+	.picker-loading {
+		display: flex;
+		justify-content: center;
+		padding: 60px;
+	}
+
+	.picker-empty {
+		text-align: center;
+		padding: 60px 24px;
+		font-family: "Manrope", sans-serif;
+		font-size: 13px;
+		color: #4a4d57;
+	}
+
+	.space-avatar {
+		width: 52px;
+		height: 52px;
+		border-radius: 12px;
+		font-size: 22px;
+		font-weight: 700;
+		color: rgba(0, 0, 0, 0.55);
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		flex-shrink: 0;
+		text-shadow: 0 1px 2px rgba(255, 255, 255, 0.15);
+		box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.15);
+	}
+
+	.space-row {
+		display: flex;
+		align-items: center;
+		gap: 14px;
+		padding: 10px 12px;
+		border-radius: 10px;
+		cursor: pointer;
+		transition: background 0.12s;
+	}
+
+	.space-row:hover {
+		background: rgba(255, 255, 255, 0.04);
+	}
+
+	.space-row.loading {
+		opacity: 0.6;
+		pointer-events: none;
+	}
+
+	.space-row-left {
+		flex: 1;
+		min-width: 0;
+	}
+
+	.space-name-row {
+		display: flex;
+		align-items: center;
+		gap: 8px;
+		min-width: 0;
+	}
+
+	.space-name {
+		font-family: "Manrope", sans-serif;
+		font-size: 14px;
+		font-weight: 700;
+		color: #e8e9f0;
+		white-space: nowrap;
+		overflow: hidden;
+		text-overflow: ellipsis;
+	}
+
+	.space-badge {
+		display: inline-flex;
+		align-items: center;
+		padding: 2px 7px;
+		border-radius: 10px;
+		background: rgba(255, 255, 255, 0.06);
+		color: #8b8d98;
+		font-family: "Manrope", sans-serif;
+		font-size: 10px;
+		font-weight: 600;
+		white-space: nowrap;
+		flex-shrink: 0;
+	}
+
+	.space-badge-featured {
+		background: rgba(249, 115, 22, 0.14);
+		color: #f97316;
+	}
+
+	.space-desc {
+		font-family: "Manrope", sans-serif;
+		font-size: 12.5px;
+		color: #7a7d88;
+		margin-top: 3px;
+		white-space: nowrap;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		line-height: 1.35;
+	}
+
+	.space-row-right {
+		display: flex;
+		align-items: center;
+		gap: 10px;
+		flex-shrink: 0;
+	}
+
+	.space-likes {
+		font-family: "Manrope", sans-serif;
+		font-size: 11px;
+		font-weight: 600;
+		color: #4a4d57;
+	}
+
+	.space-row-link {
+		display: inline-flex;
+		align-items: center;
+		justify-content: center;
+		width: 22px;
+		height: 22px;
+		border-radius: 6px;
+		color: #4a4d57;
+		text-decoration: none;
+		opacity: 0;
+		transition:
+			opacity 0.15s,
+			color 0.15s,
+			background 0.15s;
+	}
+
+	.space-row:hover .space-row-link,
+	.space-row:focus-within .space-row-link {
+		opacity: 1;
+	}
+
+	.space-row-link:hover {
+		color: #f97316;
+		background: rgba(249, 115, 22, 0.08);
+	}
+
+	.spinner {
+		display: inline-block;
+		width: 18px;
+		height: 18px;
+		border: 2px solid #2a2b36;
+		border-top-color: #f97316;
+		border-radius: 50%;
+		animation: spin 0.7s linear infinite;
+	}
+
+	.spinner.small {
+		width: 14px;
+		height: 14px;
+		border-width: 1.5px;
+	}
+
+	@keyframes spin {
+		to {
+			transform: rotate(360deg);
+		}
+	}
+
+	/* Light mode */
+	:global(body:not(.dark)) .picker-panel {
+		background: #ffffff;
+		border-color: #e2e4ea;
+		box-shadow:
+			0 12px 40px rgba(0, 0, 0, 0.12),
+			0 0 0 1px rgba(0, 0, 0, 0.04);
+	}
+
+	:global(body:not(.dark)) .picker-search {
+		background: #f8f9fb;
+		border-color: #e2e4ea;
+		color: #1a1b25;
+	}
+
+	:global(body:not(.dark)) .picker-search::placeholder {
+		color: #b0b2bc;
+	}
+
+	:global(body:not(.dark)) .picker-search:focus {
+		background: #ffffff;
+	}
+
+	:global(body:not(.dark)) .picker-tabs {
+		border-bottom-color: #e2e4ea;
+	}
+
+	:global(body:not(.dark)) .picker-tab {
+		color: #8b8d98;
+	}
+
+	:global(body:not(.dark)) .picker-tab.active {
+		color: #1a1b25;
+	}
+
+	:global(body:not(.dark)) .space-row:hover {
+		background: #f4f5f8;
+	}
+
+	:global(body:not(.dark)) .space-name {
+		color: #1a1b25;
+	}
+
+	:global(body:not(.dark)) .space-desc {
+		color: #6b6e78;
+	}
+
+	:global(body:not(.dark)) .space-badge {
+		background: #eef0f4;
+		color: #6b6e78;
+	}
+
+	:global(body:not(.dark)) .space-badge-featured {
+		background: rgba(249, 115, 22, 0.12);
+		color: #c84a00;
+	}
+
+	:global(body:not(.dark)) .space-likes {
+		color: #b0b2bc;
+	}
+
+	:global(body:not(.dark)) .picker-empty {
+		color: #b0b2bc;
+	}
+
+	:global(body:not(.dark)) .space-avatar {
+		color: rgba(0, 0, 0, 0.55);
+	}
+</style>

6.17.1/workflowcanvas/workflow/NodeWidget.svelte

@@ -0,0 +1,690 @@
+<script lang="ts">
+	import type {
+		WFNode,
+		PortType,
+		NodeDataValue,
+		FileValue
+	} from "./workflow-types";
+	import { BaseTextbox } from "@gradio/textbox";
+	import { BaseStaticImage } from "@gradio/image";
+	import DownloadIcon from "./icons/DownloadIcon.svelte";
+
+	interface Props {
+		node: WFNode;
+		widgetPortId: string;
+		widgetType: PortType;
+		isReadonly: boolean;
+		ondatachange: (
+			nodeId: string,
+			portId: string,
+			value: NodeDataValue
+		) => void;
+	}
+
+	let { node, widgetPortId, widgetType, isReadonly, ondatachange }: Props =
+		$props();
+
+	let fileInputEl: HTMLInputElement | undefined = $state();
+
+	function getTextValue(): string {
+		const v = node.data?.[widgetPortId];
+		return typeof v === "string" ? v : "";
+	}
+
+	function getFileValue(): FileValue | null {
+		const v = node.data?.[widgetPortId];
+		return v && typeof v === "object" ? v : null;
+	}
+
+	function getNumberValue(): number {
+		const v = node.data?.[widgetPortId];
+		return typeof v === "number" ? v : 0;
+	}
+
+	function getBooleanValue(): boolean {
+		const v = node.data?.[widgetPortId];
+		return typeof v === "boolean" ? v : false;
+	}
+
+	function handleNumberInput(e: Event) {
+		const target = e.currentTarget as HTMLInputElement;
+		ondatachange(node.id, widgetPortId, parseFloat(target.value) || 0);
+	}
+
+	function handleBooleanInput(e: Event) {
+		const target = e.currentTarget as HTMLInputElement;
+		ondatachange(node.id, widgetPortId, target.checked);
+	}
+
+	function revoke_old_blob(): void {
+		const old = getFileValue();
+		if (old?.url?.startsWith("blob:")) URL.revokeObjectURL(old.url);
+	}
+
+	function adopt_file(file: File): void {
+		revoke_old_blob();
+		ondatachange(node.id, widgetPortId, {
+			name: file.name,
+			url: URL.createObjectURL(file),
+			mime: file.type
+		});
+	}
+
+	function handleFileSelect(e: Event) {
+		const file = (e.currentTarget as HTMLInputElement).files?.[0];
+		if (file) adopt_file(file);
+	}
+
+	function handleFileDrop(e: DragEvent) {
+		e.preventDefault();
+		e.stopPropagation();
+		const file = e.dataTransfer?.files?.[0];
+		if (file) adopt_file(file);
+	}
+
+	function clearFile() {
+		revoke_old_blob();
+		ondatachange(node.id, widgetPortId, null);
+	}
+
+	/**
+	 * Download the current file value. Same-origin and blob/data URLs work
+	 * via a direct `<a download>`. Cross-origin URLs (e.g. HF Inference
+	 * results) often ignore the download attribute and navigate instead,
+	 * so we fetch into a blob first and then trigger the link on the
+	 * resulting object URL — that forces a save instead of a tab swap.
+	 */
+	async function downloadFile() {
+		const v = getFileValue();
+		if (!v?.url) return;
+		const name = v.name || "download";
+		const sameOrigin =
+			v.url.startsWith("blob:") ||
+			v.url.startsWith("data:") ||
+			(v.url.startsWith("http") &&
+				new URL(v.url, window.location.origin).origin ===
+					window.location.origin) ||
+			!v.url.startsWith("http");
+		try {
+			const url = sameOrigin
+				? v.url
+				: await fetch(v.url)
+						.then((r) => r.blob())
+						.then((b) => URL.createObjectURL(b));
+			const a = document.createElement("a");
+			a.href = url;
+			a.download = name;
+			document.body.appendChild(a);
+			a.click();
+			document.body.removeChild(a);
+			if (!sameOrigin) setTimeout(() => URL.revokeObjectURL(url), 1000);
+		} catch {
+			// Fall back to navigating; user can right-click → save.
+			window.open(v.url, "_blank", "noopener");
+		}
+	}
+
+	const i18n = (key: string) => key;
+	async function stubUpload(files: File[]): Promise<any[]> {
+		return files.map((f) => ({
+			url: URL.createObjectURL(f),
+			orig_name: f.name,
+			path: f.name,
+			mime_type: f.type,
+			size: f.size
+		}));
+	}
+	async function stubStream(): Promise<any> {
+		return;
+	}
+</script>
+
+<!-- svelte-ignore a11y_no_static_element_interactions -->
+<div
+	class="widget-zone nodrag nopan"
+	class:text-full={widgetType === "text" || widgetType === "json"}
+	onmousedown={(e) => e.stopPropagation()}
+	onpointerdown={(e) => e.stopPropagation()}
+>
+	{#if widgetType === "text" || widgetType === "json"}
+		<div class="widget-text-wrap">
+			<div class="widget-gradio-wrap">
+				<BaseTextbox
+					value={getTextValue()}
+					label="text"
+					show_label={false}
+					lines={widgetType === "json" ? 4 : 3}
+					max_lines={8}
+					placeholder={isReadonly
+						? "Waiting for output..."
+						: widgetType === "json"
+							? '{"key": "value"}'
+							: "Enter text..."}
+					disabled={isReadonly}
+					oninput={(val) => ondatachange(node.id, widgetPortId, val)}
+				/>
+			</div>
+		</div>
+	{:else if widgetType === "number"}
+		<div class="widget-number-wrap">
+			{#if isReadonly}
+				<div class="widget-text-display">
+					{getNumberValue()}
+				</div>
+			{:else}
+				<input
+					class="widget-number"
+					type="number"
+					value={getNumberValue()}
+					oninput={handleNumberInput}
+					step="any"
+				/>
+			{/if}
+		</div>
+	{:else if widgetType === "boolean"}
+		<div class="widget-bool-wrap">
+			<label class="widget-checkbox-row">
+				<input
+					class="widget-checkbox"
+					type="checkbox"
+					checked={getBooleanValue()}
+					disabled={isReadonly}
+					onchange={handleBooleanInput}
+				/>
+				<span class="widget-checkbox-label"
+					>{getBooleanValue() ? "On" : "Off"}</span
+				>
+			</label>
+		</div>
+	{:else if widgetType === "image" || widgetType === "audio" || widgetType === "video" || widgetType === "file" || widgetType === "gallery" || widgetType === "model3d"}
+		{@const fileVal = getFileValue()}
+		{#if fileVal}
+			<div class="widget-preview">
+				{#if (widgetType === "image" || widgetType === "gallery") && isReadonly}
+					<div class="widget-gradio-wrap widget-gradio-image">
+						<BaseStaticImage
+							value={{
+								url: fileVal.url,
+								orig_name: fileVal.name,
+								path: fileVal.url,
+								mime_type: fileVal.mime
+							}}
+							show_label={false}
+							{i18n}
+							buttons={[]}
+						/>
+					</div>
+				{:else if widgetType === "image" || widgetType === "gallery"}
+					<img class="widget-img" src={fileVal.url} alt={fileVal.name} />
+				{:else if widgetType === "audio"}
+					<audio class="widget-audio" controls src={fileVal.url}></audio>
+				{:else if widgetType === "video"}
+					<video class="widget-video" controls src={fileVal.url}></video>
+				{:else}
+					<div class="widget-file-info">
+						<span class="widget-file-name">{fileVal.name}</span>
+					</div>
+				{/if}
+				<div class="widget-preview-actions">
+					<button
+						class="widget-action"
+						onclick={downloadFile}
+						title="Download {fileVal.name}"
+						aria-label="Download"
+					>
+						<DownloadIcon />
+					</button>
+					{#if !isReadonly}
+						<button
+							class="widget-action widget-clear"
+							onclick={clearFile}
+							title="Clear"
+							aria-label="Clear">&times;</button
+						>
+					{/if}
+				</div>
+			</div>
+		{:else if isReadonly}
+			<div class="widget-placeholder">Waiting for output...</div>
+		{:else}
+			<!-- svelte-ignore a11y_interactive_supports_focus -->
+			<div
+				class="widget-file-drop nodrag nopan"
+				role="button"
+				tabindex="0"
+				onclick={() => fileInputEl?.click()}
+				onkeydown={(e) => {
+					if (e.key === "Enter" || e.key === " ") fileInputEl?.click();
+				}}
+				onmousedown={(e) => e.stopPropagation()}
+				onpointerdown={(e) => e.stopPropagation()}
+				ondragover={(e) => {
+					e.preventDefault();
+					e.stopPropagation();
+				}}
+				ondrop={handleFileDrop}
+			>
+				<input
+					bind:this={fileInputEl}
+					type="file"
+					accept={widgetType === "image"
+						? "image/*"
+						: widgetType === "audio"
+							? "audio/*"
+							: widgetType === "video"
+								? "video/*"
+								: widgetType === "model3d"
+									? ".glb,.gltf,.obj,.stl"
+									: "*"}
+					onchange={handleFileSelect}
+					style="display: none"
+				/>
+				<span class="widget-drop-text">
+					Drop {widgetType} or click
+				</span>
+			</div>
+		{/if}
+	{/if}
+</div>
+
+<style>
+	/* ─── Gradio Component Wrapper ─── */
+	.widget-text-wrap,
+	.widget-number-wrap,
+	.widget-bool-wrap {
+		padding: 6px 12px 8px;
+	}
+
+	.widget-gradio-wrap {
+		font-size: 12px;
+		--input-text-size: 11px;
+		--input-text-weight: 400;
+		--input-padding: 8px 10px;
+		--input-background-fill: #101118;
+		--input-background-fill-focus: #101118;
+		--input-border-color: #1e1f2a;
+		--input-border-color-focus: var(--accent);
+		--input-border-width: 1px;
+		--input-radius: 6px;
+		--input-shadow: none;
+		--input-shadow-focus: 0 0 0 2px var(--accent-dim);
+		--input-placeholder-color: #4a4b58;
+		--body-text-color: #c8c9d2;
+		--font-sans: "JetBrains Mono", monospace;
+		--line-sm: 1.4;
+		--spacing-sm: 4px;
+		--weight-semibold: 600;
+		--layer-1: #101118;
+		--shadow-inset: none;
+		--button-secondary-background-fill: #1e1f2a;
+		--button-secondary-background-fill-hover: #2a2b36;
+		--button-secondary-text-color: #8b8d98;
+		--button-shadow-active: none;
+		--error-icon-color: #ef4444;
+	}
+
+	.widget-gradio-wrap :global(textarea),
+	.widget-gradio-wrap :global(input) {
+		font-family: "JetBrains Mono", monospace !important;
+		font-size: 11px !important;
+		line-height: 1.4 !important;
+		background: #101118 !important;
+		color: #c8c9d2 !important;
+		border: 1px solid #1e1f2a !important;
+		border-radius: 6px !important;
+		padding: 8px 10px !important;
+		outline: none !important;
+		box-shadow: none !important;
+	}
+
+	.widget-gradio-wrap :global(textarea:focus),
+	.widget-gradio-wrap :global(input:focus) {
+		border-color: var(--accent) !important;
+		box-shadow: 0 0 0 2px var(--accent-dim) !important;
+	}
+
+	.widget-gradio-wrap :global(textarea::placeholder),
+	.widget-gradio-wrap :global(input::placeholder) {
+		color: #4a4b58 !important;
+	}
+
+	.widget-gradio-wrap :global(.block),
+	.widget-gradio-wrap :global(.wrap),
+	.widget-gradio-wrap :global(.container) {
+		background: transparent !important;
+		border: none !important;
+		box-shadow: none !important;
+		padding: 0 !important;
+		margin: 0 !important;
+		gap: 0 !important;
+	}
+
+	.widget-gradio-wrap :global(.block.padded) {
+		padding: 0 !important;
+	}
+
+	.widget-gradio-wrap :global(.label-wrap),
+	.widget-gradio-wrap :global(.info-text),
+	.widget-gradio-wrap :global(.icon-button-wrapper),
+	.widget-gradio-wrap :global(.icon-buttons) {
+		display: none !important;
+	}
+
+	.widget-gradio-image {
+		overflow: hidden;
+		border-radius: 6px;
+	}
+
+	.widget-gradio-image :global(img) {
+		max-height: 140px !important;
+		width: 100% !important;
+		object-fit: contain !important;
+		display: block !important;
+	}
+
+	.widget-gradio-image :global(.image-container) {
+		max-height: 140px !important;
+		overflow: hidden !important;
+	}
+
+	.widget-gradio-image :global(.empty-wrapper) {
+		display: none !important;
+	}
+
+	.widget-gradio-wrap :global(textarea) {
+		min-height: 60px !important;
+		height: auto !important;
+		resize: vertical !important;
+	}
+
+	.widget-gradio-wrap :global(label) {
+		display: block !important;
+	}
+
+	.widget-gradio-wrap :global(.input-container) {
+		display: flex !important;
+	}
+
+	/* ─── Widget Zone ─── */
+	.widget-zone {
+		padding: 0;
+		border-top: 1px solid #1e1f2a;
+		/* Canvas blocks user-select to stop dbl-click selecting random
+		 * UI text; opt the widget back in so users can highlight + copy
+		 * text inside textboxes / display zones. */
+		user-select: text;
+		-webkit-user-select: text;
+	}
+
+	.widget-zone.text-full {
+		border-top: none;
+	}
+
+	.widget-zone.text-full .widget-text-wrap {
+		padding: 0;
+	}
+
+	.widget-zone.text-full :global(textarea) {
+		border-radius: 0 0 9px 9px !important;
+		border-top: 1px solid #1e1f2a !important;
+		border-left: none !important;
+		border-right: none !important;
+		border-bottom: none !important;
+		min-height: 120px !important;
+		width: 100% !important;
+		box-sizing: border-box !important;
+		resize: vertical !important;
+	}
+
+	.widget-zone.text-full :global(textarea:focus) {
+		border-top-color: var(--accent) !important;
+		box-shadow: none !important;
+	}
+
+	.widget-text-display {
+		font-family: "JetBrains Mono", monospace;
+		font-size: 11px;
+		line-height: 1.4;
+		padding: 8px 10px;
+		border: 1px solid #1e1f2a;
+		border-radius: 6px;
+		background: #101118;
+		color: #5c5e6a;
+		min-height: 42px;
+		max-height: 300px;
+		overflow-y: auto;
+		white-space: pre-wrap;
+		word-break: break-word;
+	}
+
+	.widget-number {
+		width: 100%;
+		font-family: "JetBrains Mono", monospace;
+		font-size: 12px;
+		border: 1px solid #1e1f2a;
+		border-radius: 6px;
+		padding: 8px 10px;
+		background: #101118;
+		color: #c8c9d2;
+		outline: none;
+		box-sizing: border-box;
+		transition: border-color 0.15s;
+	}
+
+	.widget-number:focus {
+		border-color: var(--accent);
+		box-shadow: 0 0 0 2px var(--accent-dim);
+	}
+
+	.widget-checkbox-row {
+		display: flex;
+		align-items: center;
+		gap: 8px;
+		padding: 6px 0;
+		cursor: pointer;
+	}
+
+	.widget-checkbox {
+		width: 16px;
+		height: 16px;
+		accent-color: var(--accent);
+		cursor: pointer;
+	}
+
+	.widget-checkbox-label {
+		font-family: "JetBrains Mono", monospace;
+		font-size: 11px;
+		color: #8b8d98;
+	}
+
+	.widget-file-info {
+		padding: 10px 12px;
+	}
+
+	.widget-file-name {
+		font-family: "JetBrains Mono", monospace;
+		font-size: 10.5px;
+		color: #8b8d98;
+		word-break: break-all;
+	}
+
+	.widget-file-drop {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		height: 80px;
+		border: none;
+		border-radius: 0 0 10px 10px;
+		background: #101118;
+		cursor: pointer;
+		transition: background 0.15s;
+	}
+
+	.widget-file-drop:hover {
+		background: #14151a;
+	}
+
+	.widget-file-drop input {
+		display: none;
+	}
+
+	.widget-drop-text {
+		font-size: 10.5px;
+		color: #4a4b58;
+	}
+
+	.widget-placeholder {
+		font-family: "JetBrains Mono", monospace;
+		font-size: 10px;
+		color: #2e2f3d;
+		text-align: center;
+		padding: 24px 0;
+		background: #101118;
+		border-radius: 0 0 10px 10px;
+	}
+
+	.widget-preview {
+		position: relative;
+		overflow: hidden;
+		border-radius: 0 0 10px 10px;
+	}
+
+	.widget-img {
+		display: block;
+		width: 100%;
+		max-height: 320px;
+		object-fit: contain;
+		background: #101118;
+	}
+
+	.widget-audio {
+		display: block;
+		width: 100%;
+		height: 36px;
+		border-radius: 5px;
+	}
+
+	.widget-video {
+		display: block;
+		width: 100%;
+		max-height: 100px;
+		object-fit: contain;
+		border-radius: 5px;
+	}
+
+	.widget-preview-actions {
+		position: absolute;
+		top: 4px;
+		right: 4px;
+		display: flex;
+		gap: 4px;
+		opacity: 0;
+		transition: opacity 0.15s;
+	}
+
+	.widget-preview:hover .widget-preview-actions {
+		opacity: 1;
+	}
+
+	.widget-action {
+		width: 22px;
+		height: 22px;
+		border-radius: 50%;
+		border: none;
+		background: rgba(0, 0, 0, 0.6);
+		color: #d5d6de;
+		font-size: 13px;
+		line-height: 1;
+		cursor: pointer;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		padding: 0;
+		transition:
+			background 0.15s,
+			color 0.15s;
+	}
+
+	.widget-action:hover {
+		background: rgba(0, 0, 0, 0.85);
+		color: #fff;
+	}
+
+	.widget-clear:hover {
+		background: rgba(239, 68, 68, 0.85);
+		color: #fff;
+	}
+
+	/* ─── Light mode ─── */
+	:global(body:not(.dark)) .widget-zone {
+		border-top-color: #e2e4ea;
+	}
+
+	:global(body:not(.dark)) .widget-gradio-wrap {
+		--input-background-fill: #f8f9fb;
+		--input-background-fill-focus: #ffffff;
+		--input-border-color: #e2e4ea;
+		--input-placeholder-color: #c0c2cc;
+		--body-text-color: #1a1b25;
+		--layer-1: #f8f9fb;
+		--button-secondary-background-fill: #f0f1f5;
+		--button-secondary-background-fill-hover: #e2e4ea;
+		--button-secondary-text-color: #6b6e78;
+	}
+
+	:global(body:not(.dark)) .widget-gradio-wrap :global(textarea),
+	:global(body:not(.dark)) .widget-gradio-wrap :global(input) {
+		background: #f8f9fb !important;
+		color: #1a1b25 !important;
+		border-color: #e2e4ea !important;
+	}
+
+	:global(body:not(.dark)) .widget-gradio-wrap :global(textarea::placeholder),
+	:global(body:not(.dark)) .widget-gradio-wrap :global(input::placeholder) {
+		color: #c0c2cc !important;
+	}
+
+	:global(body:not(.dark)) .widget-text-display {
+		background: #f8f9fb;
+		border-color: #e2e4ea;
+		color: #6b6e78;
+	}
+
+	:global(body:not(.dark)) .widget-number {
+		background: #f8f9fb;
+		border-color: #e2e4ea;
+		color: #1a1b25;
+	}
+
+	:global(body:not(.dark)) .widget-checkbox-label {
+		color: #6b6e78;
+	}
+
+	:global(body:not(.dark)) .widget-file-name {
+		color: #6b6e78;
+	}
+
+	:global(body:not(.dark)) .widget-file-drop {
+		background: #f8f9fb;
+		border-color: #d0d2dc;
+	}
+
+	:global(body:not(.dark)) .widget-file-drop:hover {
+		background: #f0f1f5;
+	}
+
+	:global(body:not(.dark)) .widget-drop-text {
+		color: #b0b2bc;
+	}
+
+	:global(body:not(.dark)) .widget-placeholder {
+		background: #f8f9fb;
+		border-color: #e2e4ea;
+		color: #b0b2bc;
+	}
+
+	:global(body:not(.dark)) .widget-preview {
+		background: #f8f9fb;
+		border-color: #e2e4ea;
+	}
+</style>

6.17.1/workflowcanvas/workflow/WorkflowBottomBar.svelte

@@ -0,0 +1,444 @@
+<script lang="ts">
+	import { MODALITIES, DATASET_MODALITY } from "./workflow-modalities";
+	import type { ModalityConfig } from "./workflow-modalities";
+	import ImageIcon from "./icons/ImageIcon.svelte";
+	import AudioIcon from "./icons/AudioIcon.svelte";
+	import VideoIcon from "./icons/VideoIcon.svelte";
+	import Model3DIcon from "./icons/Model3DIcon.svelte";
+	import TextIcon from "./icons/TextIcon.svelte";
+	import DatasetIcon from "./icons/DatasetIcon.svelte";
+	import PlusIcon from "./icons/PlusIcon.svelte";
+	import FunctionIcon from "./icons/FunctionIcon.svelte";
+	import StopIcon from "./icons/StopIcon.svelte";
+	import PlayIcon from "./icons/PlayIcon.svelte";
+
+	export interface BoundFnTemplate {
+		fn: string;
+		label: string;
+		inputs: { id: string; label: string; type: string }[];
+		outputs: { id: string; label: string; type: string }[];
+	}
+
+	interface Props {
+		running: boolean;
+		hasTransforms: boolean;
+		boundFns: BoundFnTemplate[];
+		onopenpicker: (modality: ModalityConfig) => void;
+		onaddinput: (portType: string) => void;
+		onaddfn: (template: BoundFnTemplate) => void;
+		onrun: () => void;
+		onstop: () => void;
+	}
+
+	let {
+		running,
+		hasTransforms,
+		boundFns,
+		onopenpicker,
+		onaddinput,
+		onaddfn,
+		onrun,
+		onstop
+	}: Props = $props();
+
+	const INPUT_TYPES = [
+		{ key: "image", label: "Image" },
+		{ key: "text", label: "Text" },
+		{ key: "audio", label: "Audio" },
+		{ key: "video", label: "Video" },
+		{ key: "number", label: "Number" },
+		{ key: "file", label: "File" }
+	];
+
+	let showInputMenu = $state(false);
+	let showFnMenu = $state(false);
+
+	function closeMenus(): void {
+		showInputMenu = false;
+		showFnMenu = false;
+	}
+
+	function toggleInputMenu(e: MouseEvent) {
+		e.stopPropagation();
+		showFnMenu = false;
+		showInputMenu = !showInputMenu;
+	}
+
+	function toggleFnMenu(e: MouseEvent) {
+		e.stopPropagation();
+		showInputMenu = false;
+		showFnMenu = !showFnMenu;
+	}
+
+	function handleInputType(type: string, e: MouseEvent) {
+		e.stopPropagation();
+		showInputMenu = false;
+		onaddinput(type);
+	}
+
+	function handleFnClick(tmpl: BoundFnTemplate, e: MouseEvent) {
+		e.stopPropagation();
+		showFnMenu = false;
+		onaddfn(tmpl);
+	}
+</script>
+
+<!-- svelte-ignore a11y_no_static_element_interactions -->
+<div
+	class="bottom-bar"
+	onclick={(e) => {
+		e.stopPropagation();
+		closeMenus();
+	}}
+>
+	<div class="bb-group">
+		{#each MODALITIES as m}
+			<div class="bb-modality-wrap">
+				<button
+					class="bb-btn"
+					onclick={(e) => {
+						e.stopPropagation();
+						closeMenus();
+						onopenpicker(m);
+					}}
+					title="Add {m.label} node"
+				>
+					<span class="bb-icon">
+						{#if m.key === "image"}
+							<ImageIcon />
+						{:else if m.key === "audio"}
+							<AudioIcon />
+						{:else if m.key === "video"}
+							<VideoIcon />
+						{:else if m.key === "3d"}
+							<Model3DIcon />
+						{:else if m.key === "text"}
+							<TextIcon />
+						{/if}
+					</span>
+					<span class="bb-label">{m.label}</span>
+				</button>
+			</div>
+		{/each}
+	</div>
+
+	<button
+		class="bb-btn"
+		onclick={(e) => {
+			e.stopPropagation();
+			onopenpicker(DATASET_MODALITY);
+		}}
+		title="Add dataset node"
+	>
+		<span class="bb-icon">
+			<DatasetIcon />
+		</span>
+		<span class="bb-label">Data</span>
+	</button>
+
+	<div class="bb-divider"></div>
+
+	<div class="bb-input-wrap">
+		<button
+			class="bb-input-btn"
+			onclick={toggleInputMenu}
+			title="Add input node"
+		>
+			<PlusIcon />
+			Input
+		</button>
+		{#if showInputMenu}
+			<div class="input-type-menu">
+				{#each INPUT_TYPES as t}
+					<button
+						class="input-type-opt"
+						onclick={(e) => handleInputType(t.key, e)}>{t.label}</button
+					>
+				{/each}
+			</div>
+		{/if}
+	</div>
+
+	{#if boundFns.length > 0}
+		<div class="bb-input-wrap">
+			<button
+				class="bb-input-btn"
+				onclick={toggleFnMenu}
+				title="Add Python function node"
+			>
+				<FunctionIcon />
+				Function
+			</button>
+			{#if showFnMenu}
+				<div class="input-type-menu fn-menu">
+					{#each boundFns as t}
+						<button
+							class="input-type-opt"
+							onclick={(e) => handleFnClick(t, e)}
+							title={t.fn}
+						>
+							{t.label}
+						</button>
+					{/each}
+				</div>
+			{/if}
+		</div>
+	{/if}
+
+	<div class="bb-divider"></div>
+
+	{#if running}
+		<button class="bb-run-btn stop" onclick={onstop}>
+			<StopIcon />
+			Stop
+		</button>
+	{:else}
+		<button class="bb-run-btn" onclick={onrun} disabled={!hasTransforms}>
+			<PlayIcon />
+			Run
+		</button>
+	{/if}
+</div>
+
+<style>
+	.bottom-bar {
+		position: absolute;
+		bottom: 20px;
+		left: 50%;
+		transform: translateX(-50%);
+		display: flex;
+		align-items: center;
+		gap: 6px;
+		padding: 5px 8px;
+		background: rgba(16, 17, 24, 0.92);
+		border: 1px solid rgba(255, 255, 255, 0.07);
+		border-radius: 40px;
+		backdrop-filter: blur(16px);
+		-webkit-backdrop-filter: blur(16px);
+		box-shadow:
+			0 4px 24px rgba(0, 0, 0, 0.5),
+			0 0 0 1px rgba(255, 255, 255, 0.03);
+		z-index: 20;
+		white-space: nowrap;
+	}
+
+	.bb-group {
+		display: flex;
+		align-items: center;
+		gap: 2px;
+	}
+
+	.bb-btn {
+		display: flex;
+		align-items: center;
+		gap: 6px;
+		padding: 6px 12px;
+		border: none;
+		border-radius: 28px;
+		background: transparent;
+		color: #8b8d98;
+		font-family: "Manrope", sans-serif;
+		font-size: 12px;
+		font-weight: 600;
+		cursor: pointer;
+		transition:
+			background 0.15s,
+			color 0.15s;
+	}
+
+	.bb-btn:hover,
+	.bb-btn-active {
+		background: rgba(255, 255, 255, 0.06);
+		color: #d5d6de;
+	}
+
+	.bb-modality-wrap {
+		position: relative;
+	}
+
+	.bb-icon {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		flex-shrink: 0;
+	}
+
+	.bb-label {
+		letter-spacing: -0.01em;
+	}
+
+	.bb-divider {
+		width: 1px;
+		height: 20px;
+		background: rgba(255, 255, 255, 0.07);
+		flex-shrink: 0;
+	}
+
+	.bb-input-wrap {
+		position: relative;
+	}
+
+	.bb-input-btn {
+		display: flex;
+		align-items: center;
+		gap: 5px;
+		padding: 6px 12px;
+		border: 1px solid rgba(255, 255, 255, 0.08);
+		border-radius: 28px;
+		background: transparent;
+		color: #6b6e78;
+		font-family: "Manrope", sans-serif;
+		font-size: 12px;
+		font-weight: 600;
+		cursor: pointer;
+		transition:
+			background 0.15s,
+			color 0.15s,
+			border-color 0.15s;
+	}
+
+	.bb-input-btn:hover {
+		background: rgba(255, 255, 255, 0.06);
+		color: #a0a2ae;
+		border-color: rgba(255, 255, 255, 0.14);
+	}
+
+	.input-type-menu {
+		position: absolute;
+		bottom: calc(100% + 16px);
+		left: 50%;
+		transform: translateX(-50%);
+		background: #16171f;
+		border: 1px solid #2a2b36;
+		border-radius: 10px;
+		padding: 4px;
+		display: flex;
+		flex-direction: column;
+		gap: 1px;
+		/* Negative Y offset casts the shadow UPWARD, since the menu opens
+		 * above the bottom bar. The previous downward shadow smudged onto
+		 * the button below. Pair with a subtle inset ring for crisper
+		 * edge definition on dark bg. */
+		box-shadow:
+			0 -6px 20px rgba(0, 0, 0, 0.35),
+			0 0 0 1px rgba(255, 255, 255, 0.03);
+		z-index: 30;
+		min-width: 90px;
+	}
+
+	.input-type-opt {
+		padding: 7px 12px;
+		border: none;
+		border-radius: 6px;
+		background: transparent;
+		color: #8b8d98;
+		font-family: "Manrope", sans-serif;
+		font-size: 12px;
+		font-weight: 500;
+		cursor: pointer;
+		text-align: left;
+		transition:
+			background 0.1s,
+			color 0.1s;
+	}
+
+	.input-type-opt:hover {
+		background: rgba(255, 255, 255, 0.06);
+		color: #d5d6de;
+	}
+
+	.bb-run-btn {
+		display: flex;
+		align-items: center;
+		gap: 6px;
+		padding: 7px 16px;
+		border: none;
+		border-radius: 28px;
+		background: linear-gradient(135deg, #f97316, #ea580c);
+		color: #fff;
+		font-family: "Manrope", sans-serif;
+		font-size: 12.5px;
+		font-weight: 700;
+		cursor: pointer;
+		transition:
+			transform 0.1s,
+			box-shadow 0.15s;
+		box-shadow: 0 2px 10px rgba(249, 115, 22, 0.3);
+	}
+
+	.bb-run-btn:hover {
+		transform: translateY(-1px);
+		box-shadow: 0 4px 18px rgba(249, 115, 22, 0.4);
+	}
+
+	.bb-run-btn:active {
+		transform: translateY(0);
+	}
+
+	.bb-run-btn:disabled {
+		opacity: 0.35;
+		cursor: default;
+		transform: none;
+		box-shadow: none;
+	}
+
+	.bb-run-btn.stop {
+		background: linear-gradient(135deg, #ef4444, #dc2626);
+		box-shadow: 0 2px 10px rgba(239, 68, 68, 0.3);
+	}
+
+	.bb-run-btn.stop:hover {
+		box-shadow: 0 4px 18px rgba(239, 68, 68, 0.4);
+	}
+
+	/* Light mode */
+	:global(body:not(.dark)) .bottom-bar {
+		background: rgba(255, 255, 255, 0.92);
+		border-color: rgba(0, 0, 0, 0.08);
+		box-shadow:
+			0 4px 24px rgba(0, 0, 0, 0.12),
+			0 0 0 1px rgba(0, 0, 0, 0.04);
+	}
+
+	:global(body:not(.dark)) .bb-btn {
+		color: #6b6e78;
+	}
+
+	:global(body:not(.dark)) .bb-btn:hover {
+		background: rgba(0, 0, 0, 0.04);
+		color: #1a1b25;
+	}
+
+	:global(body:not(.dark)) .bb-divider {
+		background: rgba(0, 0, 0, 0.1);
+	}
+
+	:global(body:not(.dark)) .bb-input-btn {
+		border-color: rgba(0, 0, 0, 0.1);
+		color: #8b8d98;
+	}
+
+	:global(body:not(.dark)) .bb-input-btn:hover {
+		background: rgba(0, 0, 0, 0.04);
+		color: #3e4050;
+	}
+
+	:global(body:not(.dark)) .input-type-menu {
+		background: #ffffff;
+		border-color: #e2e4ea;
+	}
+
+	:global(body:not(.dark)) .input-type-opt {
+		color: #6b6e78;
+	}
+
+	:global(body:not(.dark)) .input-type-opt:hover {
+		background: #f0f1f5;
+		color: #1a1b25;
+	}
+
+	:global(body:not(.dark)) .bb-models-btn-active {
+		color: #ea580c;
+		background: rgba(234, 88, 12, 0.08);
+	}
+</style>

6.17.1/workflowcanvas/workflow/WorkflowCanvas.svelte

@@ -0,0 +1,2154 @@
+<script lang="ts">
+	import { setContext } from "svelte";
+
+	import WorkflowNodeSF from "./WorkflowNodeSF.svelte";
+	import WorkflowBottomBar from "./WorkflowBottomBar.svelte";
+	import type { BoundFnTemplate } from "./WorkflowBottomBar.svelte";
+	import NodeModelPicker from "./NodeModelPicker.svelte";
+	import WorkflowEmptyState from "./WorkflowEmptyState.svelte";
+
+	import {
+		MODALITIES,
+		DATASET_MODALITY,
+		portMeta,
+		modalityForPort
+	} from "./workflow-modalities";
+	import type { ModalityConfig } from "./workflow-modalities";
+	import { fetchSpaceApi } from "./space-api";
+	import {
+		workflow,
+		addNode,
+		moveNode,
+		addEdge,
+		removeEdge,
+		updateNodeData,
+		removeNode,
+		replaceNodeSource,
+		switch_endpoint,
+		hydrate_endpoints,
+		sanitize_for_save,
+		revoke_blob_urls
+	} from "./workflow-store";
+	import { migrateToV2, toLegacyShape } from "./workflow-migration";
+	import { PORT_COLOR, ports_compatible } from "./workflow-types";
+	import type {
+		PortType,
+		WFNode,
+		WFEdge,
+		NodeStatus,
+		NodeRole
+	} from "./workflow-types";
+	import { executeWorkflow } from "./workflow-executor";
+	import { stream_text_generation } from "./inference-stream";
+	import {
+		findFreeSpot as findFreeSpotImpl,
+		topoSort,
+		resolveCurrentInputs as resolveCurrentInputsImpl,
+		computeStaleNodes,
+		buildUpstreamSubgraph as buildUpstreamSubgraphImpl
+	} from "./workflow-graph";
+	import { LIBRARY, getComponentForPortType } from "./node-library";
+	import { createHFAuth } from "./hf-auth.svelte";
+	import { load_viewport, save_viewport } from "./viewport-persistence";
+	import CheckIcon from "./icons/CheckIcon.svelte";
+
+	/**
+	 * A node template's role for the v2 store. v1-style templates from LIBRARY/
+	 * picker use `kind: "component" | "transform"` — map them to v2 roles here.
+	 * Subjects aren't auto-created by templates today; they're created when an
+	 * edge wires into a reference (future enhancement). For now, components default
+	 * to reference.
+	 */
+	function templateRole(template: any): NodeRole {
+		if (template?.role) return template.role;
+		if (template?.kind === "transform") return "operator";
+		return "reference";
+	}
+
+	let {
+		server = {},
+		initialValue = null
+	}: { server?: Record<string, any>; initialValue?: string | null } = $props();
+
+	const auth = createHFAuth(() => server);
+
+	$effect(() => {
+		if (server?.get_token) {
+			void auth.checkLoginStatus();
+		}
+	});
+
+	$effect(() => {
+		if (!initialValue) return;
+		try {
+			const parsed = JSON.parse(initialValue);
+			// Migration handles both v1 (legacy workflow.json files) and v2.
+			const v2 = migrateToV2(parsed);
+			workflow.set(v2);
+		} catch {}
+	});
+
+	$effect(() => {
+		const wf = $workflow;
+		if (!server?.save_workflow) return;
+		const timer = setTimeout(() => {
+			server
+				.save_workflow([JSON.stringify(sanitize_for_save(wf))])
+				.catch(() => {});
+		}, 500);
+		return () => clearTimeout(timer);
+	});
+
+	// Pull the bind=[…] list from the server once on mount so the
+	// Functions button in the bottom bar can offer them as add-able
+	// nodes. Silently no-op if the server doesn't expose it (older
+	// gradio backends).
+	$effect(() => {
+		if (!server?.list_bound_fns) return;
+		void server
+			.list_bound_fns()
+			.then((raw: string) => {
+				try {
+					const parsed = JSON.parse(raw);
+					if (Array.isArray(parsed)) boundFns = parsed as BoundFnTemplate[];
+				} catch {
+					/* ignore malformed */
+				}
+			})
+			.catch(() => {});
+	});
+
+	$effect(() => {
+		window.addEventListener("keydown", handleKeydown);
+		return () => window.removeEventListener("keydown", handleKeydown);
+	});
+
+	// ─── Canvas state ───────────────────────────────────────────────────────────
+	let viewport = $state(load_viewport($workflow.name));
+
+	let lastViewportName = $state($workflow.name);
+	$effect(() => {
+		if ($workflow.name !== lastViewportName) {
+			lastViewportName = $workflow.name;
+			viewport = load_viewport($workflow.name);
+		}
+	});
+
+	$effect(() => {
+		const name = $workflow.name;
+		const v = viewport;
+		const timer = setTimeout(() => save_viewport(name, v), 250);
+		return () => clearTimeout(timer);
+	});
+
+	// Pointer interaction state: track which kind of drag is happening so
+	// pointermove/up know what to do. Mutually exclusive — at most one mode.
+	type DragMode =
+		| { kind: "pan"; startX: number; startY: number; vx: number; vy: number }
+		| {
+				kind: "node";
+				nodeId: string;
+				startClientX: number;
+				startClientY: number;
+				startNodeX: number;
+				startNodeY: number;
+		  }
+		| {
+				kind: "connection";
+				fromNodeId: string;
+				fromPortId: string;
+				type: PortType;
+				reversed: boolean;
+				cursorCanvasX: number;
+				cursorCanvasY: number;
+		  };
+	let dragMode = $state<DragMode | null>(null);
+
+	// ─── App state ────────────────────────��─────────────────────────────────────
+	let canvasEl: HTMLDivElement;
+	let running = $state(false);
+	let abortController: AbortController | null = null;
+	let nodeStatus: Record<string, NodeStatus> = $state({});
+	let nodeErrors: Record<string, string> = $state({});
+	/**
+	 * Bound Python functions advertised by the server (`list_bound_fns`).
+	 * Populates the bottom-bar Functions button so users can re-add an
+	 * fn node after deleting it without re-launching the app.
+	 */
+	let boundFns = $state<BoundFnTemplate[]>([]);
+	/**
+	 * Snapshot of resolved inputs at the moment a node last completed. Used
+	 * to flag nodes as stale when their current inputs differ from the
+	 * snapshot — i.e. an upstream value changed but this node hasn't been
+	 * re-run yet. Pattern lifted from gradio-app/daggr.
+	 */
+	let nodeInputSnapshots: Record<string, string> = $state({});
+	let editingName = $state(false);
+	let selectedNodeId: string | null = $state(null);
+	let showShortcuts = $state(false);
+	let nameInput: HTMLInputElement = $state()!;
+
+	type Pending = {
+		from_node_id: string;
+		from_port_id: string;
+		type: PortType;
+		reversed?: boolean;
+	};
+	let activeConnection: Pending | null = $state(null);
+
+	interface WfToast {
+		id: number;
+		message: string;
+		type: "info" | "warning" | "error" | "success";
+	}
+	let toasts: WfToast[] = $state([]);
+	let toastCounter = 0;
+
+	function showToast(
+		msg: string,
+		ms = 3000,
+		type: "info" | "warning" | "error" | "success" = "info"
+	): void {
+		const id = ++toastCounter;
+		toasts = [...toasts, { id, message: msg, type }].slice(-3);
+		if (ms > 0)
+			setTimeout(() => {
+				toasts = toasts.filter((t) => t.id !== id);
+			}, ms);
+	}
+
+	// v1 shape for read paths; writes go through v2 store actions.
+	const legacyView = $derived(toLegacyShape($workflow));
+
+	const gridTile = $derived.by(() => {
+		let tile = 22 * viewport.zoom;
+		while (tile < 16) tile *= 2;
+		return tile;
+	});
+
+	const nodeCount = $derived(legacyView.nodes.length);
+	const hasTransforms = $derived($workflow.operators.length > 0);
+	const edgeCount = $derived($workflow.edges.length);
+
+	const connectedPortsSet = $derived(() => {
+		const set = new Set<string>();
+		for (const e of $workflow.edges) {
+			set.add(`${e.from_node_id}:${e.from_port_id}:output`);
+			set.add(`${e.to_node_id}:${e.to_port_id}:input`);
+		}
+		return set;
+	});
+
+	interface ActivePicker {
+		mode: "create" | "update";
+		modality: ModalityConfig;
+		nodeId?: string;
+		anchorX?: number;
+		anchorY?: number;
+		initialSource?: "spaces" | "models" | "datasets";
+		initialSubtab?: string;
+	}
+	let activePicker: ActivePicker | null = $state(null);
+
+	interface PendingDrop {
+		from_node_id: string;
+		from_port_id: string;
+		type: PortType;
+		x: number;
+		y: number;
+		reversed?: boolean;
+		positionOnly?: boolean;
+	}
+	let pendingDrop: PendingDrop | null = $state(null);
+
+	interface DropOption {
+		kind: "model" | "component";
+		label: string;
+		subtab?: string;
+	}
+	interface DropChoice {
+		clientX: number;
+		clientY: number;
+		modelOptions: DropOption[];
+		componentOptions: DropOption[];
+		/** true → user dragged from an input port (needs a Source);
+		 *  false → user dragged from an output port (needs an Output sink). */
+		reversed: boolean;
+	}
+	let dropChoice: DropChoice | null = $state(null);
+
+	interface DoubleClickMenu {
+		clientX: number;
+		clientY: number;
+		canvasX: number;
+		canvasY: number;
+	}
+	let doubleClickMenu: DoubleClickMenu | null = $state(null);
+
+	function inputOutputLabel(type: PortType, reversed: boolean): string {
+		const base = portMeta(type)?.label ?? "File";
+		// When dragging from an input (reversed), media types want an "Upload"
+		// affordance; scalar types reuse their own label as the source widget.
+		if (reversed) {
+			const scalar =
+				type === "text" ||
+				type === "number" ||
+				type === "json" ||
+				type === "boolean";
+			return scalar ? base : "Upload";
+		}
+		return base;
+	}
+
+	// ─── Context for node components ────────────────────────────────────────────
+	const wfCtx = $state({
+		pending: null as Pending | null,
+		nodeStatus: {} as Record<string, NodeStatus>,
+		nodeErrors: {} as Record<string, string>,
+		staleNodes: new Set<string>(),
+		connectedPorts: new Set<string>(),
+		ondatachange: updateNodeData,
+		onremove: (id: string) => removeNode(id),
+		onopenpicker: (id: string) => openPickerForNode(id),
+		onswitchendpoint: (id: string, endpointName: string) =>
+			switch_endpoint(id, endpointName),
+		onhydratendpoints: async (id: string, spaceId: string) => {
+			try {
+				const info = await fetchSpaceApi(spaceId);
+				if (!info.endpoints || info.endpoints.length === 0) {
+					showToast(`${spaceId} has no usable endpoints`, 4000, "warning");
+					return;
+				}
+				hydrate_endpoints(id, info.endpoints);
+				if (info.endpoints.length === 1) {
+					showToast(`${spaceId} only exposes one endpoint`, 3000);
+				}
+			} catch (err) {
+				showToast(
+					err instanceof Error ? err.message : "Failed to load endpoints",
+					4000,
+					"error"
+				);
+			}
+		},
+		onrunnode: (id: string) => void runNode(id),
+		onselect: (id: string) => selectNode(id),
+		onnodepointerdown: (e: PointerEvent, id: string) => startNodeDrag(e, id),
+		onportpointerdown: (
+			e: PointerEvent,
+			nodeId: string,
+			portId: string,
+			type: PortType,
+			isInput: boolean
+		) => startConnection(e, nodeId, portId, type, isInput)
+	});
+	setContext("wf", wfCtx);
+
+	$effect(() => {
+		wfCtx.pending = activeConnection;
+	});
+	$effect(() => {
+		wfCtx.nodeStatus = nodeStatus;
+	});
+	$effect(() => {
+		wfCtx.nodeErrors = nodeErrors;
+	});
+	$effect(() => {
+		wfCtx.staleNodes = staleNodes;
+	});
+	$effect(() => {
+		wfCtx.connectedPorts = connectedPortsSet();
+	});
+
+	// ─── Custom canvas event handlers ───────────────────────────────────────────
+
+	function clientToCanvas(
+		clientX: number,
+		clientY: number
+	): { x: number; y: number } {
+		const r = canvasEl?.getBoundingClientRect();
+		if (!r) return { x: 0, y: 0 };
+		return {
+			x: (clientX - r.left - viewport.x) / viewport.zoom,
+			y: (clientY - r.top - viewport.y) / viewport.zoom
+		};
+	}
+
+	function onCanvasPointerDown(e: PointerEvent): void {
+		if (e.button !== 0) return;
+		const target = e.target as HTMLElement;
+		// Only start pan when clicking truly empty canvas — not nodes, edges, ports, UI
+		if (
+			target.closest(
+				".node-pos-wrap, .edge-path, .picker-panel, .drop-menu, .add-node-menu, .bottom-bar, .zoom-controls, .toolbar"
+			)
+		) {
+			return;
+		}
+		dragMode = {
+			kind: "pan",
+			startX: e.clientX,
+			startY: e.clientY,
+			vx: viewport.x,
+			vy: viewport.y
+		};
+		canvasEl.setPointerCapture(e.pointerId);
+	}
+
+	function onWheel(e: WheelEvent): void {
+		if (!canvasEl) return;
+		e.preventDefault();
+		const r = canvasEl.getBoundingClientRect();
+		const cx = e.clientX - r.left;
+		const cy = e.clientY - r.top;
+		const factor = e.deltaY < 0 ? 1.1 : 1 / 1.1;
+		const oldZoom = viewport.zoom;
+		const newZoom = Math.max(0.15, Math.min(4, oldZoom * factor));
+		viewport = {
+			x: cx - (cx - viewport.x) * (newZoom / oldZoom),
+			y: cy - (cy - viewport.y) * (newZoom / oldZoom),
+			zoom: newZoom
+		};
+	}
+
+	function startNodeDrag(e: PointerEvent, nodeId: string): void {
+		if (e.button !== 0) return;
+		const node = legacyView.nodes.find((n) => n.id === nodeId);
+		if (!node) return;
+		e.stopPropagation();
+		dragMode = {
+			kind: "node",
+			nodeId,
+			startClientX: e.clientX,
+			startClientY: e.clientY,
+			startNodeX: node.x,
+			startNodeY: node.y
+		};
+		canvasEl?.setPointerCapture(e.pointerId);
+	}
+
+	function startConnection(
+		e: PointerEvent,
+		nodeId: string,
+		portId: string,
+		type: PortType,
+		isInput: boolean
+	): void {
+		if (e.button !== 0) return;
+		e.stopPropagation();
+		const { x, y } = clientToCanvas(e.clientX, e.clientY);
+		dragMode = {
+			kind: "connection",
+			fromNodeId: nodeId,
+			fromPortId: portId,
+			type,
+			reversed: isInput,
+			cursorCanvasX: x,
+			cursorCanvasY: y
+		};
+		activeConnection = {
+			from_node_id: nodeId,
+			from_port_id: portId,
+			type,
+			reversed: isInput
+		};
+		canvasEl?.setPointerCapture(e.pointerId);
+	}
+
+	function onCanvasPointerMove(e: PointerEvent): void {
+		if (!dragMode) return;
+		if (dragMode.kind === "pan") {
+			viewport = {
+				...viewport,
+				x: dragMode.vx + (e.clientX - dragMode.startX),
+				y: dragMode.vy + (e.clientY - dragMode.startY)
+			};
+		} else if (dragMode.kind === "node") {
+			const dx = (e.clientX - dragMode.startClientX) / viewport.zoom;
+			const dy = (e.clientY - dragMode.startClientY) / viewport.zoom;
+			moveNode(
+				dragMode.nodeId,
+				dragMode.startNodeX + dx,
+				dragMode.startNodeY + dy
+			);
+		} else if (dragMode.kind === "connection") {
+			const { x, y } = clientToCanvas(e.clientX, e.clientY);
+			dragMode = { ...dragMode, cursorCanvasX: x, cursorCanvasY: y };
+		}
+	}
+
+	function onCanvasPointerUp(e: PointerEvent): void {
+		if (!dragMode) return;
+		const mode = dragMode;
+		if (mode.kind === "connection") {
+			activeConnection = null;
+			const targetEl = document.elementFromPoint(
+				e.clientX,
+				e.clientY
+			) as HTMLElement | null;
+
+			// 1. Precise hit on a port handle — use it directly.
+			const portEl = targetEl?.closest("[data-port-id]") as HTMLElement | null;
+			if (portEl) {
+				const toNodeId = portEl.getAttribute("data-node-id");
+				const toPortId = portEl.getAttribute("data-port-id");
+				const toIsInput =
+					portEl.getAttribute("data-port-direction") === "input";
+				if (toNodeId && toPortId && toNodeId !== mode.fromNodeId) {
+					tryCreateEdge(
+						mode.fromNodeId,
+						mode.fromPortId,
+						mode.reversed,
+						toNodeId,
+						toPortId,
+						toIsInput
+					);
+				}
+				dragMode = null;
+				try {
+					canvasEl?.releasePointerCapture(e.pointerId);
+				} catch {}
+				return;
+			}
+
+			// 2. Fuzzy hit — dropped on a node body, not its port. Find the first
+			// compatible free port on that node and use it. This is what users
+			// usually mean: "connect to that node", not "to that 12px circle."
+			const nodeWrap = targetEl?.closest(
+				"[data-node-id]"
+			) as HTMLElement | null;
+			const droppedNodeId = nodeWrap?.getAttribute("data-node-id");
+			if (droppedNodeId && droppedNodeId !== mode.fromNodeId) {
+				const autoPort = pickCompatiblePort(
+					droppedNodeId,
+					mode.type,
+					mode.reversed
+				);
+				if (autoPort) {
+					tryCreateEdge(
+						mode.fromNodeId,
+						mode.fromPortId,
+						mode.reversed,
+						droppedNodeId,
+						autoPort.id,
+						autoPort.direction === "input"
+					);
+					dragMode = null;
+					try {
+						canvasEl?.releasePointerCapture(e.pointerId);
+					} catch {}
+					return;
+				}
+			}
+
+			// 3. Empty drop — open the drop-choice menu so the user can spawn a new node.
+			const r = canvasEl?.getBoundingClientRect();
+			if (r) {
+				const drop: PendingDrop = {
+					from_node_id: mode.fromNodeId,
+					from_port_id: mode.fromPortId,
+					type: mode.type,
+					x: mode.cursorCanvasX,
+					y: mode.cursorCanvasY,
+					reversed: mode.reversed
+				};
+				const choice: DropChoice = {
+					clientX: e.clientX - r.left,
+					clientY: e.clientY - r.top,
+					modelOptions: buildModelOptions(mode.type),
+					componentOptions: buildComponentOptions(mode.type, mode.reversed),
+					reversed: mode.reversed
+				};
+				setTimeout(() => {
+					pendingDrop = drop;
+					dropChoice = choice;
+				}, 0);
+			}
+		}
+		dragMode = null;
+		try {
+			canvasEl?.releasePointerCapture(e.pointerId);
+		} catch {}
+	}
+
+	/**
+	 * Choose the best port on `nodeId` for a connection of `type` whose source
+	 * is reversed/forward. Forward = we're dragging an output, so we want an
+	 * unconnected input on the target; reversed = we're dragging an input, so
+	 * we want any output on the target. Returns null if nothing fits.
+	 */
+	function pickCompatiblePort(
+		nodeId: string,
+		type: PortType,
+		reversed: boolean
+	): { id: string; direction: "input" | "output" } | null {
+		const target = legacyView.nodes.find((n) => n.id === nodeId);
+		if (!target) return null;
+		if (reversed) {
+			const out = target.outputs.find((p) => ports_compatible(p.type, type));
+			return out ? { id: out.id, direction: "output" } : null;
+		}
+		const inPort = target.inputs.find(
+			(p) =>
+				ports_compatible(type, p.type) &&
+				!$workflow.edges.some(
+					(e) => e.to_node_id === nodeId && e.to_port_id === p.id
+				)
+		);
+		return inPort ? { id: inPort.id, direction: "input" } : null;
+	}
+
+	/**
+	 * Cache of measured port-handle centers in canvas-space. Re-populated after
+	 * any node change via the effect below; canvas coords are invariant to
+	 * pan/zoom so we don't need to re-measure on viewport changes.
+	 */
+	let portPositions = $state(new Map<string, { x: number; y: number }>());
+
+	function portKey(
+		nodeId: string,
+		portId: string,
+		direction: "input" | "output"
+	): string {
+		return `${nodeId}:${portId}:${direction}`;
+	}
+
+	$effect(() => {
+		legacyView.nodes;
+		// Defer until after Svelte commits this render so the handle elements
+		// have their final positions in the DOM.
+		const raf = requestAnimationFrame(() => {
+			if (!canvasEl) return;
+			const cr = canvasEl.getBoundingClientRect();
+			const next = new Map<string, { x: number; y: number }>();
+			canvasEl.querySelectorAll<HTMLElement>("[data-port-id]").forEach((el) => {
+				const nodeId = el.getAttribute("data-node-id");
+				const portId = el.getAttribute("data-port-id");
+				const dir = el.getAttribute("data-port-direction") as
+					| "input"
+					| "output"
+					| null;
+				if (!nodeId || !portId || !dir) return;
+				const r = el.getBoundingClientRect();
+				const cx = r.left + r.width / 2 - cr.left;
+				const cy = r.top + r.height / 2 - cr.top;
+				next.set(portKey(nodeId, portId, dir), {
+					x: (cx - viewport.x) / viewport.zoom,
+					y: (cy - viewport.y) / viewport.zoom
+				});
+			});
+			portPositions = next;
+		});
+		return () => cancelAnimationFrame(raf);
+	});
+
+	/**
+	 * Canvas-space position of a port handle. Uses the measured DOM position
+	 * when available; falls back to a coarse estimate for the first paint
+	 * before the measurement effect has run (handles are ~24px outside the
+	 * node edge, so the heuristic offsets X by ±18 to hit the handle center).
+	 */
+	function portPos(
+		nodeId: string,
+		portId: string,
+		direction: "input" | "output"
+	): { x: number; y: number } | null {
+		const measured = portPositions.get(portKey(nodeId, portId, direction));
+		if (measured) return measured;
+		const node = legacyView.nodes.find((n) => n.id === nodeId);
+		if (!node) return null;
+		const ports = direction === "input" ? node.inputs : node.outputs;
+		const i = ports.findIndex((p) => p.id === portId);
+		if (i < 0) return null;
+		const headerHeight = 36;
+		const rowHeight = 30;
+		const y = node.y + headerHeight + i * rowHeight + rowHeight / 2;
+		const x = direction === "input" ? node.x - 18 : node.x + node.width + 18;
+		return { x, y };
+	}
+
+	function bezier(
+		a: { x: number; y: number },
+		b: { x: number; y: number }
+	): string {
+		const dx = Math.max(40, Math.abs(b.x - a.x) * 0.5);
+		return `M ${a.x} ${a.y} C ${a.x + dx} ${a.y}, ${b.x - dx} ${b.y}, ${b.x} ${b.y}`;
+	}
+
+	function edgePath(edge: WFEdge): string | null {
+		const a = portPos(edge.from_node_id, edge.from_port_id, "output");
+		const b = portPos(edge.to_node_id, edge.to_port_id, "input");
+		if (!a || !b) return null;
+		return bezier(a, b);
+	}
+
+	function connectionPreviewPath(
+		mode: Extract<DragMode, { kind: "connection" }>
+	): string | null {
+		const port = portPos(
+			mode.fromNodeId,
+			mode.fromPortId,
+			mode.reversed ? "input" : "output"
+		);
+		if (!port) return null;
+		const cursor = { x: mode.cursorCanvasX, y: mode.cursorCanvasY };
+		return mode.reversed ? bezier(cursor, port) : bezier(port, cursor);
+	}
+
+	function tryCreateEdge(
+		fromId: string,
+		fromPort: string,
+		fromIsInput: boolean,
+		toId: string,
+		toPort: string,
+		toIsInput: boolean
+	): void {
+		if (fromIsInput === toIsInput) return; // both ends same direction → invalid
+		// Normalize: edges always flow output → input
+		const [sourceId, sourcePort, targetId, targetPort] = fromIsInput
+			? [toId, toPort, fromId, fromPort]
+			: [fromId, fromPort, toId, toPort];
+		const sourceNode = legacyView.nodes.find((n) => n.id === sourceId);
+		const targetNode = legacyView.nodes.find((n) => n.id === targetId);
+		if (!sourceNode || !targetNode) return;
+		const outPort = sourceNode.outputs.find((p) => p.id === sourcePort);
+		const inPort = targetNode.inputs.find((p) => p.id === targetPort);
+		if (!outPort || !inPort || !ports_compatible(outPort.type, inPort.type))
+			return;
+		addEdge({
+			from_node_id: sourceId,
+			from_port_id: sourcePort,
+			to_node_id: targetId,
+			to_port_id: targetPort,
+			type: outPort.type
+		});
+	}
+
+	function buildModelOptions(type: PortType): DropOption[] {
+		const modality = modalityForPort(type);
+		if (!modality) return [];
+		return modality.subtabs
+			.filter((st) => st.key !== "all")
+			.map((st) => ({
+				kind: "model" as const,
+				label: st.label,
+				subtab: st.key
+			}));
+	}
+
+	function buildComponentOptions(
+		type: PortType,
+		reversed: boolean
+	): DropOption[] {
+		return [
+			{ kind: "component" as const, label: inputOutputLabel(type, reversed) }
+		];
+	}
+
+	function handleDropChoiceModel(subtab?: string): void {
+		dropChoice = null;
+		if (!pendingDrop) return;
+		const modality = modalityForPort(pendingDrop.type);
+		if (!modality) return;
+		activePicker = { mode: "create", modality, initialSubtab: subtab };
+	}
+
+	function handleDropChoiceUpload(): void {
+		dropChoice = null;
+		const drop = pendingDrop;
+		pendingDrop = null;
+		if (!drop) return;
+		const typedComponents: Record<string, any> = {};
+		for (const c of LIBRARY.components) {
+			typedComponents[c.outputs[0]?.type ?? "any"] = c;
+		}
+		const template = typedComponents[drop.type] ?? LIBRARY.components[0];
+		const rawX = drop.reversed
+			? drop.x - (template.width ?? 200) - 80
+			: drop.x - (template.width ?? 200) / 2;
+		const { x, y } = findFreeSpot(rawX, drop.y - 45);
+		// reversed=true → user dragged from an input port; they need a Source
+		// (reference) supplying that value. reversed=false → user dragged from
+		// an output port; they need a Sink (subject) displaying that value.
+		const role: "reference" | "subject" = drop.reversed
+			? "reference"
+			: "subject";
+		const newId = addNode(role, template, x, y);
+		const newNode = legacyView.nodes.find((n) => n.id === newId);
+		if (drop.reversed) {
+			const outputPort = newNode?.outputs.find((p: any) =>
+				ports_compatible(p.type, drop.type)
+			);
+			if (outputPort) {
+				addEdge({
+					from_node_id: newId,
+					from_port_id: outputPort.id,
+					to_node_id: drop.from_node_id,
+					to_port_id: drop.from_port_id,
+					type: drop.type
+				});
+			}
+		} else {
+			const inputPort = newNode?.inputs.find((p: any) =>
+				ports_compatible(drop.type, p.type)
+			);
+			if (inputPort) {
+				addEdge({
+					from_node_id: drop.from_node_id,
+					from_port_id: drop.from_port_id,
+					to_node_id: newId,
+					to_port_id: inputPort.id,
+					type: drop.type
+				});
+			}
+		}
+	}
+
+	function handleCanvasDoubleClick(e: MouseEvent): void {
+		const target = e.target as HTMLElement;
+		if (
+			target.closest(".node-pos-wrap") ||
+			target.closest(".drop-menu") ||
+			target.closest(".picker-panel")
+		)
+			return;
+		const r = canvasEl?.getBoundingClientRect();
+		if (!r) return;
+		setTimeout(() => {
+			doubleClickMenu = {
+				clientX: e.clientX - r.left,
+				clientY: e.clientY - r.top,
+				canvasX: (e.clientX - r.left - viewport.x) / viewport.zoom,
+				canvasY: (e.clientY - r.top - viewport.y) / viewport.zoom
+			};
+		}, 0);
+	}
+
+	function handleDoubleClickInputNode(portType: PortType): void {
+		if (!doubleClickMenu) return;
+		const { canvasX, canvasY } = doubleClickMenu;
+		doubleClickMenu = null;
+		const typedComponents: Record<string, any> = {};
+		for (const c of LIBRARY.components) {
+			typedComponents[c.outputs[0]?.type ?? "any"] = c;
+		}
+		const template = typedComponents[portType] ?? LIBRARY.components[0];
+		addNode(
+			"reference",
+			template,
+			canvasX - (template.width ?? 200) / 2,
+			canvasY - 45
+		);
+	}
+
+	function handleDoubleClickUpload(): void {
+		if (!doubleClickMenu) return;
+		const { canvasX, canvasY } = doubleClickMenu;
+		doubleClickMenu = null;
+
+		// Attach the input to body briefly. Safari (and some popup
+		// blockers) refuse to open the OS file-picker dialog when
+		// `input.click()` is called on a detached element, even from
+		// a real user gesture.
+		const input = document.createElement("input");
+		input.type = "file";
+		input.accept = "image/*,audio/*,video/*";
+		input.style.display = "none";
+		document.body.appendChild(input);
+		const cleanup = (): void => {
+			try {
+				document.body.removeChild(input);
+			} catch {
+				/* noop */
+			}
+		};
+		input.onchange = () => {
+			const file = input.files?.[0];
+			if (!file) {
+				cleanup();
+				return;
+			}
+			let portType: PortType = "file";
+			if (file.type.startsWith("image/")) portType = "image";
+			else if (file.type.startsWith("audio/")) portType = "audio";
+			else if (file.type.startsWith("video/")) portType = "video";
+			const typedComponents: Record<string, any> = {};
+			for (const c of LIBRARY.components) {
+				typedComponents[c.outputs[0]?.type ?? "any"] = c;
+			}
+			const template = typedComponents[portType] ?? LIBRARY.components[0];
+			const { x: fx, y: fy } = findFreeSpot(
+				canvasX - (template.width ?? 200) / 2,
+				canvasY - 45
+			);
+			const newId = addNode("reference", template, fx, fy);
+			const url = URL.createObjectURL(file);
+			const portId = template.outputs[0]?.id;
+			if (portId && newId) {
+				updateNodeData(newId, portId, {
+					url,
+					path: file.name,
+					name: file.name
+				} as any);
+			}
+			cleanup();
+		};
+		// `cancel` fires when the user dismisses the dialog without picking.
+		input.oncancel = cleanup;
+		input.click();
+	}
+
+	function handleDoubleClickSpaceModel(modality: ModalityConfig): void {
+		if (!doubleClickMenu) return;
+		const { canvasX, canvasY } = doubleClickMenu;
+		doubleClickMenu = null;
+		pendingDrop = {
+			from_node_id: "",
+			from_port_id: "",
+			type: "any" as PortType,
+			x: canvasX,
+			y: canvasY,
+			positionOnly: true
+		};
+		activePicker = { mode: "create", modality };
+	}
+
+	// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+	function resolveCurrentInputs(node: WFNode): Record<string, unknown> {
+		return resolveCurrentInputsImpl(node, legacyView.nodes, $workflow.edges);
+	}
+
+	const staleNodes = $derived(
+		computeStaleNodes(
+			legacyView.nodes,
+			$workflow.edges,
+			nodeStatus,
+			nodeInputSnapshots
+		)
+	);
+
+	function canvasCenter(): { x: number; y: number } {
+		if (!canvasEl) return { x: 200, y: 200 };
+		const r = canvasEl.getBoundingClientRect();
+		return {
+			x: (r.width / 2 - viewport.x) / viewport.zoom - 150,
+			y: (r.height / 2 - viewport.y) / viewport.zoom - 60
+		};
+	}
+
+	/**
+	 * Walk diagonally from (x, y) in 28px steps until an open spot is found
+	 * that doesn't visually overlap an existing node. Used by any code path
+	 * that drops a fresh node at a fixed fallback position (canvas center,
+	 * picker create, etc.) — without this, successive adds stack identically.
+	 */
+	function findFreeSpot(x: number, y: number): { x: number; y: number } {
+		return findFreeSpotImpl(legacyView.nodes, x, y);
+	}
+
+	async function addTemplateToCanvas(
+		template: any,
+		x?: number,
+		y?: number
+	): Promise<string | null> {
+		if (
+			template.source === "space" &&
+			template.space_id &&
+			template.inputs.length === 0
+		) {
+			showToast(`Connecting to ${template.space_id}...`);
+			try {
+				const apiInfo = await fetchSpaceApi(template.space_id);
+				template.inputs = apiInfo.inputs;
+				template.outputs = apiInfo.outputs;
+				template.endpoint = apiInfo.endpoint;
+				template.width = apiInfo.width;
+			} catch (err) {
+				showToast(
+					err instanceof Error ? err.message : "Failed to connect to Space",
+					5000,
+					"error"
+				);
+				return null;
+			}
+		}
+		if (x === undefined || y === undefined) {
+			const nodes = legacyView.nodes;
+			x =
+				nodes.length > 0
+					? Math.max(...nodes.map((n) => n.x + n.width)) + 80
+					: 200;
+			y = nodes.length > 0 ? nodes[nodes.length - 1].y : 150;
+		}
+		return addNode(templateRole(template), template, x, y);
+	}
+
+	async function handleDrop(e: DragEvent): Promise<void> {
+		e.preventDefault();
+		const raw = e.dataTransfer?.getData("node-template");
+		if (!raw) return;
+		const template = JSON.parse(raw);
+		const r = canvasEl.getBoundingClientRect();
+		const x = (e.clientX - r.left - viewport.x) / viewport.zoom - 100;
+		const y = (e.clientY - r.top - viewport.y) / viewport.zoom - 45;
+		await addTemplateToCanvas(template, x, y);
+	}
+
+	function revokeAllBlobUrls(nodes: WFNode[]): void {
+		for (const node of nodes) revoke_blob_urls(node.data);
+	}
+
+	let clearConfirm = $state(false);
+
+	function clearWorkflow(): void {
+		if (legacyView.nodes.length === 0) return;
+		clearConfirm = true;
+	}
+
+	function confirmClearWorkflow(): void {
+		clearConfirm = false;
+		revokeAllBlobUrls(legacyView.nodes);
+		workflow.set({
+			schema_version: "2",
+			name: $workflow.name,
+			runtime: { default: "client" },
+			references: [],
+			operators: [],
+			subjects: [],
+			edges: [],
+			view: { default: "canvas" }
+		});
+	}
+
+	function autoLayout(): void {
+		const sorted = topoSort(legacyView.nodes, $workflow.edges);
+		const edges = $workflow.edges;
+		const depth = new Map<string, number>();
+		for (const node of sorted) {
+			const maxParent = edges
+				.filter((e) => e.to_node_id === node.id)
+				.map((e) => depth.get(e.from_node_id) ?? 0)
+				.reduce((max, d) => Math.max(max, d + 1), 0);
+			depth.set(node.id, maxParent);
+		}
+		const columns = new Map<number, WFNode[]>();
+		for (const node of sorted) {
+			const d = depth.get(node.id) ?? 0;
+			if (!columns.has(d)) columns.set(d, []);
+			columns.get(d)!.push(node);
+		}
+		const gap = 30;
+		const colGap = 80;
+		// Auto-layout produces { id -> {x, y} }; apply to v2 arrays without
+		// changing role membership.
+		const positions = new Map<string, { x: number; y: number }>();
+		let xOffset = 80;
+		for (const [_, col] of [...columns.entries()].sort((a, b) => a[0] - b[0])) {
+			let yOffset = 80;
+			let maxWidth = 0;
+			for (const node of col) {
+				positions.set(node.id, { x: xOffset, y: yOffset });
+				yOffset += node.height + gap;
+				maxWidth = Math.max(maxWidth, node.width);
+			}
+			xOffset += maxWidth + colGap;
+		}
+		workflow.update((wf) => {
+			const reposition = <T extends { id: string; x: number; y: number }>(
+				n: T
+			): T => {
+				const p = positions.get(n.id);
+				return p ? { ...n, x: p.x, y: p.y } : n;
+			};
+			return {
+				...wf,
+				references: wf.references.map(reposition),
+				operators: wf.operators.map(reposition),
+				subjects: wf.subjects.map(reposition)
+			};
+		});
+	}
+
+	async function runNode(targetId: string): Promise<void> {
+		if (running) return;
+		await runWorkflow(buildUpstreamSubgraphImpl($workflow, targetId));
+	}
+
+	async function runWorkflow(target?: Workflow): Promise<void> {
+		if (running) return;
+		running = true;
+		const wfToRun = target ?? $workflow;
+		// Clear status only for nodes we're about to run, so already-finished
+		// nodes outside the target subgraph keep their snapshots + state.
+		const runningIds = new Set([
+			...wfToRun.references.map((n) => n.id),
+			...wfToRun.operators.map((n) => n.id),
+			...wfToRun.subjects.map((n) => n.id)
+		]);
+		nodeStatus = Object.fromEntries(
+			Object.entries(nodeStatus).filter(([id]) => !runningIds.has(id))
+		);
+		nodeErrors = Object.fromEntries(
+			Object.entries(nodeErrors).filter(([id]) => !runningIds.has(id))
+		);
+		abortController = new AbortController();
+
+		const oauthToken = await auth.getOAuthToken();
+		const hasAuth = !!oauthToken || !!auth.hfToken;
+		if (
+			legacyView.nodes.some((n) => n.source === "space" && n.space_id) &&
+			!hasAuth
+		) {
+			showToast(
+				"Running as guest — GPU Spaces may hit quota limits. Sign in with HuggingFace for your own compute.",
+				5000,
+				"warning"
+			);
+		}
+
+		const callSpaceWithToken = server?.call_space
+			? async (spaceId: string, endpoint: string, argsJson: string) =>
+					server.call_space([spaceId, endpoint, argsJson, auth.hfToken || ""])
+			: undefined;
+
+		const callModelWithToken = server?.call_model
+			? async (
+					modelId: string,
+					pipelineTag: string,
+					argsJson: string,
+					provider?: string
+				) =>
+					server.call_model([
+						modelId,
+						pipelineTag,
+						argsJson,
+						auth.hfToken || "",
+						provider ?? ""
+					])
+			: undefined;
+
+		const fetchDatasetWithToken = server?.fetch_dataset
+			? async (
+					datasetId: string,
+					config: string,
+					split: string,
+					offset: string,
+					length: string
+				) =>
+					server.fetch_dataset([
+						datasetId,
+						config,
+						split,
+						offset,
+						length,
+						auth.hfToken || ""
+					])
+			: undefined;
+
+		const callFnWithToken = server?.call_fn
+			? async (fnName: string, argsJson: string) =>
+					server.call_fn([fnName, argsJson])
+			: undefined;
+
+		await executeWorkflow(
+			wfToRun,
+			(nodeId, status, error, errorType) => {
+				nodeStatus = { ...nodeStatus, [nodeId]: status };
+				if (status === "done") {
+					const node = legacyView.nodes.find((n) => n.id === nodeId);
+					if (node) {
+						nodeInputSnapshots = {
+							...nodeInputSnapshots,
+							[nodeId]: JSON.stringify(resolveCurrentInputs(node))
+						};
+					}
+				}
+				if (error) {
+					nodeErrors = { ...nodeErrors, [nodeId]: error };
+					const node = legacyView.nodes.find((n) => n.id === nodeId);
+					const label =
+						node?.label ?? node?.space_id ?? node?.model_id ?? "Node";
+					showToast(
+						`${label}: ${error}`,
+						errorType === "quota" || errorType === "gpu" ? 0 : 5000,
+						"error"
+					);
+				}
+			},
+			(nodeId, portId, value) => {
+				updateNodeData(nodeId, portId, value);
+			},
+			abortController.signal,
+			callSpaceWithToken,
+			callModelWithToken,
+			fetchDatasetWithToken,
+			callFnWithToken,
+			(modelId, prompt, provider, signal, onChunk) =>
+				stream_text_generation({
+					modelId,
+					prompt,
+					provider,
+					hfToken: auth.hfToken || undefined,
+					signal: signal ?? undefined,
+					onChunk
+				})
+		);
+
+		running = false;
+		abortController = null;
+
+		const hasErrors = Object.values(nodeStatus).some((s) => s === "error");
+		showToast(
+			hasErrors ? "Workflow finished with errors" : "Workflow complete",
+			hasErrors ? 5000 : 3000,
+			hasErrors ? "error" : "success"
+		);
+
+		setTimeout(() => {
+			nodeStatus = Object.fromEntries(
+				Object.entries(nodeStatus).filter(([_, s]) => s === "error")
+			);
+		}, 3000);
+	}
+
+	function stopWorkflow(): void {
+		abortController?.abort();
+		running = false;
+		abortController = null;
+		nodeStatus = Object.fromEntries(
+			Object.entries(nodeStatus).map(([id, s]) => [
+				id,
+				s === "running" ? "idle" : s
+			])
+		);
+		showToast("Stopped", 3000, "warning");
+	}
+
+	function handleGlobalClick(e: MouseEvent): void {
+		const target = e.target as HTMLElement;
+		if (dropChoice && !target?.closest(".drop-menu")) {
+			dropChoice = null;
+			pendingDrop = null;
+		}
+		if (doubleClickMenu && !target?.closest(".add-node-menu")) {
+			doubleClickMenu = null;
+		}
+		if (
+			showShortcuts &&
+			!target?.closest(".shortcuts-panel") &&
+			!target?.closest(".zoom-controls")
+		) {
+			showShortcuts = false;
+		}
+		if (activePicker && !target?.closest(".picker-panel")) {
+			activePicker = null;
+		}
+	}
+
+	function zoomToFit(): void {
+		const nodes = legacyView.nodes;
+		if (nodes.length === 0) {
+			viewport = { x: 0, y: 0, zoom: 1 };
+			return;
+		}
+		const padding = 60;
+		const minX = Math.min(...nodes.map((n) => n.x));
+		const minY = Math.min(...nodes.map((n) => n.y));
+		const maxX = Math.max(...nodes.map((n) => n.x + n.width));
+		const maxY = Math.max(...nodes.map((n) => n.y + n.height));
+		const contentW = maxX - minX + padding * 2;
+		const contentH = maxY - minY + padding * 2;
+		if (!canvasEl) {
+			viewport = { x: 0, y: 0, zoom: 1 };
+			return;
+		}
+		const r = canvasEl.getBoundingClientRect();
+		const newZoom = Math.min(
+			Math.max(Math.min(r.width / contentW, r.height / contentH), 0.15),
+			2
+		);
+		viewport = {
+			x: (r.width - contentW * newZoom) / 2 - (minX - padding) * newZoom,
+			y: (r.height - contentH * newZoom) / 2 - (minY - padding) * newZoom,
+			zoom: newZoom
+		};
+	}
+
+	function selectNode(id: string): void {
+		selectedNodeId = id;
+	}
+
+	function duplicateNode(id: string): void {
+		const node = legacyView.nodes.find((n) => n.id === id);
+		if (!node) return;
+		const { id: _, data: __, ...template } = node;
+		selectedNodeId = addNode(
+			templateRole(template),
+			template,
+			node.x + 40,
+			node.y + 40
+		);
+	}
+
+	function handleKeydown(e: KeyboardEvent): void {
+		if (
+			e.key === "Enter" &&
+			(e.metaKey || e.ctrlKey) &&
+			!running &&
+			hasTransforms
+		) {
+			e.preventDefault();
+			runWorkflow();
+			return;
+		}
+		const tag = (e.target as HTMLElement)?.tagName;
+		if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return;
+		if ((e.key === "Delete" || e.key === "Backspace") && selectedNodeId) {
+			e.preventDefault();
+			const id = selectedNodeId;
+			selectedNodeId = null;
+			requestAnimationFrame(() => removeNode(id));
+		}
+		if (e.key === "d" && (e.metaKey || e.ctrlKey) && selectedNodeId) {
+			e.preventDefault();
+			duplicateNode(selectedNodeId);
+		}
+		if (e.key === "f" && !e.metaKey && !e.ctrlKey) {
+			e.preventDefault();
+			zoomToFit();
+		}
+		if (e.key === "0" && (e.metaKey || e.ctrlKey)) {
+			e.preventDefault();
+			viewport = { x: 0, y: 0, zoom: 1 };
+		}
+		if (e.key === "Escape") {
+			selectedNodeId = null;
+			activeConnection = null;
+			activePicker = null;
+			pendingDrop = null;
+			dropChoice = null;
+			doubleClickMenu = null;
+			clearConfirm = false;
+		}
+		if (e.key === "Enter" && clearConfirm) {
+			e.preventDefault();
+			confirmClearWorkflow();
+		}
+	}
+
+	function openPicker(modality: ModalityConfig): void {
+		activePicker = { mode: "create", modality };
+	}
+
+	function openPickerForNode(nodeId: string): void {
+		const node = legacyView.nodes.find((n) => n.id === nodeId);
+		if (!node) return;
+
+		// Components no longer open the picker — only transform nodes can have
+		// their model/space swapped. Guard so any stale callers no-op cleanly.
+		if (node.kind !== "transform") return;
+
+		let modality: ModalityConfig;
+		let initialSource: "spaces" | "models" | "datasets" = "spaces";
+		if (node.dataset_id) {
+			modality = DATASET_MODALITY;
+			initialSource = "datasets";
+		} else {
+			const cat = node.pipeline_tag
+				? getModalityForPipelineTag(node.pipeline_tag)
+				: "image";
+			modality = MODALITIES.find((m) => m.category === cat) ?? MODALITIES[0];
+			initialSource = node.model_id ? "models" : "spaces";
+		}
+
+		let anchorX: number | undefined;
+		let anchorY: number | undefined;
+		if (canvasEl) {
+			const r = canvasEl.getBoundingClientRect();
+			const panelWidth = 536;
+			const panelHeight = 620;
+			const nodeScreenRight =
+				node.x * viewport.zoom + viewport.x + node.width * viewport.zoom;
+			anchorX = nodeScreenRight + 12;
+			if (anchorX + panelWidth > r.width) {
+				anchorX = Math.max(
+					4,
+					node.x * viewport.zoom + viewport.x - panelWidth - 12
+				);
+			}
+			anchorX = Math.max(4, anchorX);
+			anchorY = Math.max(
+				4,
+				Math.min(
+					node.y * viewport.zoom + viewport.y,
+					r.height - panelHeight - 8
+				)
+			);
+		}
+
+		activePicker = {
+			mode: "update",
+			modality,
+			nodeId,
+			anchorX,
+			anchorY,
+			initialSource
+		};
+	}
+
+	function getModalityForPipelineTag(tag: string): string {
+		const map: Record<string, string> = {
+			"text-to-image": "image",
+			"image-to-image": "image",
+			"text-to-audio": "audio",
+			"text-to-speech": "audio",
+			"automatic-speech-recognition": "audio",
+			"text-to-video": "video",
+			"image-to-video": "video",
+			"text-to-3d": "3d",
+			"image-to-3d": "3d",
+			"text-generation": "text",
+			summarization: "text",
+			translation: "text"
+		};
+		return map[tag] ?? "image";
+	}
+
+	const SUBGRAPH_PORT_TYPES = new Set([
+		"image",
+		"audio",
+		"video",
+		"text",
+		"file",
+		"gallery",
+		"boolean",
+		"number"
+	]);
+
+	async function handlePickerCreate(template: any): Promise<void> {
+		activePicker = null;
+		const drop = pendingDrop;
+		pendingDrop = null;
+		let x: number, y: number;
+		if (drop) {
+			x = drop.reversed
+				? drop.x - (template.width ?? 200) - 80
+				: drop.x - (template.width ?? 200) / 2;
+			y = drop.y - 60;
+		} else {
+			({ x, y } = findFreeSpot(canvasCenter().x, canvasCenter().y));
+		}
+		const newId = await addTemplateToCanvas({ ...template }, x, y);
+		if (!newId) return;
+
+		// For spaces added fresh to the canvas (not wired from an existing port),
+		// auto-create input + output components to form a ready-to-run subgraph
+		const isSpaceFresh =
+			template.source === "space" && (!drop || drop.positionOnly);
+		if (isSpaceFresh) {
+			const spaceNode = legacyView.nodes.find((n) => n.id === newId);
+			if (spaceNode) {
+				const compGap = 24;
+				const compH = 180;
+				const inputPorts = spaceNode.inputs.filter((p) =>
+					SUBGRAPH_PORT_TYPES.has(p.type)
+				);
+				const outputPorts = spaceNode.outputs.filter((p) =>
+					SUBGRAPH_PORT_TYPES.has(p.type)
+				);
+
+				const inTotal = inputPorts.length * (compH + compGap) - compGap;
+				const inStartY = y + (spaceNode.height ?? 90) / 2 - inTotal / 2;
+				inputPorts.forEach((port, i) => {
+					const comp = getComponentForPortType(port.type);
+					if (!comp) return;
+					const { x: cx, y: cy } = findFreeSpot(
+						x - 220 - 80,
+						inStartY + i * (compH + compGap)
+					);
+					const cId = addNode("reference", comp, cx, cy);
+					addEdge({
+						from_node_id: cId,
+						from_port_id: "out",
+						to_node_id: newId,
+						to_port_id: port.id,
+						type: port.type
+					});
+				});
+
+				const outTotal = outputPorts.length * (compH + compGap) - compGap;
+				const outStartY = y + (spaceNode.height ?? 90) / 2 - outTotal / 2;
+				outputPorts.forEach((port, i) => {
+					const comp = getComponentForPortType(port.type);
+					if (!comp) return;
+					const { x: cx, y: cy } = findFreeSpot(
+						x + (spaceNode.width ?? 280) + 80,
+						outStartY + i * (compH + compGap)
+					);
+					const cId = addNode("subject", comp, cx, cy);
+					addEdge({
+						from_node_id: newId,
+						from_port_id: port.id,
+						to_node_id: cId,
+						to_port_id: "in",
+						type: port.type
+					});
+				});
+			}
+			return;
+		}
+
+		// Wiring from an existing port drag
+		if (drop && !drop.positionOnly) {
+			const newNode = legacyView.nodes.find((n) => n.id === newId);
+			if (drop.reversed) {
+				const outputPort = newNode?.outputs.find((p: any) =>
+					ports_compatible(p.type, drop.type)
+				);
+				if (outputPort) {
+					addEdge({
+						from_node_id: newId,
+						from_port_id: outputPort.id,
+						to_node_id: drop.from_node_id,
+						to_port_id: drop.from_port_id,
+						type: drop.type
+					});
+				}
+			} else {
+				const inputPort = newNode?.inputs.find((p: any) =>
+					ports_compatible(drop.type, p.type)
+				);
+				if (inputPort) {
+					addEdge({
+						from_node_id: drop.from_node_id,
+						from_port_id: drop.from_port_id,
+						to_node_id: newId,
+						to_port_id: inputPort.id,
+						type: drop.type
+					});
+				}
+			}
+		}
+	}
+
+	function handlePickerUpdate(nodeId: string, template: any): void {
+		replaceNodeSource(nodeId, template);
+		activePicker = null;
+	}
+
+	function addInputNode(portType: string, cx?: number, cy?: number): void {
+		let pos: { x: number; y: number };
+		if (cx !== undefined && cy !== undefined) {
+			const r = canvasEl?.getBoundingClientRect();
+			pos = r
+				? {
+						x: (cx - r.left - viewport.x) / viewport.zoom,
+						y: (cy - r.top - viewport.y) / viewport.zoom
+					}
+				: canvasCenter();
+		} else {
+			pos = canvasCenter();
+		}
+		const typedComponents: Record<string, any> = {};
+		for (const c of LIBRARY.components) {
+			typedComponents[c.outputs[0]?.type ?? "any"] = c;
+		}
+		const template = typedComponents[portType] ?? LIBRARY.components[0];
+		const half = (template.width ?? 200) / 2;
+		const { x, y } = findFreeSpot(pos.x - half, pos.y - 45);
+		addNode("reference", template, x, y);
+	}
+
+	/**
+	 * Spawn a Python fn node from a server-advertised bound function.
+	 * Wire-compatible with `_workflow_from_bind`: same id prefix, same
+	 * port shape, so it merges cleanly with any auto-generated fn nodes
+	 * already on the canvas.
+	 */
+	function addFnNode(tmpl: BoundFnTemplate): void {
+		const half = 110;
+		const { x, y } = findFreeSpot(
+			canvasCenter().x - half,
+			canvasCenter().y - 45
+		);
+		const height =
+			80 + Math.max(tmpl.inputs.length, tmpl.outputs.length, 1) * 36;
+		addNode(
+			"operator",
+			{
+				label: tmpl.label,
+				kind: "fn",
+				source: "fn",
+				fn: tmpl.fn,
+				inputs: tmpl.inputs,
+				outputs: tmpl.outputs,
+				width: 220,
+				height
+			},
+			x,
+			y
+		);
+	}
+
+	function setName(value: string): void {
+		workflow.update((wf) => ({ ...wf, name: value }));
+		editingName = false;
+	}
+</script>
+
+<!-- svelte-ignore a11y_no_static_element_interactions -->
+<div class="workflow-root" onclick={handleGlobalClick}>
+	<div class="toolbar">
+		<div class="toolbar-left">
+			{#if editingName}
+				<input
+					bind:this={nameInput}
+					class="name-input"
+					value={$workflow.name}
+					onblur={(e) => setName(e.currentTarget.value)}
+					onkeydown={(e) => {
+						if (e.key === "Enter") setName(e.currentTarget.value);
+						if (e.key === "Escape") editingName = false;
+					}}
+				/>
+			{:else}
+				<button
+					class="name-btn"
+					onclick={() => {
+						editingName = true;
+						requestAnimationFrame(() => nameInput?.focus());
+					}}
+				>
+					<span class="name-text">{$workflow.name}</span>
+					<span class="name-edit-icon">&#x270E;</span>
+				</button>
+			{/if}
+			<span class="toolbar-stat"
+				>{nodeCount} nodes &middot; {edgeCount} edges</span
+			>
+		</div>
+		<div class="toolbar-right">
+			{#if !auth.isCheckingLogin}
+				{#if auth.loggedInUser}
+					<span class="toolbar-user-info"
+						>Logged in as <strong>{auth.loggedInUser}</strong></span
+					>
+					{#if auth.isHFSpace}
+						<button
+							class="toolbar-login-btn logged-in"
+							onclick={auth.handleLogout}>Log out</button
+						>
+					{/if}
+				{:else if auth.isHFSpace}
+					<button class="toolbar-login-btn" onclick={auth.handleLogin}
+						>Sign in with 🤗</button
+					>
+				{:else}
+					<form class="toolbar-token-form" onsubmit={(e) => e.preventDefault()}>
+						<input
+							class="toolbar-token-input"
+							class:has-user={!!auth.tokenUser}
+							class:invalid={auth.tokenStatus === "invalid"}
+							type="password"
+							placeholder="Paste HF token (hf_...)"
+							value={auth.hfToken}
+							onchange={(e) => auth.saveToken(e.currentTarget.value)}
+							title="HuggingFace token for GPU access"
+						/>
+						{#if auth.tokenUser}
+							<span
+								class="toolbar-token-status valid"
+								title={`Signed in as ${auth.tokenUser}`}
+							>
+								<CheckIcon />
+								{auth.tokenUser}
+							</span>
+						{:else if auth.tokenStatus === "validating"}
+							<span class="toolbar-token-status validating">checking…</span>
+						{:else if auth.tokenStatus === "invalid"}
+							<span class="toolbar-token-status invalid">invalid</span>
+						{/if}
+					</form>
+				{/if}
+			{/if}
+			<button class="tool-btn" onclick={autoLayout} title="Auto-arrange nodes"
+				>Layout</button
+			>
+			<button class="tool-btn" onclick={clearWorkflow}>Clear</button>
+		</div>
+	</div>
+
+	<!-- svelte-ignore a11y_no_static_element_interactions -->
+	<div
+		class="editor"
+		class:editor-panning={dragMode?.kind === "pan"}
+		bind:this={canvasEl}
+		ondragover={(e) => e.preventDefault()}
+		ondrop={handleDrop}
+		ondblclick={handleCanvasDoubleClick}
+		onpointerdown={onCanvasPointerDown}
+		onpointermove={onCanvasPointerMove}
+		onpointerup={onCanvasPointerUp}
+		onwheel={onWheel}
+	>
+		<!-- Dot grid background — fixed in screen space, parallax-free -->
+		<div
+			class="canvas-bg"
+			style="background-position: {viewport.x}px {viewport.y}px; background-size: {gridTile}px {gridTile}px;"
+		></div>
+
+		<!-- Viewport: all nodes + edges live in here, sharing one transform -->
+		<div
+			class="canvas-viewport"
+			style="transform: translate({viewport.x}px, {viewport.y}px) scale({viewport.zoom});"
+		>
+			<!-- Edges layer (SVG). overflow:visible so edges aren't clipped. -->
+			<svg class="edges-layer" width="1" height="1" style="overflow: visible;">
+				{#each legacyView.edges as edge (edge.id)}
+					{@const path = edgePath(edge)}
+					{#if path}
+						<path
+							class="edge-path"
+							d={path}
+							stroke={PORT_COLOR[edge.type] ?? "#6b6e78"}
+							stroke-width={2 / viewport.zoom}
+							fill="none"
+							onclick={() => removeEdge(edge.id)}
+						/>
+					{/if}
+				{/each}
+				{#if dragMode?.kind === "connection"}
+					{@const preview = connectionPreviewPath(dragMode)}
+					{#if preview}
+						<path
+							class="edge-preview"
+							d={preview}
+							stroke={PORT_COLOR[dragMode.type] ?? "#6b6e78"}
+							stroke-width={2 / viewport.zoom}
+							stroke-dasharray="6 4"
+							fill="none"
+						/>
+					{/if}
+				{/if}
+			</svg>
+
+			<!-- Nodes layer -->
+			{#each legacyView.nodes as n (n.id)}
+				<div
+					class="node-pos-wrap"
+					class:node-pos-selected={selectedNodeId === n.id}
+					data-node-id={n.id}
+					style="left: {n.x}px; top: {n.y}px; width: {n.width}px;"
+					onpointerdown={(e) => startNodeDrag(e, n.id)}
+				>
+					<WorkflowNodeSF
+						id={n.id}
+						data={n}
+						selected={selectedNodeId === n.id}
+					/>
+				</div>
+			{/each}
+		</div>
+
+		{#if nodeCount === 0}
+			<WorkflowEmptyState />
+		{/if}
+
+		{#if running}
+			<div class="run-overlay"></div>
+		{/if}
+
+		{#if dropChoice}
+			<!-- svelte-ignore a11y_no_static_element_interactions -->
+			<!-- Stop click + mousedown propagation: handleGlobalClick on
+			     workflow-root closes activePicker when the click target is
+			     outside .picker-panel. Without onclick stopPropagation, a
+			     "Generate" click here would set activePicker and then have
+			     the very same click bubble out and close it. -->
+			<div
+				class="drop-menu"
+				style="left: {dropChoice.clientX}px; top: {dropChoice.clientY}px;"
+				onmousedown={(e) => e.stopPropagation()}
+				onclick={(e) => e.stopPropagation()}
+			>
+				{#if dropChoice.modelOptions.length > 0}
+					<div class="drop-section-label">Models</div>
+					{#each dropChoice.modelOptions as opt}
+						<button
+							class="drop-opt"
+							onclick={() => handleDropChoiceModel(opt.subtab)}
+							>{opt.label}</button
+						>
+					{/each}
+				{/if}
+				{#if dropChoice.componentOptions.length > 0}
+					<div class="drop-section-label">
+						{dropChoice.reversed ? "Sources" : "Outputs"}
+					</div>
+					{#each dropChoice.componentOptions as opt}
+						<button class="drop-opt" onclick={handleDropChoiceUpload}
+							>{opt.label}</button
+						>
+					{/each}
+				{/if}
+			</div>
+		{/if}
+
+		{#if doubleClickMenu}
+			<!-- svelte-ignore a11y_no_static_element_interactions -->
+			<!-- Stop click+mousedown so handleGlobalClick (on .workflow-root)
+			     doesn't close the menu before the inner button fires.
+			     Same bug we fixed on .drop-menu earlier. -->
+			<div
+				class="add-node-menu"
+				style="left: {doubleClickMenu.clientX}px; top: {doubleClickMenu.clientY}px;"
+				onmousedown={(e) => e.stopPropagation()}
+				onclick={(e) => e.stopPropagation()}
+			>
+				<div class="add-node-section-label">Add</div>
+				<div class="add-node-grid">
+					<button class="add-node-type-btn" onclick={handleDoubleClickUpload}
+						>Upload Media</button
+					>
+					<button
+						class="add-node-type-btn"
+						onclick={() => handleDoubleClickInputNode("text" as PortType)}
+						>Text</button
+					>
+				</div>
+				<div class="add-node-divider"></div>
+				<div class="add-node-section-label">Space / Model</div>
+				<div class="add-node-grid">
+					{#each MODALITIES.filter( (m) => ["image", "audio", "video", "text", "3d"].includes(m.key) ) as m}
+						<button
+							class="add-node-type-btn"
+							onclick={() => handleDoubleClickSpaceModel(m)}>{m.label}</button
+						>
+					{/each}
+				</div>
+			</div>
+		{/if}
+
+		<div class="zoom-controls">
+			<button
+				class="zoom-ctrl-btn"
+				onclick={() => (showShortcuts = !showShortcuts)}
+				title="Keyboard shortcuts">?</button
+			>
+			<button class="zoom-ctrl-btn" onclick={zoomToFit} title="Fit all (F)"
+				>&#x2922;</button
+			>
+			<button
+				class="zoom-ctrl-btn"
+				onclick={() => {
+					viewport = { ...viewport, zoom: Math.max(0.15, viewport.zoom / 1.2) };
+				}}>−</button
+			>
+			<button
+				class="zoom-btn"
+				onclick={() => {
+					viewport = { x: 0, y: 0, zoom: 1 };
+				}}>{Math.round(viewport.zoom * 100)}%</button
+			>
+			<button
+				class="zoom-ctrl-btn"
+				onclick={() => {
+					viewport = { ...viewport, zoom: Math.min(4, viewport.zoom * 1.2) };
+				}}>+</button
+			>
+		</div>
+
+		{#if showShortcuts}
+			<div class="shortcuts-panel">
+				<div class="shortcuts-title">Keyboard shortcuts</div>
+				<div class="shortcut-row">
+					<kbd>Cmd+Enter</kbd> <span>Run workflow</span>
+				</div>
+				<div class="shortcut-row">
+					<kbd>Cmd+D</kbd> <span>Duplicate node</span>
+				</div>
+				<div class="shortcut-row"><kbd>F</kbd> <span>Zoom to fit</span></div>
+				<div class="shortcut-row"><kbd>Cmd+0</kbd> <span>Reset zoom</span></div>
+				<div class="shortcut-row">
+					<kbd>Delete</kbd> <span>Remove node</span>
+				</div>
+				<div class="shortcut-row"><kbd>Escape</kbd> <span>Deselect</span></div>
+				<div class="shortcut-row"><kbd>Scroll</kbd> <span>Zoom</span></div>
+				<div class="shortcut-row"><kbd>Drag canvas</kbd> <span>Pan</span></div>
+				<div class="shortcut-row">
+					<kbd>Double-click</kbd> <span>Rename node</span>
+				</div>
+			</div>
+		{/if}
+
+		<WorkflowBottomBar
+			{running}
+			{hasTransforms}
+			{boundFns}
+			onopenpicker={openPicker}
+			onaddinput={addInputNode}
+			onaddfn={addFnNode}
+			onrun={() => void runWorkflow()}
+			onstop={stopWorkflow}
+		/>
+
+		{#if activePicker}
+			<!-- Key on modality so swapping the bottom-bar modality button
+			     while the picker is open re-mounts the component and
+			     re-fetches Trending / New for the new modality. Without
+			     this, NodeModelPicker just sees its `modality` prop change
+			     and keeps stale activeSubtab + results. -->
+			{#key activePicker.modality.key}
+				<NodeModelPicker
+					mode={activePicker.mode}
+					modality={activePicker.modality}
+					nodeId={activePicker.nodeId}
+					initialSource={activePicker.initialSource}
+					initialSubtab={activePicker.initialSubtab}
+					{server}
+					hfToken={auth.hfToken}
+					anchorX={activePicker.anchorX}
+					anchorY={activePicker.anchorY}
+					oncreate={handlePickerCreate}
+					onupdate={handlePickerUpdate}
+					onclose={() => {
+						activePicker = null;
+					}}
+					onerror={(msg) => showToast(msg, 5000, "error")}
+				/>
+			{/key}
+		{/if}
+	</div>
+
+	{#if toasts.length > 0}
+		<div class="wf-toast-stack">
+			{#each toasts as t (t.id)}
+				<div class="wf-toast wf-toast-{t.type}">
+					<span class="wf-toast-msg">{t.message}</span>
+					<button
+						class="wf-toast-close"
+						aria-label="Dismiss"
+						title="Dismiss"
+						onclick={() => (toasts = toasts.filter((x) => x.id !== t.id))}
+					>
+						×
+					</button>
+				</div>
+			{/each}
+		</div>
+	{/if}
+
+	{#if clearConfirm}
+		<!-- svelte-ignore a11y_click_events_have_key_events -->
+		<!-- svelte-ignore a11y_no_static_element_interactions -->
+		<div class="wf-modal-backdrop" onclick={() => (clearConfirm = false)}>
+			<div
+				class="wf-modal"
+				role="dialog"
+				aria-modal="true"
+				aria-labelledby="wf-modal-title"
+				onclick={(e) => e.stopPropagation()}
+			>
+				<div class="wf-modal-title" id="wf-modal-title">Clear workflow?</div>
+				<div class="wf-modal-body">
+					This will remove <strong>{nodeCount}</strong>
+					{nodeCount === 1 ? "node" : "nodes"} and
+					<strong>{edgeCount}</strong>
+					{edgeCount === 1 ? "edge" : "edges"}. This can't be undone.
+				</div>
+				<div class="wf-modal-actions">
+					<button class="wf-modal-btn" onclick={() => (clearConfirm = false)}
+						>Cancel</button
+					>
+					<button
+						class="wf-modal-btn wf-modal-btn-danger"
+						onclick={confirmClearWorkflow}>Clear</button
+					>
+				</div>
+			</div>
+		</div>
+	{/if}
+</div>
+
+<style>
+	@import "./WorkflowCanvas.css";
+
+	/* ─── Custom canvas ─────────────────────────────────────────────────────── */
+	.editor {
+		cursor: grab;
+	}
+
+	.editor.editor-panning {
+		cursor: grabbing;
+	}
+
+	.canvas-bg {
+		position: absolute;
+		inset: 0;
+		background-image: radial-gradient(#2a2b36 1px, transparent 1px);
+		background-repeat: repeat;
+		pointer-events: none;
+	}
+
+	.canvas-viewport {
+		position: absolute;
+		top: 0;
+		left: 0;
+		transform-origin: 0 0;
+		width: 0;
+		height: 0;
+	}
+
+	.edges-layer {
+		position: absolute;
+		top: 0;
+		left: 0;
+		overflow: visible;
+		pointer-events: none;
+	}
+
+	.edges-layer .edge-path {
+		cursor: pointer;
+		pointer-events: stroke;
+		transition: stroke-width 0.1s;
+	}
+
+	.edges-layer .edge-path:hover {
+		stroke-width: 3 !important;
+	}
+
+	.edges-layer .edge-preview {
+		pointer-events: none;
+	}
+
+	.node-pos-wrap {
+		position: absolute;
+		touch-action: none;
+		z-index: 1;
+	}
+
+	.node-pos-wrap.node-pos-selected {
+		z-index: 2;
+	}
+
+	:global(body:not(.dark)) .canvas-bg {
+		background-image: radial-gradient(#d0d2dc 1px, transparent 1px);
+	}
+
+	/* ─── Light mode ─── */
+	:global(body:not(.dark) .workflow-root) {
+		background: #f8f9fb;
+		border-color: #e2e4ea;
+		color-scheme: light;
+		box-shadow:
+			0 0 0 1px rgba(0, 0, 0, 0.04),
+			0 20px 60px rgba(0, 0, 0, 0.08);
+	}
+
+	:global(body:not(.dark) .toolbar) {
+		background: #ffffff;
+		border-bottom-color: #e2e4ea;
+	}
+
+	:global(body:not(.dark) .name-btn:hover) {
+		background: #f0f1f5;
+	}
+	:global(body:not(.dark) .name-text) {
+		color: #1a1b25;
+	}
+	:global(body:not(.dark) .name-edit-icon) {
+		color: #b0b2bc;
+	}
+	:global(body:not(.dark) .name-input) {
+		background: #ffffff;
+		color: #1a1b25;
+	}
+	:global(body:not(.dark) .toolbar-stat) {
+		color: #b0b2bc;
+	}
+	:global(body:not(.dark) .tool-btn) {
+		border-color: #e2e4ea;
+		color: #8b8d98;
+	}
+	:global(body:not(.dark) .tool-btn:hover) {
+		background: #f0f1f5;
+		color: #3e4050;
+		border-color: #d0d2dc;
+	}
+	:global(body:not(.dark) .toolbar-login-btn) {
+		border-color: #e2e4ea;
+		color: #6b6e78;
+	}
+	:global(body:not(.dark) .toolbar-login-btn:hover) {
+		background: #f0f1f5;
+		color: #1a1b25;
+		border-color: #d0d2dc;
+	}
+	:global(body:not(.dark) .toolbar-login-btn.logged-in) {
+		color: #8b8d98;
+	}
+	:global(body:not(.dark) .toolbar-user-info) {
+		color: #8b8d98;
+	}
+	:global(body:not(.dark) .toolbar-user-info strong) {
+		color: #3e4050;
+	}
+	:global(body:not(.dark) .toolbar-token-input) {
+		background: #ffffff;
+		color: #6b6e78;
+		border-color: #e2e4ea;
+	}
+	:global(body:not(.dark) .toolbar-token-input::placeholder) {
+		color: #c0c2cc;
+	}
+	:global(body:not(.dark) .toolbar-token-input:focus) {
+		background: #ffffff;
+		color: #3e4050;
+	}
+	:global(body:not(.dark) .toolbar-divider) {
+		background: #e2e4ea;
+	}
+	:global(body:not(.dark) .zoom-controls) {
+		background: #ffffff;
+		border-color: #e2e4ea;
+	}
+	:global(body:not(.dark) .zoom-ctrl-btn) {
+		color: #9a9caa;
+	}
+	:global(body:not(.dark) .zoom-ctrl-btn:hover) {
+		background: #f0f1f5;
+		color: #3e4050;
+	}
+	:global(body:not(.dark) .zoom-btn) {
+		background: #ffffff;
+		border-color: #e2e4ea;
+		color: #9a9caa;
+	}
+	:global(body:not(.dark) .zoom-btn:hover) {
+		color: #3e4050;
+		border-color: #d0d2dc;
+	}
+	:global(body:not(.dark) .shortcuts-panel) {
+		background: #ffffff;
+		border-color: #e2e4ea;
+		box-shadow: 0 8px 24px rgba(0, 0, 0, 0.1);
+	}
+	:global(body:not(.dark) .shortcuts-title) {
+		color: #6b6e78;
+	}
+	:global(body:not(.dark) .shortcut-row) {
+		color: #9a9caa;
+	}
+	:global(body:not(.dark) .shortcut-row kbd) {
+		background: #f0f1f5;
+		color: #3e4050;
+		border-color: #d0d2dc;
+	}
+	:global(body:not(.dark) .wf-toast) {
+		background: #ffffff;
+		color: #2a2b36;
+		border-color: #e2e4ea;
+		box-shadow: 0 4px 16px rgba(0, 0, 0, 0.1);
+	}
+</style>

6.17.1/workflowcanvas/workflow/WorkflowEdges.svelte

@@ -0,0 +1,207 @@
+<script lang="ts">
+	import { workflow } from "./workflow-store";
+	import { PORT_COLOR } from "./workflow-types";
+	import type { PortType, WFNode } from "./workflow-types";
+
+	interface Props {
+		pending: {
+			from_node_id: string;
+			from_port_id: string;
+			type: PortType;
+			x: number;
+			y: number;
+			reversed?: boolean;
+		} | null;
+		onremove: (id: string) => void;
+		zoom: number;
+		panX: number;
+		panY: number;
+	}
+
+	let { pending, onremove, zoom, panX, panY }: Props = $props();
+
+	function bez(x1: number, y1: number, x2: number, y2: number): string {
+		const cx = Math.max(Math.abs(x2 - x1) * 0.5, 60);
+		return `M ${x1} ${y1} C ${x1 + cx} ${y1}, ${x2 - cx} ${y2}, ${x2} ${y2}`;
+	}
+
+	function getPortPos(
+		nodes: WFNode[],
+		nodeId: string,
+		portId: string,
+		side: "output" | "input"
+	): { x: number; y: number } {
+		// DOM measurement — always accurate regardless of layout
+		const dotEl = document.querySelector(
+			`[data-port-id="${nodeId}:${portId}:${side}"]`
+		);
+		const transformEl = document.querySelector(".canvas-transform");
+		if (dotEl && transformEl) {
+			const dotRect = dotEl.getBoundingClientRect();
+			const transformRect = transformEl.getBoundingClientRect();
+			const edgeX =
+				side === "output"
+					? dotRect.right - transformRect.left
+					: dotRect.left - transformRect.left;
+			return {
+				x: edgeX / zoom,
+				y: (dotRect.top + dotRect.height / 2 - transformRect.top) / zoom
+			};
+		}
+
+		// Fallback
+		const node = nodes.find((n) => n.id === nodeId);
+		if (!node) return { x: 0, y: 0 };
+		const ports = side === "output" ? node.outputs : node.inputs;
+		const idx = ports.findIndex((p) => p.id === portId);
+		const portIndex = idx >= 0 ? idx : 0;
+		const DOT_OUTSET = 24;
+		const x =
+			side === "output"
+				? node.x + node.width + DOT_OUTSET
+				: node.x - DOT_OUTSET;
+		const headerH = node.source === "space" && node.space_id ? 60 : 44;
+		if (side === "input") {
+			return { x, y: node.y + headerH + portIndex * 26 };
+		} else {
+			const portsBlockH = ports.length * 26;
+			return { x, y: node.y + node.height - portsBlockH + portIndex * 26 - 2 };
+		}
+	}
+</script>
+
+<svg class="edge-layer">
+	<defs>
+		{#each $workflow.edges as edge (edge.id)}
+			<linearGradient id="grad-{edge.id}" x1="0%" y1="0%" x2="100%" y2="0%">
+				<stop
+					offset="0%"
+					stop-color={PORT_COLOR[edge.type]}
+					stop-opacity="0.9"
+				/>
+				<stop
+					offset="100%"
+					stop-color={PORT_COLOR[edge.type]}
+					stop-opacity="0.4"
+				/>
+			</linearGradient>
+		{/each}
+	</defs>
+
+	{#each $workflow.edges as edge (edge.id)}
+		{@const from = getPortPos(
+			$workflow.nodes,
+			edge.from_node_id,
+			edge.from_port_id,
+			"output"
+		)}
+		{@const to = getPortPos(
+			$workflow.nodes,
+			edge.to_node_id,
+			edge.to_port_id,
+			"input"
+		)}
+		<!-- glow -->
+		<path
+			d={bez(from.x, from.y, to.x, to.y)}
+			fill="none"
+			stroke={PORT_COLOR[edge.type]}
+			stroke-width={6 / zoom}
+			stroke-opacity="0.08"
+			style="pointer-events: none"
+		/>
+		<!-- hitbox -->
+		<path
+			class="wire-hitbox"
+			d={bez(from.x, from.y, to.x, to.y)}
+			fill="none"
+			stroke="transparent"
+			stroke-width={16 / zoom}
+			onclick={() => onremove(edge.id)}
+			role="button"
+			tabindex="-1"
+		/>
+		<!-- wire -->
+		<path
+			class="wire"
+			d={bez(from.x, from.y, to.x, to.y)}
+			fill="none"
+			stroke="url(#grad-{edge.id})"
+			stroke-width={2 / zoom}
+			style="pointer-events: none"
+		/>
+		<!-- flow particles -->
+		<path
+			class="wire-flow"
+			d={bez(from.x, from.y, to.x, to.y)}
+			fill="none"
+			stroke={PORT_COLOR[edge.type]}
+			stroke-width={2 / zoom}
+			stroke-dasharray="{4 / zoom} {12 / zoom}"
+			stroke-opacity="0.5"
+			style="pointer-events: none"
+		/>
+	{/each}
+
+	{#if pending}
+		{@const anchor = getPortPos(
+			$workflow.nodes,
+			pending.from_node_id,
+			pending.from_port_id,
+			pending.reversed ? "input" : "output"
+		)}
+		<path
+			d={pending.reversed
+				? bez(pending.x, pending.y, anchor.x, anchor.y)
+				: bez(anchor.x, anchor.y, pending.x, pending.y)}
+			fill="none"
+			stroke={PORT_COLOR[pending.type] ?? "#5c5e6a"}
+			stroke-width={2 / zoom}
+			stroke-dasharray="{6 / zoom} {4 / zoom}"
+			stroke-opacity="0.6"
+			style="pointer-events: none"
+		/>
+		<circle
+			cx={pending.x}
+			cy={pending.y}
+			r={4 / zoom}
+			fill="none"
+			stroke={PORT_COLOR[pending.type] ?? "#5c5e6a"}
+			stroke-width={1.5 / zoom}
+			stroke-opacity="0.5"
+			style="pointer-events: none"
+		/>
+	{/if}
+</svg>
+
+<style>
+	.edge-layer {
+		position: absolute;
+		top: 0;
+		left: 0;
+		width: 1px;
+		height: 1px;
+		overflow: visible;
+		pointer-events: none;
+	}
+
+	.wire-hitbox {
+		pointer-events: stroke;
+		cursor: pointer;
+		transition: stroke 0.15s;
+	}
+
+	.wire-hitbox:hover {
+		stroke: rgba(239, 68, 68, 0.25);
+	}
+
+	.wire-flow {
+		animation: flow 1.2s linear infinite;
+	}
+
+	@keyframes flow {
+		to {
+			stroke-dashoffset: -16;
+		}
+	}
+</style>

6.17.1/workflowcanvas/workflow/WorkflowEmptyState.svelte

@@ -0,0 +1,36 @@
+<div class="empty-state">
+	<div class="empty-icon">✦</div>
+	<div class="empty-title">Start building</div>
+	<div class="empty-hint">Add a model or space from the toolbar below</div>
+</div>
+
+<style>
+	.empty-state {
+		position: absolute;
+		inset: 0;
+		display: flex;
+		flex-direction: column;
+		align-items: center;
+		justify-content: center;
+		gap: 8px;
+		pointer-events: none;
+	}
+
+	.empty-icon {
+		font-size: 22px;
+		color: #2a2b36;
+		margin-bottom: 4px;
+	}
+
+	.empty-title {
+		font-size: 15px;
+		font-weight: 700;
+		color: #3e3f4d;
+		letter-spacing: -0.01em;
+	}
+
+	.empty-hint {
+		font-size: 11.5px;
+		color: #2a2b36;
+	}
+</style>

6.17.1/workflowcanvas/workflow/WorkflowNodeSF.svelte

@@ -0,0 +1,1088 @@
+<script lang="ts">
+	import { getContext } from "svelte";
+	import { resizeNode, workflow } from "./workflow-store";
+	import NodeWidget from "./NodeWidget.svelte";
+	import PlayIcon from "./icons/PlayIcon.svelte";
+	import OpenLinkIcon from "./icons/OpenLinkIcon.svelte";
+	import {
+		PORT_COLOR,
+		PORT_COLOR_DIM,
+		ports_compatible
+	} from "./workflow-types";
+	import type {
+		WFNode,
+		PortType,
+		NodeDataValue,
+		NodeStatus
+	} from "./workflow-types";
+
+	interface Props {
+		id: string;
+		data: WFNode;
+		selected?: boolean;
+	}
+
+	let { id, data: node, selected = false }: Props = $props();
+
+	interface WfCtx {
+		pending: {
+			from_node_id: string;
+			from_port_id: string;
+			type: PortType;
+			reversed?: boolean;
+		} | null;
+		nodeStatus: Record<string, NodeStatus>;
+		nodeErrors: Record<string, string>;
+		staleNodes: Set<string>;
+		connectedPorts: Set<string>;
+		ondatachange: (
+			nodeId: string,
+			portId: string,
+			value: NodeDataValue
+		) => void;
+		onremove: (id: string) => void;
+		onopenpicker: (id: string) => void;
+		onswitchendpoint: (id: string, endpointName: string) => void;
+		onhydratendpoints: (id: string, spaceId: string) => void;
+		onrunnode: (id: string) => void;
+		onselect: (id: string) => void;
+		onnodepointerdown: (e: PointerEvent, id: string) => void;
+		onportpointerdown: (
+			e: PointerEvent,
+			nodeId: string,
+			portId: string,
+			type: PortType,
+			isInput: boolean
+		) => void;
+	}
+
+	const ctx = getContext<WfCtx>("wf");
+
+	const pending = $derived(ctx.pending);
+	const status = $derived((ctx.nodeStatus[id] ?? "idle") as NodeStatus);
+	const error = $derived(ctx.nodeErrors[id] ?? "");
+	const isStale = $derived(ctx.staleNodes.has(id));
+	const connectedPorts = $derived(ctx.connectedPorts);
+	// Only operator nodes have meaningful per-node execution. References just
+	// hold values; subjects just display passthrough.
+	const canRunSolo = $derived(node.kind === "transform");
+
+	let nodeEl: HTMLDivElement;
+	let editingLabel = $state(false);
+	let labelInput: HTMLInputElement;
+	let showAllInputs = $state(false);
+
+	const INPUT_COLLAPSE_THRESHOLD = 3;
+
+	function renameNode(newLabel: string): void {
+		const trimmed = newLabel.trim();
+		if (trimmed && trimmed !== node.label) {
+			workflow.update((wf) => ({
+				...wf,
+				nodes: wf.nodes.map((n) =>
+					n.id === node.id ? { ...n, label: trimmed } : n
+				)
+			}));
+		}
+		editingLabel = false;
+	}
+
+	const primaryType = $derived<PortType>(
+		node.outputs[0]?.type ?? node.inputs[0]?.type ?? "any"
+	);
+	const accentColor = $derived(PORT_COLOR[primaryType]);
+	const accentDim = $derived(PORT_COLOR_DIM[primaryType]);
+
+	const isComponent = $derived(node.kind === "component");
+	const componentIsOutput = $derived(
+		isComponent && node.inputs[0]
+			? connectedPorts.has(`${node.id}:${node.inputs[0].id}:input`)
+			: false
+	);
+	const mode = $derived(
+		isComponent ? (componentIsOutput ? "output" : "input") : node.kind
+	);
+
+	const hasWidget = $derived(mode === "input" || mode === "output");
+	const widgetPortId = $derived(
+		mode === "input"
+			? (node.outputs[0]?.id ?? null)
+			: mode === "output"
+				? (node.inputs[0]?.id ?? null)
+				: null
+	);
+	const widgetType = $derived<PortType | null>(
+		mode === "input"
+			? (node.outputs[0]?.type ?? null)
+			: mode === "output"
+				? (node.inputs[0]?.type ?? null)
+				: null
+	);
+	const isReadonly = $derived(mode === "output");
+
+	function sourceHFUrl(n: WFNode): string {
+		if (n.space_id) return `https://huggingface.co/spaces/${n.space_id}`;
+		if (n.model_id) return `https://huggingface.co/${n.model_id}`;
+		if (n.dataset_id) return `https://huggingface.co/datasets/${n.dataset_id}`;
+		return "";
+	}
+
+	const isDropTarget = $derived(
+		pending !== null &&
+			pending.from_node_id !== node.id &&
+			node.inputs.some(
+				(p) =>
+					ports_compatible(pending.type, p.type) &&
+					!connectedPorts.has(`${node.id}:${p.id}:input`)
+			)
+	);
+
+	$effect(() => {
+		if (!nodeEl) return;
+		const ro = new ResizeObserver(([entry]) => {
+			const h = Math.ceil(entry.borderBoxSize[0].blockSize);
+			if (Math.abs(h - node.height) > 1) {
+				resizeNode(node.id, node.width, h);
+			}
+		});
+		ro.observe(nodeEl);
+		return () => ro.disconnect();
+	});
+</script>
+
+<div
+	class="wf-node"
+	class:node-transform={node.kind === "transform"}
+	class:node-running={status === "running"}
+	class:node-done={status === "done"}
+	class:node-error={status === "error"}
+	class:node-stale={isStale}
+	class:node-selected={selected}
+	class:node-droptarget={isDropTarget}
+	class:has-pending={pending !== null}
+	bind:this={nodeEl}
+	onclick={() => ctx.onselect(node.id)}
+	style="
+		width: {node.width}px;
+		--accent: {accentColor};
+		--accent-dim: {accentDim};
+	"
+>
+	<div class="node-header" role="button" tabindex="-1">
+		<div class="node-header-top">
+			{#if status === "running"}
+				<span class="node-status-spinner"></span>
+			{/if}
+			{#if editingLabel}
+				<input
+					bind:this={labelInput}
+					class="node-label-input"
+					value={node.label}
+					onblur={(e) => renameNode(e.currentTarget.value)}
+					onkeydown={(e) => {
+						if (e.key === "Enter") renameNode(e.currentTarget.value);
+						if (e.key === "Escape") editingLabel = false;
+						e.stopPropagation();
+					}}
+					onmousedown={(e) => e.stopPropagation()}
+				/>
+			{:else}
+				<span
+					class="node-label"
+					ondblclick={(e) => {
+						e.stopPropagation();
+						editingLabel = true;
+						requestAnimationFrame(() => labelInput?.select());
+					}}>{node.label}</span
+				>
+			{/if}
+			{#if canRunSolo}
+				<button
+					class="node-run"
+					class:node-run-stale={isStale}
+					onpointerdown={(e) => e.stopPropagation()}
+					onmousedown={(e) => e.stopPropagation()}
+					onclick={(e) => {
+						e.stopPropagation();
+						ctx.onrunnode(node.id);
+					}}
+					title={isStale ? "Run this node (inputs changed)" : "Run this node"}
+					aria-label="Run this node"
+				>
+					<PlayIcon />
+				</button>
+			{/if}
+			<button
+				class="node-delete"
+				onpointerdown={(e) => e.stopPropagation()}
+				onmousedown={(e) => e.stopPropagation()}
+				onclick={(e) => {
+					e.stopPropagation();
+					ctx.onremove(node.id);
+				}}
+				title="Delete node">&times;</button
+			>
+		</div>
+	</div>
+
+	<!-- Source label for transform nodes — floats above the card.
+	     Components are pure data containers and have no source label. -->
+	{#if node.kind === "transform"}
+		{#if node.space_id || node.model_id || node.dataset_id}
+			{@const itemId = node.space_id ?? node.model_id ?? node.dataset_id ?? ""}
+			<div class="node-outside-label-wrap">
+				<button
+					class="node-outside-label"
+					title="Click to change source"
+					onpointerdown={(e) => e.stopPropagation()}
+					onmousedown={(e) => e.stopPropagation()}
+					onclick={(e) => {
+						e.stopPropagation();
+						ctx.onopenpicker(node.id);
+					}}>{itemId.split("/").pop() ?? itemId}</button
+				>
+				<a
+					class="node-outside-link"
+					href={sourceHFUrl(node)}
+					target="_blank"
+					rel="noopener noreferrer"
+					title="Open on HuggingFace"
+					onpointerdown={(e) => e.stopPropagation()}
+					onmousedown={(e) => e.stopPropagation()}
+					onclick={(e) => e.stopPropagation()}
+					aria-label="Open on HuggingFace"
+				>
+					<OpenLinkIcon />
+				</a>
+			</div>
+		{:else if node.fn}
+			<!-- Python fn nodes already have a "source" — their function
+			     name. Show that above the card; no picker swap because
+			     fn nodes can't be replaced by a Space/Model in place. -->
+			<div class="node-outside-label-wrap">
+				<span class="node-outside-label node-outside-label-fn">{node.fn}()</span
+				>
+			</div>
+		{:else}
+			<button
+				class="node-outside-label node-outside-label-empty"
+				onpointerdown={(e) => e.stopPropagation()}
+				onmousedown={(e) => e.stopPropagation()}
+				onclick={(e) => {
+					e.stopPropagation();
+					ctx.onopenpicker(node.id);
+				}}>+ source</button
+			>
+		{/if}
+	{/if}
+
+	{#if node.space_id}
+		<div
+			class="node-endpoint-row"
+			onpointerdown={(e) => e.stopPropagation()}
+			onmousedown={(e) => e.stopPropagation()}
+		>
+			{#if node.endpoints && node.endpoints.length > 1}
+				<select
+					class="node-endpoint-select"
+					value={node.endpoint ?? ""}
+					onpointerdown={(e) => e.stopPropagation()}
+					onmousedown={(e) => e.stopPropagation()}
+					onclick={(e) => e.stopPropagation()}
+					onchange={(e) => {
+						e.stopPropagation();
+						ctx.onswitchendpoint(
+							node.id,
+							(e.currentTarget as HTMLSelectElement).value
+						);
+					}}
+				>
+					{#each node.endpoints as ep}
+						<option value={ep.name}>{ep.name}</option>
+					{/each}
+				</select>
+			{:else if !node.endpoints}
+				<button
+					class="node-endpoint-load"
+					onpointerdown={(e) => e.stopPropagation()}
+					onmousedown={(e) => e.stopPropagation()}
+					onclick={(e) => {
+						e.stopPropagation();
+						ctx.onhydratendpoints(node.id, node.space_id ?? "");
+					}}
+					title="Discover this Space's other endpoints"
+				>
+					{node.endpoint ?? "/predict"} ▾
+				</button>
+			{/if}
+		</div>
+	{/if}
+
+	<!-- Input ports -->
+	{#if node.inputs.length > 0}
+		{@const collapsible = node.inputs.length > INPUT_COLLAPSE_THRESHOLD}
+		<div class="ports" class:widget-ports={hasWidget}>
+			{#each node.inputs as port, i}
+				{@const portConnected = connectedPorts.has(
+					`${node.id}:${port.id}:input`
+				)}
+				{@const visible =
+					showAllInputs || i < INPUT_COLLAPSE_THRESHOLD || portConnected}
+				{#if visible}
+					<div class="port-row input-row" class:widget-port={hasWidget}>
+						<!-- svelte-ignore a11y_no_static_element_interactions -->
+						<div
+							class="port-handle-sf input-handle-sf"
+							class:connected={portConnected}
+							class:incompatible={pending !== null &&
+								!ports_compatible(pending.type, port.type)}
+							class:pulse={pending !== null &&
+								ports_compatible(pending.type, port.type)}
+							data-node-id={node.id}
+							data-port-id={port.id}
+							data-port-type={port.type}
+							data-port-direction="input"
+							style="--port-color: {PORT_COLOR[port.type]}"
+							onpointerdown={(e) =>
+								ctx.onportpointerdown(e, node.id, port.id, port.type, true)}
+						></div>
+						{#if !hasWidget}
+							<span
+								class="port-label"
+								class:port-label-optional={port.required === false}
+								>{port.label}</span
+							>
+							<span class="port-type-tag" style="color: {PORT_COLOR[port.type]}"
+								>{port.type}</span
+							>
+						{/if}
+					</div>
+					{#if !portConnected && node.kind === "transform" && (port.type === "text" || port.type === "number" || port.type === "boolean" || port.type === "any" || port.type === "json")}
+						<div
+							class="port-inline-config"
+							onmousedown={(e) => e.stopPropagation()}
+						>
+							{#if port.type === "number"}
+								<input
+									class="inline-input inline-number"
+									type="number"
+									step="any"
+									placeholder={port.default_value != null
+										? String(port.default_value)
+										: "0"}
+									value={node.data?.[port.id] ?? ""}
+									oninput={(e) =>
+										ctx.ondatachange(
+											node.id,
+											port.id,
+											parseFloat(e.currentTarget.value) || 0
+										)}
+								/>
+							{:else if port.type === "boolean"}
+								<label class="inline-checkbox">
+									<input
+										type="checkbox"
+										checked={!!node.data?.[port.id]}
+										onchange={(e) =>
+											ctx.ondatachange(
+												node.id,
+												port.id,
+												e.currentTarget.checked
+											)}
+									/>
+									<span>{node.data?.[port.id] ? "On" : "Off"}</span>
+								</label>
+							{:else}
+								<input
+									class="inline-input"
+									type="text"
+									placeholder={port.default_value != null
+										? String(port.default_value)
+										: port.label}
+									value={typeof node.data?.[port.id] === "string"
+										? (node.data[port.id] as string)
+										: ""}
+									oninput={(e) =>
+										ctx.ondatachange(node.id, port.id, e.currentTarget.value)}
+								/>
+							{/if}
+						</div>
+					{/if}
+				{/if}
+			{/each}
+			{#if collapsible}
+				<button
+					class="ports-toggle"
+					onmousedown={(e) => e.stopPropagation()}
+					onclick={() => (showAllInputs = !showAllInputs)}
+				>
+					{#if showAllInputs}▴ show less{:else}▾ {node.inputs.length -
+							INPUT_COLLAPSE_THRESHOLD} more params{/if}
+				</button>
+			{/if}
+		</div>
+	{/if}
+
+	<!-- Widget zone -->
+	{#if hasWidget && widgetPortId && widgetType}
+		<NodeWidget
+			{node}
+			{widgetPortId}
+			{widgetType}
+			{isReadonly}
+			ondatachange={ctx.ondatachange}
+		/>
+	{/if}
+
+	<!-- Output ports -->
+	{#if node.outputs.length > 0}
+		<div class="ports" class:widget-ports={hasWidget}>
+			{#each node.outputs as port}
+				{@const portConnected = connectedPorts.has(
+					`${node.id}:${port.id}:output`
+				)}
+				<div class="port-row output-row" class:widget-port={hasWidget}>
+					{#if !hasWidget}
+						<span class="port-type-tag" style="color: {PORT_COLOR[port.type]}"
+							>{port.type}</span
+						>
+						<span class="port-label">{port.label}</span>
+					{/if}
+					<!-- svelte-ignore a11y_no_static_element_interactions -->
+					<div
+						class="port-handle-sf output-handle-sf"
+						class:connected={portConnected}
+						data-node-id={node.id}
+						data-port-id={port.id}
+						data-port-type={port.type}
+						data-port-direction="output"
+						style="--port-color: {PORT_COLOR[port.type]}"
+						onpointerdown={(e) =>
+							ctx.onportpointerdown(e, node.id, port.id, port.type, false)}
+					></div>
+				</div>
+			{/each}
+		</div>
+	{/if}
+
+	{#if status === "error" && error}
+		<div class="node-error-banner">{error}</div>
+	{/if}
+</div>
+
+<style>
+	/* Prevent SvelteFlow from adding its own drag cursor while we use the node header */
+	.wf-node {
+		position: relative;
+		background: #16171f;
+		border: 1px solid #24252e;
+		border-radius: 10px;
+		min-height: 90px;
+		user-select: none;
+		font-family: "Manrope", sans-serif;
+		overflow: visible;
+		transition:
+			box-shadow 0.2s,
+			border-color 0.3s;
+		box-sizing: border-box;
+	}
+
+	/* Space/transform nodes get a subtle top accent to distinguish from component nodes */
+	.wf-node.node-transform {
+		background: #13141c;
+		border-color: #2a2b38;
+	}
+
+	.wf-node.node-transform .node-header {
+		border-bottom-color: #22233a;
+	}
+
+	.wf-node:hover {
+		box-shadow:
+			0 0 0 1px var(--accent-dim),
+			0 4px 20px rgba(0, 0, 0, 0.4);
+	}
+
+	.wf-node.node-selected {
+		border-color: #f97316;
+		box-shadow:
+			0 0 0 1px #f97316,
+			0 0 16px rgba(249, 115, 22, 0.15);
+	}
+
+	.wf-node.node-droptarget {
+		border-color: var(--accent);
+		box-shadow:
+			0 0 0 1px var(--accent),
+			0 0 20px var(--accent-dim);
+	}
+
+	.wf-node.node-running {
+		border-color: #f5a623;
+		box-shadow: 0 0 12px rgba(245, 166, 35, 0.2);
+	}
+
+	.wf-node.node-done {
+		border-color: #4fd1a5;
+		box-shadow: 0 0 12px rgba(79, 209, 165, 0.15);
+	}
+
+	.wf-node.node-error {
+		border-color: #ef4444;
+		box-shadow: 0 0 12px rgba(239, 68, 68, 0.15);
+	}
+
+	/* Stale: ran successfully, but inputs have since changed. Subtle dashed
+	 * outline so the user knows the displayed output no longer reflects
+	 * current upstream state. Overridden by running/error which are stronger
+	 * signals. */
+	.wf-node.node-stale:not(.node-running):not(.node-error) {
+		border-color: #f97316;
+		border-style: dashed;
+		box-shadow: 0 0 10px rgba(249, 115, 22, 0.12);
+	}
+
+	.node-status-spinner {
+		width: 12px;
+		height: 12px;
+		border: 2px solid transparent;
+		border-top-color: #f5a623;
+		border-radius: 50%;
+		animation: node-spin 0.7s linear infinite;
+		flex-shrink: 0;
+	}
+
+	@keyframes node-spin {
+		to {
+			transform: rotate(360deg);
+		}
+	}
+
+	.node-header {
+		display: flex;
+		flex-direction: column;
+		gap: 4px;
+		padding: 9px 12px 8px;
+		cursor: grab;
+		border-bottom: 1px solid #1e1f2a;
+	}
+
+	.node-header:active {
+		cursor: grabbing;
+	}
+
+	.node-header-top {
+		display: flex;
+		align-items: center;
+		gap: 7px;
+	}
+
+	.node-label {
+		font-size: 12.5px;
+		font-weight: 600;
+		color: #d5d6de;
+		white-space: nowrap;
+		cursor: text;
+		flex: 1;
+		min-width: 0;
+		overflow: hidden;
+		padding: 1px 4px;
+		border: 1px solid transparent;
+		border-radius: 4px;
+		box-sizing: border-box;
+		mask-image: linear-gradient(
+			to right,
+			black calc(100% - 24px),
+			transparent 100%
+		);
+		-webkit-mask-image: linear-gradient(
+			to right,
+			black calc(100% - 24px),
+			transparent 100%
+		);
+	}
+
+	.node-label-input {
+		font-family: "Manrope", sans-serif;
+		font-size: 12.5px;
+		font-weight: 600;
+		color: #d5d6de;
+		background: #101118;
+		border: 1px solid #f97316;
+		border-radius: 4px;
+		padding: 1px 4px;
+		outline: none;
+		width: 100%;
+		min-width: 0;
+		box-sizing: border-box;
+	}
+
+	.node-outside-label-wrap {
+		position: absolute;
+		bottom: calc(100% + 6px);
+		/* Anchor to the card's right edge; label sits to the LEFT of the
+		 * open-link icon with a small gap. */
+		right: 0;
+		display: flex;
+		align-items: center;
+		gap: 6px;
+		pointer-events: auto;
+	}
+
+	.node-outside-label {
+		position: absolute;
+		bottom: calc(100% + 6px);
+		right: 12px;
+		white-space: nowrap;
+		font-family: "Manrope", sans-serif;
+		font-size: 11.5px;
+		font-weight: 500;
+		color: #6b6e78;
+		background: transparent;
+		border: none;
+		padding: 0;
+		cursor: pointer;
+		transition: color 0.15s;
+		pointer-events: auto;
+	}
+
+	.node-outside-label-wrap .node-outside-label {
+		position: static;
+		bottom: auto;
+		right: auto;
+	}
+
+	.node-outside-label:hover {
+		color: #c8c9d2;
+	}
+
+	.node-outside-link {
+		display: inline-flex;
+		align-items: center;
+		justify-content: center;
+		width: 16px;
+		height: 16px;
+		color: #4a4d57;
+		opacity: 0;
+		text-decoration: none;
+		border-radius: 3px;
+		transition:
+			opacity 0.15s,
+			color 0.15s,
+			background 0.15s;
+		flex-shrink: 0;
+	}
+
+	.wf-node:hover .node-outside-link,
+	.node-outside-label-wrap:focus-within .node-outside-link {
+		opacity: 1;
+	}
+
+	.node-outside-link:hover {
+		color: #f97316;
+		background: rgba(249, 115, 22, 0.08);
+	}
+
+	.node-outside-label-empty {
+		color: #3a3b47;
+		font-size: 10.5px;
+	}
+
+	.node-outside-label-empty:hover {
+		color: #f97316;
+	}
+
+	.node-outside-label-fn {
+		font-family: "JetBrains Mono", monospace;
+		font-size: 10.5px;
+		color: #8b8d98;
+		cursor: default;
+	}
+
+	.node-delete {
+		display: none;
+		width: 20px;
+		height: 20px;
+		border: none;
+		border-radius: 4px;
+		background: transparent;
+		color: #5c5e6a;
+		font-size: 12px;
+		cursor: pointer;
+		flex-shrink: 0;
+		margin-left: auto;
+		align-items: center;
+		justify-content: center;
+		padding: 0;
+		text-align: center;
+	}
+
+	.wf-node:hover .node-delete {
+		display: flex;
+	}
+
+	.node-delete:hover {
+		background: rgba(239, 68, 68, 0.15);
+		color: #ef4444;
+	}
+
+	/* Per-node run button — hidden by default, revealed on hover, mirrors
+	 * the node-delete affordance pattern. Stale state pulses faintly to
+	 * signal "this needs re-running". */
+	.node-run {
+		display: none;
+		width: 20px;
+		height: 20px;
+		margin-left: auto;
+		border: none;
+		border-radius: 4px;
+		background: transparent;
+		color: #5c5e6a;
+		cursor: pointer;
+		flex-shrink: 0;
+		align-items: center;
+		justify-content: center;
+		padding: 0;
+	}
+
+	.wf-node:hover .node-run {
+		display: flex;
+	}
+
+	.node-run + .node-delete {
+		margin-left: 2px;
+	}
+
+	.node-run:hover {
+		background: rgba(249, 115, 22, 0.18);
+		color: #f97316;
+	}
+
+	.node-run.node-run-stale {
+		display: flex;
+		color: #f97316;
+		animation: node-run-pulse 1.8s ease-in-out infinite;
+	}
+
+	@keyframes node-run-pulse {
+		0%,
+		100% {
+			opacity: 1;
+		}
+		50% {
+			opacity: 0.55;
+		}
+	}
+
+	.ports {
+		padding: 6px 0 8px;
+	}
+
+	.ports.widget-ports {
+		padding: 0;
+	}
+
+	.port-row.widget-port {
+		padding: 0;
+		min-height: 0;
+		position: static;
+	}
+
+	.port-row {
+		display: flex;
+		align-items: center;
+		gap: 7px;
+		padding: 4px 12px;
+		position: relative;
+		min-height: 22px;
+	}
+
+	.input-row {
+		padding-left: 20px;
+	}
+
+	.output-row {
+		justify-content: flex-end;
+		padding-right: 20px;
+	}
+
+	.port-label {
+		font-size: 11.5px;
+		font-weight: 500;
+		color: #8b8d98;
+		white-space: nowrap;
+	}
+
+	.port-label-optional {
+		opacity: 0.5;
+	}
+
+	.port-type-tag {
+		font-family: "JetBrains Mono", monospace;
+		font-size: 9px;
+		font-weight: 500;
+		opacity: 0.5;
+	}
+
+	/* Port handles (plain divs, positioned on each port-row) */
+	.port-handle-sf {
+		width: 12px;
+		height: 12px;
+		border-radius: 50%;
+		border: 2px solid var(--port-color);
+		background: #0c0d10;
+		cursor: crosshair;
+		opacity: 0.5;
+		transition:
+			opacity 0.15s,
+			transform 0.15s,
+			background 0.15s,
+			box-shadow 0.15s;
+		position: absolute;
+		top: 50%;
+		transform: translateY(-50%);
+		touch-action: none;
+	}
+
+	.wf-node:hover .port-handle-sf,
+	.wf-node.node-selected .port-handle-sf,
+	.wf-node.has-pending .port-handle-sf {
+		opacity: 1;
+	}
+
+	.port-handle-sf.incompatible {
+		border-color: #ef4444;
+		opacity: 0.4;
+		animation: none;
+	}
+
+	.port-handle-sf.connected {
+		background: var(--port-color);
+		opacity: 1;
+	}
+
+	.input-handle-sf {
+		left: -24px;
+		right: auto;
+	}
+
+	.output-handle-sf {
+		right: -24px;
+		left: auto;
+		border-radius: 2px;
+		transform: translateY(-50%) rotate(45deg);
+	}
+
+	.port-handle-sf:hover {
+		opacity: 1;
+		background: var(--port-color);
+		box-shadow: 0 0 6px var(--port-color);
+	}
+
+	.output-handle-sf:hover {
+		transform: translateY(-50%) rotate(45deg) scale(1.4);
+	}
+
+	.port-handle-sf.pulse {
+		animation: port-pulse 1s ease-in-out infinite;
+	}
+
+	@keyframes port-pulse {
+		0%,
+		100% {
+			box-shadow: 0 0 0 0 transparent;
+		}
+		50% {
+			box-shadow: 0 0 0 4px var(--port-color);
+			opacity: 0.3;
+		}
+	}
+
+	.node-error-banner {
+		font-family: "JetBrains Mono", monospace;
+		font-size: 9px;
+		color: #fca5a5;
+		background: rgba(239, 68, 68, 0.1);
+		border-top: 1px solid rgba(239, 68, 68, 0.2);
+		border-radius: 0 0 10px 10px;
+		padding: 6px 12px;
+		line-height: 1.4;
+		word-break: break-word;
+		overflow: hidden;
+		max-height: 4.5em;
+		overflow-y: auto;
+	}
+
+	.ports-toggle {
+		display: block;
+		width: 100%;
+		padding: 4px 12px;
+		border: none;
+		background: transparent;
+		font-family: "JetBrains Mono", monospace;
+		font-size: 9px;
+		font-weight: 600;
+		color: #3e3f4d;
+		cursor: pointer;
+		text-align: left;
+		letter-spacing: 0.03em;
+		transition: color 0.15s;
+	}
+
+	.ports-toggle:hover {
+		color: #8b8d98;
+	}
+
+	.port-inline-config {
+		padding: 2px 12px 4px 20px;
+	}
+
+	.inline-input {
+		width: 100%;
+		font-family: "JetBrains Mono", monospace;
+		font-size: 10px;
+		padding: 4px 8px;
+		border: 1px solid #1e1f2a;
+		border-radius: 4px;
+		background: #101118;
+		color: #c8c9d2;
+		outline: none;
+		box-sizing: border-box;
+	}
+
+	.inline-input:focus {
+		border-color: #3e3f4d;
+	}
+
+	.inline-input::placeholder {
+		color: #4a4b58;
+	}
+
+	.inline-number {
+		width: 80px;
+	}
+
+	.inline-checkbox {
+		display: flex;
+		align-items: center;
+		gap: 6px;
+		font-family: "JetBrains Mono", monospace;
+		font-size: 10px;
+		color: #8b8d98;
+		cursor: pointer;
+	}
+
+	/* Light mode */
+	:global(body:not(.dark)) .wf-node {
+		background: #ffffff;
+		border-color: #e2e4ea;
+	}
+
+	:global(body:not(.dark)) .wf-node:hover {
+		box-shadow:
+			0 0 0 1px var(--accent-dim),
+			0 4px 20px rgba(0, 0, 0, 0.08);
+	}
+
+	:global(body:not(.dark)) .node-header {
+		border-bottom-color: #e2e4ea;
+	}
+
+	:global(body:not(.dark)) .node-label {
+		color: #1a1b25;
+	}
+
+	:global(body:not(.dark)) .node-label-input {
+		color: #1a1b25;
+		background: #ffffff;
+	}
+
+	:global(body:not(.dark)) .port-label {
+		color: #6b6e78;
+	}
+
+	:global(body:not(.dark)) .node-outside-label {
+		color: #9a9caa;
+	}
+
+	:global(body:not(.dark)) .node-outside-label:hover {
+		color: #1a1b25;
+	}
+
+	:global(body:not(.dark)) .node-outside-label-empty {
+		color: #c0c2cc;
+	}
+
+	:global(body:not(.dark)) .ports-toggle {
+		color: #b0b2bc;
+	}
+
+	:global(body:not(.dark)) .node-delete {
+		color: #9a9caa;
+	}
+
+	:global(body:not(.dark)) .port-handle-sf {
+		background: #ffffff;
+	}
+
+	:global(body:not(.dark)) .inline-input {
+		background: #f8f9fb;
+		border-color: #e2e4ea;
+		color: #1a1b25;
+	}
+
+	:global(body:not(.dark)) .inline-input::placeholder {
+		color: #c0c2cc;
+	}
+
+	:global(body:not(.dark)) .inline-checkbox {
+		color: #6b6e78;
+	}
+
+	.node-endpoint-row {
+		padding: 2px 12px 0 0;
+		display: flex;
+		justify-content: flex-end;
+	}
+
+	.node-endpoint-select,
+	.node-endpoint-load {
+		font-family: "JetBrains Mono", monospace;
+		font-size: 9.5px;
+		padding: 1px 0 1px 4px;
+		border: none;
+		background: transparent;
+		color: #5c5e6a;
+		cursor: pointer;
+		outline: none;
+		opacity: 0.6;
+		transition:
+			opacity 0.15s,
+			color 0.15s;
+		-webkit-appearance: none;
+		appearance: none;
+		text-align: right;
+		text-align-last: right;
+	}
+
+	.node-endpoint-select:hover,
+	.node-endpoint-load:hover {
+		opacity: 1;
+		color: #a0a2ae;
+	}
+
+	.wf-node:hover .node-endpoint-select,
+	.wf-node:hover .node-endpoint-load {
+		opacity: 1;
+	}
+
+	:global(body:not(.dark)) .node-endpoint-select,
+	:global(body:not(.dark)) .node-endpoint-load {
+		color: #8b8d98;
+	}
+
+	:global(body:not(.dark)) .node-endpoint-select:hover,
+	:global(body:not(.dark)) .node-endpoint-load:hover {
+		color: #3e4050;
+	}
+</style>

6.17.1/workflowcanvas/workflow/WorkflowSidebar.svelte

@@ -0,0 +1,1727 @@
+<script lang="ts">
+	import {
+		LIBRARY,
+		SPACE_CATEGORIES,
+		TASK_SCHEMAS,
+		categorizeSpace,
+		type NodeTemplate
+	} from "./node-library";
+	import { PORT_COLOR } from "./workflow-types";
+	import type { PortType } from "./workflow-types";
+	import { fetchSpaceApi, normalize_space_id } from "./space-api";
+	import ChevronLeftIcon from "./icons/ChevronLeftIcon.svelte";
+	import ChevronDownIcon from "./icons/ChevronDownIcon.svelte";
+
+	interface TrendingSpace {
+		id: string;
+		title: string;
+		description: string;
+		likes: number;
+		running: boolean;
+		category: string | null;
+	}
+
+	let {
+		onadd = undefined,
+		server = {},
+		hfToken = "",
+		trendingSpaces: propTrendingSpaces = undefined,
+		trendingLoading: propTrendingLoading = undefined
+	}: {
+		onadd?: (template: NodeTemplate) => void;
+		server?: Record<string, any>;
+		hfToken?: string;
+		trendingSpaces?: TrendingSpace[];
+		trendingLoading?: boolean;
+	} = $props();
+
+	let expandedSection: string | null = $state("spaces");
+	let collapsed = $state(false);
+	let sidebarWidth = $state(240);
+	let isResizing = $state(false);
+
+	// Load custom spaces from localStorage
+	let customSpaces: NodeTemplate[] = $state(
+		typeof localStorage !== "undefined"
+			? JSON.parse(localStorage.getItem("gradio_custom_spaces") ?? "[]")
+			: []
+	);
+
+	// Auto-save custom spaces to localStorage
+	$effect(() => {
+		if (typeof localStorage !== "undefined") {
+			localStorage.setItem(
+				"gradio_custom_spaces",
+				JSON.stringify(customSpaces)
+			);
+		}
+	});
+
+	function startResize(e: MouseEvent) {
+		e.preventDefault();
+		isResizing = true;
+		const startX = e.clientX;
+		const startWidth = sidebarWidth;
+
+		function onMove(ev: MouseEvent) {
+			sidebarWidth = Math.max(
+				160,
+				Math.min(400, startWidth + (ev.clientX - startX))
+			);
+		}
+		function onUp() {
+			isResizing = false;
+			window.removeEventListener("mousemove", onMove);
+			window.removeEventListener("mouseup", onUp);
+		}
+		window.addEventListener("mousemove", onMove);
+		window.addEventListener("mouseup", onUp);
+	}
+	let customSpaceInput = $state("");
+	let loadingSpace = $state(false);
+	let loadingSpaceName = $state("");
+	let spaceError = $state("");
+
+	function handleWindowClick(e: MouseEvent): void {
+		const target = e.target as HTMLElement;
+		if (searchResults.length > 0 && !target.closest(".add-space-wrapper")) {
+			searchResults = [];
+		}
+	}
+
+	// Trending spaces — use parent-provided data if available, otherwise fetch own
+	let ownTrendingSpaces: TrendingSpace[] = $state([]);
+	let ownTrendingLoading = $state(true);
+	let trendingSpaces = $derived(propTrendingSpaces ?? ownTrendingSpaces);
+	let trendingLoading = $derived(propTrendingLoading ?? ownTrendingLoading);
+
+	async function fetchTrendingSpaces() {
+		if (propTrendingSpaces !== undefined) return;
+		if (!server?.search_spaces) {
+			ownTrendingLoading = false;
+			return;
+		}
+		try {
+			const raw = await server.search_spaces(["trending", "", ""]);
+			const data = typeof raw === "string" ? JSON.parse(raw) : raw;
+			if (!Array.isArray(data)) {
+				ownTrendingSpaces = [];
+				return;
+			}
+			ownTrendingSpaces = data
+				.map((s: any) => {
+					const desc = s.cardData?.short_description || "";
+					return {
+						id: s.id,
+						title: s.cardData?.title || s.id.split("/").pop() || s.id,
+						description: desc,
+						likes: s.likes ?? 0,
+						running: s.runtime?.stage === "RUNNING",
+						category: categorizeSpace(
+							s.cardData?.pipeline_tag || s.pipeline_tag,
+							s.cardData?.tags,
+							desc,
+							s.id
+						)
+					};
+				})
+				.filter((s: TrendingSpace) => s.category !== null && s.running);
+		} catch {
+			ownTrendingSpaces = [];
+		} finally {
+			ownTrendingLoading = false;
+		}
+	}
+
+	if (typeof window !== "undefined") {
+		fetchTrendingSpaces();
+	}
+
+	function trendingToTemplate(space: TrendingSpace): NodeTemplate {
+		return {
+			label: space.id.split("/").pop() || space.id,
+			kind: "transform",
+			source: "space",
+			space_id: space.id,
+			category: space.category ?? undefined,
+			inputs: [],
+			outputs: [],
+			width: 280,
+			height: 90
+		};
+	}
+
+	function getTrendingByCategory(cat: string): TrendingSpace[] {
+		return trendingSpaces.filter((s) => s.category === cat);
+	}
+
+	// Search state
+	let searchResults: {
+		id: string;
+		likes: number;
+		title?: string;
+		description?: string;
+		running: boolean;
+	}[] = $state([]);
+	let searching = $state(false);
+	let searchTimeout: ReturnType<typeof setTimeout> | null = null;
+
+	function handleSearchInput(e: Event) {
+		const query = (e.currentTarget as HTMLInputElement).value;
+		customSpaceInput = query;
+		spaceError = "";
+
+		if (searchTimeout) clearTimeout(searchTimeout);
+
+		if (query.length < 2) {
+			searchResults = [];
+			searching = false;
+			return;
+		}
+
+		if (normalize_space_id(query)) {
+			searchResults = [];
+			return;
+		}
+
+		searching = true;
+		searchTimeout = setTimeout(async () => {
+			try {
+				if (!server?.search_spaces) {
+					searchResults = [];
+					return;
+				}
+				const raw = await server.search_spaces(["search", query, ""]);
+				const data = typeof raw === "string" ? JSON.parse(raw) : raw;
+				if (!Array.isArray(data)) {
+					searchResults = [];
+					return;
+				}
+				searchResults = data
+					.filter((s: any) => s.sdk === "gradio")
+					.slice(0, 6)
+					.map((s: any) => ({
+						id: s.id,
+						likes: s.likes ?? 0,
+						title: s.title || s.id.split("/").pop(),
+						description: s.ai_short_description || "",
+						running: s.runtime?.stage === "RUNNING"
+					}));
+			} catch {
+				searchResults = [];
+			} finally {
+				searching = false;
+			}
+		}, 300);
+	}
+
+	function selectSearchResult(spaceId: string) {
+		customSpaceInput = spaceId;
+		searchResults = [];
+		addCustomSpace();
+	}
+
+	function primaryType(item: (typeof LIBRARY)["inputs"][number]): PortType {
+		return item.outputs[0]?.type ?? item.inputs[0]?.type ?? "any";
+	}
+
+	function toggle(section: string) {
+		expandedSection = expandedSection === section ? null : section;
+	}
+
+	async function addCustomSpace() {
+		const spaceId = normalize_space_id(customSpaceInput);
+		if (!spaceId) {
+			spaceError = "Enter owner/repo or paste a Space URL";
+			return;
+		}
+		if (customSpaces.some((s) => s.space_id === spaceId)) {
+			customSpaceInput = "";
+			return;
+		}
+
+		loadingSpace = true;
+		loadingSpaceName = spaceId;
+		spaceError = "";
+		customSpaceInput = "";
+
+		try {
+			const apiInfo = await fetchSpaceApi(spaceId);
+			const label = spaceId.split("/").pop() ?? spaceId;
+
+			customSpaces = [
+				...customSpaces,
+				{
+					label,
+					kind: "transform",
+					source: "space",
+					space_id: spaceId,
+					endpoint: apiInfo.endpoint,
+					inputs: apiInfo.inputs,
+					outputs: apiInfo.outputs,
+					width: apiInfo.width,
+					height: 90
+				}
+			];
+			customSpaceInput = "";
+		} catch (err) {
+			spaceError = err instanceof Error ? err.message : "Failed to connect";
+		} finally {
+			loadingSpace = false;
+		}
+	}
+
+	// ── Model search ──
+	interface HFModel {
+		id: string;
+		pipeline_tag: string;
+		likes: number;
+		downloads: number;
+	}
+
+	const MODEL_TASKS = [
+		{ key: "text-to-image", label: "Text → Image" },
+		{ key: "text-generation", label: "Text Generation" },
+		{ key: "image-to-text", label: "Image → Text" },
+		{ key: "image-classification", label: "Image Classification" },
+		{ key: "object-detection", label: "Object Detection" },
+		{ key: "automatic-speech-recognition", label: "Speech → Text" },
+		{ key: "text-to-speech", label: "Text → Speech" },
+		{ key: "translation", label: "Translation" },
+		{ key: "summarization", label: "Summarization" },
+		{ key: "text-classification", label: "Text Classification" },
+		{ key: "image-to-image", label: "Image → Image" },
+		{ key: "depth-estimation", label: "Depth Estimation" },
+		{ key: "image-segmentation", label: "Image Segmentation" },
+		{ key: "text-to-video", label: "Text → Video" },
+		{ key: "image-text-to-text", label: "Image+Text → Text" },
+		{ key: "feature-extraction", label: "Embeddings" }
+	];
+
+	let modelSearchQuery = $state("");
+	let modelSearchResults: HFModel[] = $state([]);
+	let modelSearching = $state(false);
+	let modelSearchTimeout: ReturnType<typeof setTimeout> | null = null;
+	let selectedModelTask = $state("");
+	let trendingModels: HFModel[] = $state([]);
+	let trendingModelsLoading = $state(true);
+
+	async function fetchTrendingModels() {
+		if (!server?.search_models) {
+			trendingModelsLoading = false;
+			return;
+		}
+		try {
+			const raw = await server.search_models(["trending", "", "", ""]);
+			const data = typeof raw === "string" ? JSON.parse(raw) : raw;
+			if (!Array.isArray(data)) {
+				trendingModels = [];
+				return;
+			}
+			trendingModels = data
+				.filter((m: any) => m.pipeline_tag && TASK_SCHEMAS[m.pipeline_tag])
+				.map((m: any) => ({
+					id: m.id,
+					pipeline_tag: m.pipeline_tag,
+					likes: m.likes ?? 0,
+					downloads: m.downloads ?? 0
+				}));
+		} catch {
+			trendingModels = [];
+		} finally {
+			trendingModelsLoading = false;
+		}
+	}
+
+	if (typeof window !== "undefined") {
+		fetchTrendingModels();
+	}
+
+	function handleModelSearch(e: Event) {
+		const query = (e.currentTarget as HTMLInputElement).value;
+		modelSearchQuery = query;
+
+		if (modelSearchTimeout) clearTimeout(modelSearchTimeout);
+
+		if (query.length < 2 && !selectedModelTask) {
+			modelSearchResults = [];
+			modelSearching = false;
+			return;
+		}
+
+		modelSearching = true;
+		modelSearchTimeout = setTimeout(async () => {
+			try {
+				if (!server?.search_models) {
+					modelSearchResults = [];
+					return;
+				}
+				const raw = await server.search_models([
+					"search",
+					query.length >= 2 ? query : "",
+					selectedModelTask,
+					""
+				]);
+				const data = typeof raw === "string" ? JSON.parse(raw) : raw;
+				if (!Array.isArray(data)) {
+					modelSearchResults = [];
+					return;
+				}
+				modelSearchResults = data
+					.filter((m: any) => m.pipeline_tag && TASK_SCHEMAS[m.pipeline_tag])
+					.map((m: any) => ({
+						id: m.id,
+						pipeline_tag: m.pipeline_tag,
+						likes: m.likes ?? 0,
+						downloads: m.downloads ?? 0
+					}));
+			} catch {
+				modelSearchResults = [];
+			} finally {
+				modelSearching = false;
+			}
+		}, 300);
+	}
+
+	function handleTaskFilter(taskKey: string) {
+		selectedModelTask = selectedModelTask === taskKey ? "" : taskKey;
+		// Re-trigger search with new filter
+		handleModelSearch({ currentTarget: { value: modelSearchQuery } } as any);
+	}
+
+	function modelToTemplate(model: HFModel): NodeTemplate {
+		const schema = TASK_SCHEMAS[model.pipeline_tag];
+		return {
+			label: model.id.split("/").pop() || model.id,
+			kind: "transform",
+			source: "model",
+			model_id: model.id,
+			pipeline_tag: model.pipeline_tag,
+			inputs: schema?.inputs ?? [],
+			outputs: schema?.outputs ?? [],
+			width: 280,
+			height: 90
+		};
+	}
+
+	function getModelsForTask(task: string): HFModel[] {
+		return trendingModels.filter((m) => m.pipeline_tag === task);
+	}
+
+	// ── Dataset search ──
+	interface HFDataset {
+		id: string;
+		likes: number;
+		downloads: number;
+		description: string;
+	}
+
+	let datasetSearchQuery = $state("");
+	let datasetSearchResults: HFDataset[] = $state([]);
+	let datasetSearching = $state(false);
+	let datasetSearchTimeout: ReturnType<typeof setTimeout> | null = null;
+	let loadingDataset = $state(false);
+	let loadingDatasetName = $state("");
+	let datasetError = $state("");
+	let datasetsAdded = $state(0);
+
+	function handleDatasetSearch(e: Event) {
+		const query = (e.currentTarget as HTMLInputElement).value;
+		datasetSearchQuery = query;
+		datasetError = "";
+
+		if (datasetSearchTimeout) clearTimeout(datasetSearchTimeout);
+
+		if (query.length < 2) {
+			datasetSearchResults = [];
+			datasetSearching = false;
+			return;
+		}
+
+		datasetSearching = true;
+		datasetSearchTimeout = setTimeout(async () => {
+			try {
+				if (!server?.search_datasets) {
+					datasetSearchResults = [];
+					return;
+				}
+				const raw = await server.search_datasets([query, ""]);
+				const data = typeof raw === "string" ? JSON.parse(raw) : raw;
+				if (!Array.isArray(data)) {
+					datasetSearchResults = [];
+					return;
+				}
+				datasetSearchResults = data.map((d: any) => ({
+					id: d.id,
+					likes: d.likes ?? 0,
+					downloads: d.downloads ?? 0,
+					description: d.cardData?.description?.slice(0, 80) || ""
+				}));
+			} catch {
+				datasetSearchResults = [];
+			} finally {
+				datasetSearching = false;
+			}
+		}, 300);
+	}
+
+	async function addDataset(datasetId: string) {
+		loadingDataset = true;
+		loadingDatasetName = datasetId;
+		datasetError = "";
+
+		try {
+			if (!server?.get_dataset_schema)
+				throw new Error("Dataset schema function not available");
+			const raw = await server.get_dataset_schema([datasetId, hfToken || ""]);
+			const data = typeof raw === "string" ? JSON.parse(raw) : raw;
+			if (data?.error) throw new Error(data.error);
+
+			const features: { name: string; type: any }[] = data.features ?? [];
+			const featureToPortType = (f: any): PortType => {
+				const dtype = f.type?.dtype || f.type?._type || "";
+				if (
+					dtype === "string" ||
+					(f.type?._type === "Value" && f.type?.dtype === "string")
+				)
+					return "text";
+				if (
+					dtype === "float32" ||
+					dtype === "float64" ||
+					dtype === "int32" ||
+					dtype === "int64"
+				)
+					return "number";
+				if (f.type?._type === "Image") return "image";
+				if (f.type?._type === "Audio") return "audio";
+				return "json";
+			};
+
+			const outputs = features.slice(0, 6).map((f, i) => ({
+				id: `out_${i}`,
+				label: f.name,
+				type: featureToPortType(f)
+			}));
+
+			const template: NodeTemplate = {
+				label: datasetId.split("/").pop() || datasetId,
+				kind: "input" as const,
+				source: "dataset",
+				dataset_id: datasetId,
+				dataset_config: data.config,
+				dataset_split: data.split,
+				inputs: [],
+				outputs,
+				width: 280,
+				height: Math.max(90, 50 + outputs.length * 22)
+			};
+
+			onadd?.(template);
+			datasetsAdded += 1;
+		} catch (err) {
+			datasetError =
+				err instanceof Error ? err.message : "Failed to load dataset";
+		} finally {
+			loadingDataset = false;
+		}
+	}
+
+	const sections = [
+		{ key: "spaces", label: "Spaces", icon: "hub", items: LIBRARY.spaces },
+		{
+			key: "models",
+			label: "Models",
+			icon: "model",
+			items: [] as NodeTemplate[]
+		},
+		{
+			key: "datasets",
+			label: "Datasets",
+			icon: "data",
+			items: [] as NodeTemplate[]
+		},
+		{
+			key: "components",
+			label: "Components",
+			icon: "layers",
+			items: LIBRARY.components
+		}
+	];
+</script>
+
+<!-- svelte-ignore a11y_no_noninteractive_element_interactions -->
+<svelte:window onclick={handleWindowClick} />
+
+<aside
+	class="sidebar"
+	class:sidebar-collapsed={collapsed}
+	style="width: {collapsed ? 40 : sidebarWidth}px; min-width: {collapsed
+		? 40
+		: sidebarWidth}px;"
+>
+	<div class="sidebar-header">
+		<button
+			class="sidebar-collapse-btn"
+			class:collapsed
+			onclick={() => (collapsed = !collapsed)}
+		>
+			<ChevronLeftIcon />
+		</button>
+	</div>
+
+	{#if !collapsed}
+		{#each sections as section}
+			<button
+				class="section-toggle"
+				class:expanded={expandedSection === section.key}
+				onclick={() => toggle(section.key)}
+			>
+				<span class="section-label">{section.label}</span>
+				<span class="section-count"
+					>{section.key === "spaces"
+						? customSpaces.length + trendingSpaces.length
+						: section.key === "models"
+							? trendingModels.length
+							: section.key === "datasets"
+								? datasetsAdded
+								: section.items.length}</span
+				>
+				<span
+					class="section-chevron"
+					class:expanded={expandedSection === section.key}
+				>
+					<ChevronDownIcon />
+				</span>
+			</button>
+
+			{#if expandedSection === section.key}
+				<div class="section-items">
+					{#if section.key === "spaces"}
+						{#if trendingLoading}
+							<div class="trending-status">
+								<span class="space-loading-spinner"></span>
+								<span class="trending-status-text"
+									>Loading trending spaces...</span
+								>
+							</div>
+						{/if}
+
+						{#each SPACE_CATEGORIES as cat}
+							{@const trending = getTrendingByCategory(cat.key)}
+							{#if trending.length > 0}
+								<div class="category-header">
+									<span class="category-label">{cat.label}</span>
+									<span class="category-count">{trending.length}</span>
+								</div>
+
+								{#each trending as space}
+									<div
+										draggable="true"
+										class="space-card"
+										onclick={() => onadd?.(trendingToTemplate(space))}
+										ondragstart={(e) => {
+											const template = trendingToTemplate(space);
+											e.dataTransfer!.setData(
+												"node-template",
+												JSON.stringify(template)
+											);
+											const ghost = document.createElement("div");
+											ghost.textContent = space.title;
+											ghost.style.cssText =
+												"background:#f97316;color:#0c0d10;padding:4px 10px;border-radius:5px;font-family:Manrope,sans-serif;font-size:11px;font-weight:600;position:fixed;top:-100px";
+											document.body.appendChild(ghost);
+											e.dataTransfer!.setDragImage(ghost, 0, 0);
+											setTimeout(() => document.body.removeChild(ghost), 0);
+										}}
+									>
+										<div class="space-card-header">
+											<span
+												class="space-card-status"
+												class:space-card-running={space.running}
+												title={space.running ? "Running" : "Sleeping"}
+											></span>
+											<span class="space-card-name">{space.title}</span>
+											<span class="space-card-likes"
+												>&hearts; {space.likes}</span
+											>
+											<a
+												class="space-card-link"
+												href="https://huggingface.co/spaces/{space.id}"
+												target="_blank"
+												rel="noopener"
+												onclick={(e) => e.stopPropagation()}
+												title="Open on HuggingFace">&#x2197;</a
+											>
+										</div>
+										<div class="space-card-id">{space.id}</div>
+										{#if space.description}
+											<div class="space-card-desc">{space.description}</div>
+										{/if}
+									</div>
+								{/each}
+							{/if}
+						{/each}
+					{:else if section.key === "models"}
+						<div class="add-space-wrapper">
+							<div class="add-space">
+								<input
+									class="space-input"
+									type="text"
+									placeholder="Search models..."
+									value={modelSearchQuery}
+									oninput={handleModelSearch}
+								/>
+							</div>
+						</div>
+						<div class="model-task-filters">
+							{#each MODEL_TASKS as task}
+								<button
+									class="model-task-tag"
+									class:model-task-tag-active={selectedModelTask === task.key}
+									onclick={() => handleTaskFilter(task.key)}
+									>{task.label}</button
+								>
+							{/each}
+						</div>
+
+						{#if modelSearching}
+							<div class="space-loading">
+								<span class="space-loading-spinner"></span>
+								<span class="space-loading-text">Searching...</span>
+							</div>
+						{:else if modelSearchQuery.length >= 2 || selectedModelTask}
+							{#each modelSearchResults as model}
+								{@const template = modelToTemplate(model)}
+								{@const pt =
+									template.outputs[0]?.type ??
+									template.inputs[0]?.type ??
+									"any"}
+								<div
+									draggable="true"
+									class="space-card"
+									onclick={() => onadd?.(template)}
+									ondragstart={(e) => {
+										e.dataTransfer!.setData(
+											"node-template",
+											JSON.stringify(template)
+										);
+										const ghost = document.createElement("div");
+										ghost.textContent = model.id;
+										ghost.style.cssText = `background:${PORT_COLOR[pt]};color:#0c0d10;padding:4px 10px;border-radius:5px;font-family:Manrope,sans-serif;font-size:11px;font-weight:600;position:fixed;top:-100px`;
+										document.body.appendChild(ghost);
+										e.dataTransfer!.setDragImage(ghost, 0, 0);
+										setTimeout(() => document.body.removeChild(ghost), 0);
+									}}
+								>
+									<div class="space-card-header">
+										<span
+											class="chip-dot"
+											style="background: {PORT_COLOR[
+												pt
+											]}; box-shadow: 0 0 6px {PORT_COLOR[pt]}40"
+										></span>
+										<span class="space-card-name"
+											>{model.id.split("/").pop()}</span
+										>
+										<span class="space-card-likes">&hearts; {model.likes}</span>
+									</div>
+									<div class="space-card-id">{model.id}</div>
+									<div class="space-card-desc">{model.pipeline_tag}</div>
+								</div>
+							{/each}
+							{#if modelSearchResults.length === 0}
+								<div class="trending-status">
+									<span class="trending-status-text">No models found</span>
+								</div>
+							{/if}
+						{:else if trendingModelsLoading}
+							<div class="trending-status">
+								<span class="space-loading-spinner"></span>
+								<span class="trending-status-text"
+									>Loading trending models...</span
+								>
+							</div>
+						{:else}
+							{#each MODEL_TASKS.slice(0, 6) as task}
+								{@const models = getModelsForTask(task.key)}
+								{#if models.length > 0}
+									<div class="category-header">
+										<span class="category-label">{task.label}</span>
+										<span class="category-count">{models.length}</span>
+									</div>
+									{#each models.slice(0, 3) as model}
+										{@const template = modelToTemplate(model)}
+										{@const pt =
+											template.outputs[0]?.type ??
+											template.inputs[0]?.type ??
+											"any"}
+										<div
+											draggable="true"
+											class="space-card"
+											onclick={() => onadd?.(template)}
+											ondragstart={(e) => {
+												e.dataTransfer!.setData(
+													"node-template",
+													JSON.stringify(template)
+												);
+											}}
+										>
+											<div class="space-card-header">
+												<span
+													class="chip-dot"
+													style="background: {PORT_COLOR[
+														pt
+													]}; box-shadow: 0 0 6px {PORT_COLOR[pt]}40"
+												></span>
+												<span class="space-card-name"
+													>{model.id.split("/").pop()}</span
+												>
+												<span class="space-card-likes"
+													>&hearts; {model.likes}</span
+												>
+											</div>
+											<div class="space-card-id">{model.id}</div>
+										</div>
+									{/each}
+								{/if}
+							{/each}
+						{/if}
+					{:else if section.key === "datasets"}
+						<div class="add-space-wrapper">
+							<div class="add-space">
+								<input
+									class="space-input"
+									type="text"
+									placeholder="Search datasets..."
+									value={datasetSearchQuery}
+									disabled={loadingDataset}
+									oninput={handleDatasetSearch}
+									onkeydown={(e) => {
+										if (e.key === "Enter" && datasetSearchQuery.includes("/")) {
+											datasetSearchResults = [];
+											addDataset(datasetSearchQuery.trim());
+										}
+										if (e.key === "Escape") datasetSearchResults = [];
+									}}
+								/>
+							</div>
+							{#if datasetSearchResults.length > 0}
+								<div class="search-dropdown">
+									{#each datasetSearchResults as result}
+										<button
+											class="search-result"
+											onclick={() => {
+												const id = result.id;
+												datasetSearchResults = [];
+												datasetSearchQuery = "";
+												addDataset(id);
+											}}
+										>
+											<div class="search-result-top">
+												<span class="search-result-name">{result.id}</span>
+												<span class="search-result-likes"
+													>&hearts; {result.likes}</span
+												>
+											</div>
+											{#if result.description}
+												<div class="search-result-desc">
+													{result.description}
+												</div>
+											{/if}
+										</button>
+									{/each}
+								</div>
+							{:else if datasetSearching}
+								<div class="search-dropdown">
+									<div class="search-searching">Searching...</div>
+								</div>
+							{/if}
+						</div>
+						{#if loadingDataset}
+							<div class="space-loading">
+								<span class="space-loading-spinner"></span>
+								<span class="space-loading-text"
+									>Loading {loadingDatasetName}...</span
+								>
+							</div>
+						{/if}
+						{#if datasetError}
+							<span class="space-error">{datasetError}</span>
+						{/if}
+						<div class="trending-status">
+							<span class="trending-status-text"
+								>Search for a dataset by name</span
+							>
+						</div>
+					{:else}
+						{#each section.items as item}
+							{@const pt = primaryType(item)}
+							<div
+								draggable="true"
+								class="chip"
+								onclick={() => onadd?.(item)}
+								ondragstart={(e) => {
+									e.dataTransfer!.setData(
+										"node-template",
+										JSON.stringify(item)
+									);
+									const ghost = document.createElement("div");
+									ghost.textContent = item.label;
+									ghost.style.cssText = `background:${PORT_COLOR[pt]};color:#0c0d10;padding:4px 10px;border-radius:5px;font-family:Manrope,sans-serif;font-size:11px;font-weight:600;position:fixed;top:-100px`;
+									document.body.appendChild(ghost);
+									e.dataTransfer!.setDragImage(ghost, 0, 0);
+									setTimeout(() => document.body.removeChild(ghost), 0);
+								}}
+							>
+								<span
+									class="chip-dot"
+									style="background: {PORT_COLOR[
+										pt
+									]}; box-shadow: 0 0 6px {PORT_COLOR[pt]}40"
+								></span>
+								<span class="chip-label">{item.label}</span>
+							</div>
+						{/each}
+					{/if}
+
+					{#if section.key === "spaces"}
+						{#each customSpaces as item, i}
+							{@const pt = primaryType(item)}
+							<div
+								draggable="true"
+								class="chip"
+								onclick={() => onadd?.(item)}
+								ondragstart={(e) =>
+									e.dataTransfer!.setData(
+										"node-template",
+										JSON.stringify(item)
+									)}
+							>
+								<span
+									class="chip-dot"
+									style="background: {PORT_COLOR[
+										pt
+									]}; box-shadow: 0 0 6px {PORT_COLOR[pt]}40"
+								></span>
+								<span class="chip-label">{item.label}</span>
+								{#if item.space_id}
+									<a
+										class="chip-link"
+										href="https://huggingface.co/spaces/{item.space_id}"
+										target="_blank"
+										rel="noopener"
+										onclick={(e) => e.stopPropagation()}
+										title="Open on HuggingFace">&#x2197;</a
+									>
+								{/if}
+								<button
+									class="chip-remove"
+									onclick={(e) => {
+										e.stopPropagation();
+										customSpaces = customSpaces.filter((_, j) => j !== i);
+									}}
+									title="Remove">&times;</button
+								>
+							</div>
+						{/each}
+						<div class="add-space-wrapper">
+							<div class="add-space">
+								<input
+									class="space-input"
+									type="text"
+									placeholder="Search Spaces..."
+									value={customSpaceInput}
+									disabled={loadingSpace}
+									oninput={handleSearchInput}
+									onkeydown={(e) => {
+										if (e.key === "Enter" && customSpaceInput.includes("/")) {
+											searchResults = [];
+											addCustomSpace();
+										}
+										if (e.key === "Escape") searchResults = [];
+									}}
+								/>
+								<button
+									class="space-add-btn"
+									onclick={() => {
+										searchResults = [];
+										addCustomSpace();
+									}}
+									disabled={loadingSpace ||
+										!customSpaceInput.trim().includes("/")}
+									>{loadingSpace ? "..." : "+"}</button
+								>
+							</div>
+							{#if searchResults.length > 0}
+								<div class="search-dropdown">
+									{#each searchResults as result}
+										<button
+											class="search-result"
+											onclick={() => selectSearchResult(result.id)}
+										>
+											<div class="search-result-top">
+												<span
+													class="search-result-status"
+													class:search-result-running={result.running}
+													title={result.running ? "Running" : "Not running"}
+												></span>
+												<span class="search-result-name">{result.id}</span>
+												<span class="search-result-likes"
+													>&hearts; {result.likes}</span
+												>
+												<a
+													class="search-result-link"
+													href="https://huggingface.co/spaces/{result.id}"
+													target="_blank"
+													rel="noopener"
+													onclick={(e) => e.stopPropagation()}
+													title="Open on HuggingFace">&#x2197;</a
+												>
+											</div>
+											{#if result.description}
+												<div class="search-result-desc">
+													{result.description}
+												</div>
+											{/if}
+										</button>
+									{/each}
+								</div>
+							{:else if searching}
+								<div class="search-dropdown">
+									<div class="search-searching">Searching...</div>
+								</div>
+							{/if}
+						</div>
+						{#if loadingSpace}
+							<div class="space-loading">
+								<span class="space-loading-spinner"></span>
+								<span class="space-loading-text"
+									>Connecting to {loadingSpaceName}...</span
+								>
+							</div>
+						{/if}
+						{#if spaceError}
+							<span class="space-error">{spaceError}</span>
+						{/if}
+					{/if}
+				</div>
+			{/if}
+		{/each}
+
+		<div class="sidebar-footer">
+			<span class="hint">Drag to canvas</span>
+		</div>
+	{/if}
+	<!-- svelte-ignore a11y_no_static_element_interactions -->
+	{#if !collapsed}
+		<div class="resize-handle" onmousedown={startResize}></div>
+	{/if}
+</aside>
+
+<style>
+	.sidebar {
+		position: relative;
+		display: flex;
+		flex-direction: column;
+		background: #101118;
+		border-right: 1px solid #1e1f2a;
+		overflow-y: auto;
+		font-family: "Manrope", sans-serif;
+		color-scheme: dark;
+	}
+
+	.sidebar-collapsed {
+		width: 40px;
+		min-width: 40px;
+	}
+
+	.sidebar-collapse-btn {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		width: 24px;
+		height: 24px;
+		border: none;
+		border-radius: 4px;
+		background: transparent;
+		color: #5c5e6a;
+		cursor: pointer;
+		flex-shrink: 0;
+		padding: 0;
+		line-height: 1;
+		transition:
+			color 0.15s,
+			background 0.15s,
+			transform 0.2s ease;
+	}
+
+	.sidebar-collapse-btn:hover {
+		background: #1e1f2a;
+		color: #a0a2ae;
+	}
+
+	.sidebar-collapse-btn.collapsed {
+		transform: rotate(180deg);
+	}
+
+	.sidebar-header {
+		display: flex;
+		align-items: center;
+		gap: 6px;
+		padding: 12px 12px 10px;
+		border-bottom: 1px solid #1e1f2a;
+	}
+
+	.sidebar-collapsed .sidebar-header {
+		justify-content: center;
+		padding: 14px 8px 10px;
+	}
+
+	.section-toggle {
+		display: flex;
+		align-items: center;
+		width: 100%;
+		padding: 10px 16px;
+		border: none;
+		background: transparent;
+		cursor: pointer;
+		transition: background 0.15s;
+	}
+
+	.section-toggle:hover {
+		background: #16171f;
+	}
+
+	.section-label {
+		font-size: 12px;
+		font-weight: 600;
+		color: #a0a2ae;
+		flex: 1;
+		text-align: left;
+	}
+
+	.section-count {
+		font-family: "JetBrains Mono", monospace;
+		font-size: 10px;
+		color: #3e3f4d;
+		margin-right: 6px;
+	}
+
+	.section-chevron {
+		display: inline-flex;
+		color: #5c5e6a;
+		flex-shrink: 0;
+		transition: transform 0.2s ease;
+		transform: rotate(-90deg);
+	}
+
+	.section-chevron.expanded {
+		transform: rotate(0deg);
+	}
+
+	.section-items {
+		padding: 2px 8px 8px;
+	}
+
+	.chip {
+		display: flex;
+		align-items: center;
+		gap: 8px;
+		padding: 7px 10px;
+		margin-bottom: 2px;
+		border-radius: 6px;
+		cursor: pointer;
+		transition:
+			background 0.15s,
+			transform 0.1s;
+		background: transparent;
+	}
+
+	.chip:hover {
+		background: #1a1b25;
+	}
+
+	.chip:active {
+		cursor: grabbing;
+		transform: scale(0.98);
+	}
+
+	.chip-dot {
+		width: 7px;
+		height: 7px;
+		border-radius: 50%;
+		flex-shrink: 0;
+	}
+
+	.category-header {
+		display: flex;
+		align-items: center;
+		gap: 6px;
+		padding: 8px 10px 4px;
+		margin-top: 4px;
+	}
+
+	.category-header:first-child {
+		margin-top: 0;
+	}
+
+	.category-label {
+		font-size: 10px;
+		font-weight: 700;
+		text-transform: uppercase;
+		letter-spacing: 0.06em;
+		color: #5c5e6a;
+	}
+
+	.category-count {
+		font-family: "JetBrains Mono", monospace;
+		font-size: 9px;
+		color: #3e3f4d;
+	}
+
+	/* Trending space cards */
+	.space-card {
+		display: flex;
+		flex-direction: column;
+		padding: 8px 10px;
+		margin-bottom: 2px;
+		border-radius: 6px;
+		cursor: pointer;
+		transition:
+			background 0.15s,
+			transform 0.1s;
+		background: transparent;
+	}
+
+	.space-card:hover {
+		background: #1a1b25;
+	}
+
+	.space-card:active {
+		cursor: grabbing;
+		transform: scale(0.98);
+	}
+
+	.space-card-header {
+		display: flex;
+		align-items: center;
+		gap: 6px;
+		width: 100%;
+	}
+
+	.space-card-status {
+		width: 6px;
+		height: 6px;
+		border-radius: 50%;
+		background: #5c5e6a;
+		flex-shrink: 0;
+	}
+
+	.space-card-running {
+		background: #34d399;
+		box-shadow: 0 0 4px #34d39960;
+	}
+
+	.space-card-name {
+		font-size: 12px;
+		font-weight: 600;
+		color: #c8c9d2;
+		flex: 1;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+	}
+
+	.space-card-likes {
+		font-family: "JetBrains Mono", monospace;
+		font-size: 9px;
+		color: #5c5e6a;
+		flex-shrink: 0;
+	}
+
+	.space-card-link {
+		visibility: hidden;
+		font-size: 11px;
+		color: #5c5e6a;
+		text-decoration: none;
+		flex-shrink: 0;
+		padding: 2px;
+		border-radius: 3px;
+		transition: color 0.15s;
+	}
+
+	.space-card:hover .space-card-link {
+		visibility: visible;
+	}
+
+	.space-card-link:hover {
+		color: #c8c9d2;
+	}
+
+	.space-card-id {
+		font-family: "JetBrains Mono", monospace;
+		font-size: 9px;
+		color: #3e3f4d;
+		padding-left: 12px;
+		margin-top: 1px;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+	}
+
+	.space-card-desc {
+		font-size: 10px;
+		color: #5c5e6a;
+		padding-left: 12px;
+		margin-top: 2px;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+		line-height: 1.3;
+	}
+
+	.trending-status {
+		display: flex;
+		align-items: center;
+		gap: 8px;
+		padding: 8px 12px;
+	}
+
+	.trending-status-text {
+		font-family: "JetBrains Mono", monospace;
+		font-size: 9.5px;
+		color: #5c5e6a;
+	}
+
+	.chip-label {
+		font-size: 12.5px;
+		font-weight: 500;
+		color: #c8c9d2;
+		flex: 1;
+		white-space: nowrap;
+		overflow: hidden;
+		text-overflow: ellipsis;
+	}
+
+	.chip-link {
+		visibility: hidden;
+		font-size: 11px;
+		color: #5c5e6a;
+		text-decoration: none;
+		flex-shrink: 0;
+		line-height: 1;
+		padding: 2px;
+		border-radius: 3px;
+		transition: color 0.15s;
+	}
+
+	.chip:hover .chip-link {
+		visibility: visible;
+	}
+
+	.chip-link:hover {
+		color: #c8c9d2;
+	}
+
+	.chip-remove {
+		visibility: hidden;
+		display: flex;
+		width: 16px;
+		height: 16px;
+		border: none;
+		border-radius: 3px;
+		background: transparent;
+		color: #5c5e6a;
+		font-size: 12px;
+		line-height: 1;
+		cursor: pointer;
+		align-items: center;
+		justify-content: center;
+		padding: 0;
+		flex-shrink: 0;
+	}
+
+	.chip:hover .chip-remove {
+		visibility: visible;
+	}
+
+	.chip-remove:hover {
+		color: #ef4444;
+		background: rgba(239, 68, 68, 0.15);
+	}
+
+	.chip-badge {
+		font-family: "JetBrains Mono", monospace;
+		font-size: 9px;
+		font-weight: 700;
+		letter-spacing: 0.04em;
+		padding: 1px 5px;
+		border-radius: 3px;
+		background: #1e1f2a;
+		color: #5c5e6a;
+	}
+
+	.add-space {
+		display: flex;
+		gap: 4px;
+		padding: 6px 4px 2px;
+	}
+
+	.space-input {
+		flex: 1;
+		font-family: "JetBrains Mono", monospace;
+		font-size: 10.5px;
+		height: 28px;
+		padding: 0 8px;
+		border: 1px solid #1e1f2a;
+		border-radius: 5px;
+		background: #0c0d10;
+		color: #c8c9d2;
+		outline: none;
+		min-width: 0;
+		box-sizing: border-box;
+	}
+
+	.space-input::placeholder {
+		color: #5c5e6a;
+	}
+
+	.space-input:focus {
+		border-color: #3e3f4d;
+	}
+
+	.space-add-btn {
+		width: 28px;
+		height: 28px;
+		border: 1px solid #3e3f4d;
+		border-radius: 5px;
+		background: #1a1b25;
+		color: #a0a2ae;
+		font-size: 14px;
+		font-weight: 600;
+		cursor: pointer;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		transition:
+			background 0.15s,
+			color 0.15s,
+			border-color 0.15s;
+		flex-shrink: 0;
+	}
+
+	.space-add-btn:hover:not(:disabled) {
+		background: #2a2b36;
+		color: #f97316;
+		border-color: #f97316;
+	}
+
+	.space-add-btn:disabled {
+		opacity: 0.35;
+		cursor: default;
+		background: #101118;
+		color: #3e3f4d;
+		border-color: #1e1f2a;
+	}
+
+	.add-space-wrapper {
+		position: relative;
+	}
+
+	.search-dropdown {
+		position: absolute;
+		top: 100%;
+		left: 4px;
+		right: 4px;
+		background: #16171f;
+		border: 1px solid #2a2b36;
+		border-radius: 6px;
+		margin-top: 2px;
+		overflow: hidden;
+		z-index: 10;
+		box-shadow: 0 8px 24px rgba(0, 0, 0, 0.4);
+	}
+
+	.search-result {
+		display: flex;
+		flex-direction: column;
+		width: 100%;
+		padding: 7px 10px;
+		border: none;
+		border-bottom: 1px solid #1e1f2a;
+		background: transparent;
+		color: #c8c9d2;
+		cursor: pointer;
+		text-align: left;
+		transition: background 0.1s;
+	}
+
+	.search-result:last-child {
+		border-bottom: none;
+	}
+
+	.search-result:hover {
+		background: #1a1b25;
+	}
+
+	.search-result-top {
+		display: flex;
+		align-items: center;
+		gap: 6px;
+		width: 100%;
+	}
+
+	.search-result-status {
+		width: 6px;
+		height: 6px;
+		border-radius: 50%;
+		background: #5c5e6a;
+		flex-shrink: 0;
+	}
+
+	.search-result-running {
+		background: #34d399;
+		box-shadow: 0 0 4px #34d39960;
+	}
+
+	.search-result-name {
+		font-family: "JetBrains Mono", monospace;
+		font-size: 10px;
+		flex: 1;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+	}
+
+	.search-result-desc {
+		font-size: 9.5px;
+		color: #5c5e6a;
+		margin-top: 2px;
+		padding-left: 12px;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+	}
+
+	.search-result-likes {
+		font-family: "JetBrains Mono", monospace;
+		font-size: 9px;
+		color: #5c5e6a;
+		flex-shrink: 0;
+	}
+
+	.search-result-link {
+		font-size: 11px;
+		color: #5c5e6a;
+		text-decoration: none;
+		flex-shrink: 0;
+		padding: 2px;
+		border-radius: 3px;
+		transition: color 0.15s;
+	}
+
+	.search-result-link:hover {
+		color: #c8c9d2;
+	}
+
+	.search-searching {
+		font-family: "JetBrains Mono", monospace;
+		font-size: 9.5px;
+		color: #5c5e6a;
+		padding: 8px 10px;
+		text-align: center;
+	}
+
+	.space-loading {
+		display: flex;
+		align-items: center;
+		gap: 8px;
+		padding: 6px 12px;
+	}
+
+	.space-loading-spinner {
+		width: 12px;
+		height: 12px;
+		border: 2px solid transparent;
+		border-top-color: #f5a623;
+		border-radius: 50%;
+		animation: sidebar-spin 0.7s linear infinite;
+		flex-shrink: 0;
+	}
+
+	@keyframes sidebar-spin {
+		to {
+			transform: rotate(360deg);
+		}
+	}
+
+	.space-loading-text {
+		font-family: "JetBrains Mono", monospace;
+		font-size: 9.5px;
+		color: #5c5e6a;
+		white-space: nowrap;
+		overflow: hidden;
+		text-overflow: ellipsis;
+	}
+
+	.space-error {
+		display: block;
+		font-family: "JetBrains Mono", monospace;
+		font-size: 9px;
+		color: #ef4444;
+		padding: 2px 12px 4px;
+	}
+
+	.sidebar-footer {
+		margin-top: auto;
+		padding: 12px 16px;
+		border-top: 1px solid #1e1f2a;
+	}
+
+	.resize-handle {
+		position: absolute;
+		top: 0;
+		right: -3px;
+		width: 6px;
+		height: 100%;
+		cursor: col-resize;
+		z-index: 10;
+	}
+
+	.resize-handle:hover {
+		background: rgba(249, 115, 22, 0.3);
+	}
+
+	.model-task-filters {
+		display: flex;
+		flex-wrap: wrap;
+		gap: 4px;
+		padding: 4px 4px 8px;
+	}
+
+	.model-task-tag {
+		font-family: "JetBrains Mono", monospace;
+		font-size: 9px;
+		padding: 3px 7px;
+		border: 1px solid #1e1f2a;
+		border-radius: 4px;
+		background: transparent;
+		color: #5c5e6a;
+		cursor: pointer;
+		transition: all 0.15s;
+	}
+
+	.model-task-tag:hover {
+		border-color: #3e3f4d;
+		color: #a0a2ae;
+	}
+
+	.model-task-tag-active {
+		border-color: #f97316;
+		color: #f97316;
+		background: rgba(249, 115, 22, 0.1);
+	}
+
+	.hint {
+		font-family: "JetBrains Mono", monospace;
+		font-size: 10px;
+		color: #2e2f3d;
+		letter-spacing: 0.02em;
+	}
+
+	/* ─── Light mode ─── */
+	:global(body:not(.dark)) .sidebar {
+		background: #f8f9fb;
+		border-right-color: #e2e4ea;
+		color-scheme: light;
+	}
+
+	:global(body:not(.dark)) .sidebar-header {
+		border-bottom-color: #e2e4ea;
+	}
+
+	:global(body:not(.dark)) .sidebar-collapse-btn {
+		color: #9a9caa;
+	}
+
+	:global(body:not(.dark)) .sidebar-collapse-btn:hover {
+		background: #e8eaf0;
+		color: #3e4050;
+	}
+
+	:global(body:not(.dark)) .section-toggle:hover {
+		background: #f0f1f5;
+	}
+
+	:global(body:not(.dark)) .section-label {
+		color: #6b6e78;
+	}
+
+	:global(body:not(.dark)) .section-count {
+		color: #b0b2bc;
+	}
+
+	:global(body:not(.dark)) .section-chevron {
+		color: #9a9caa;
+	}
+
+	:global(body:not(.dark)) .chip:hover {
+		background: #f0f1f5;
+	}
+
+	:global(body:not(.dark)) .chip-label {
+		color: #1a1b25;
+	}
+
+	:global(body:not(.dark)) .chip-link {
+		color: #9a9caa;
+	}
+
+	:global(body:not(.dark)) .chip-link:hover {
+		color: #1a1b25;
+	}
+
+	:global(body:not(.dark)) .category-label {
+		color: #9a9caa;
+	}
+
+	:global(body:not(.dark)) .category-count {
+		color: #b0b2bc;
+	}
+
+	:global(body:not(.dark)) .space-card:hover {
+		background: #f0f1f5;
+	}
+
+	:global(body:not(.dark)) .space-card-name {
+		color: #1a1b25;
+	}
+
+	:global(body:not(.dark)) .space-card-likes {
+		color: #9a9caa;
+	}
+
+	:global(body:not(.dark)) .space-card-link {
+		color: #9a9caa;
+	}
+
+	:global(body:not(.dark)) .space-card-link:hover {
+		color: #1a1b25;
+	}
+
+	:global(body:not(.dark)) .space-card-id {
+		color: #b0b2bc;
+	}
+
+	:global(body:not(.dark)) .space-card-desc {
+		color: #9a9caa;
+	}
+
+	:global(body:not(.dark)) .space-card-status {
+		background: #b0b2bc;
+	}
+
+	:global(body:not(.dark)) .trending-status-text {
+		color: #9a9caa;
+	}
+</style>

6.17.1/workflowcanvas/workflow/featured.ts

@@ -0,0 +1,99 @@
+/**
+ * Curated lists of featured spaces and models, surfaced as the default tab
+ * in the node picker. Edit these arrays to change what users see first when
+ * they open the picker for a given modality.
+ *
+ * `modality` must match a `MODALITIES[*].key` (image / audio / video / text / 3d)
+ * or `"data"` for datasets. `pipeline_tag` is required for models so we can
+ * resolve their input/output port schema from TASK_SCHEMAS.
+ */
+export interface FeaturedItem {
+	id: string;
+	title: string;
+	description: string;
+	modality: string;
+	pipeline_tag?: string;
+	likes?: number;
+}
+
+export const FEATURED_SPACES: FeaturedItem[] = [
+	{
+		id: "black-forest-labs/FLUX.1-schnell",
+		title: "FLUX.1 schnell",
+		description: "Fast, high-quality text-to-image",
+		modality: "image",
+		pipeline_tag: "text-to-image"
+	},
+	{
+		id: "stabilityai/stable-diffusion-3.5-large",
+		title: "Stable Diffusion 3.5 Large",
+		description: "High-fidelity text-to-image",
+		modality: "image",
+		pipeline_tag: "text-to-image"
+	},
+	{
+		id: "briaai/BRIA-RMBG-2.0",
+		title: "BRIA Background Removal",
+		description: "Remove image backgrounds",
+		modality: "image"
+	},
+	{
+		id: "hf-audio/whisper-large-v3-turbo",
+		title: "Whisper Large v3 Turbo",
+		description: "Fast speech-to-text",
+		modality: "audio",
+		pipeline_tag: "automatic-speech-recognition"
+	},
+	{
+		id: "coqui/xtts",
+		title: "Coqui XTTS",
+		description: "Multilingual text-to-speech with voice cloning",
+		modality: "audio",
+		pipeline_tag: "text-to-speech"
+	}
+];
+
+export const FEATURED_MODELS: FeaturedItem[] = [
+	{
+		id: "black-forest-labs/FLUX.1-schnell",
+		title: "FLUX.1 schnell",
+		description: "Text-to-image",
+		modality: "image",
+		pipeline_tag: "text-to-image"
+	},
+	{
+		id: "stabilityai/stable-diffusion-3.5-large-turbo",
+		title: "SD 3.5 Large Turbo",
+		description: "Fast text-to-image",
+		modality: "image",
+		pipeline_tag: "text-to-image"
+	},
+	{
+		id: "Qwen/Qwen2.5-VL-7B-Instruct",
+		title: "Qwen2.5-VL 7B",
+		description: "Image understanding & captioning",
+		modality: "image",
+		pipeline_tag: "image-to-text"
+	},
+	{
+		id: "openai/whisper-large-v3-turbo",
+		title: "Whisper Large v3 Turbo",
+		description: "Speech-to-text",
+		modality: "audio",
+		pipeline_tag: "automatic-speech-recognition"
+	},
+	{
+		id: "meta-llama/Llama-3.2-3B-Instruct",
+		title: "Llama 3.2 3B Instruct",
+		description: "Open-weights text generation",
+		modality: "text",
+		pipeline_tag: "text-generation"
+	},
+	{
+		id: "Qwen/Qwen2.5-7B-Instruct",
+		title: "Qwen 2.5 7B",
+		description: "Multilingual text generation",
+		modality: "text",
+		pipeline_tag: "text-generation"
+	}
+];

6.17.1/workflowcanvas/workflow/hf-auth.svelte.ts

@@ -0,0 +1,117 @@
+async function fetch_username(token: string): Promise<string | null> {
+	try {
+		const res = await fetch("https://huggingface.co/api/whoami-v2", {
+			headers: { Authorization: `Bearer ${token}` }
+		});
+		if (!res.ok) return null;
+		return (await res.json()).name || "User";
+	} catch {
+		return null;
+	}
+}
+
+function redirect_to(path: string): void {
+	const target = encodeURIComponent(
+		window.location.pathname + window.location.search
+	);
+	window.location.assign(`${path}?_target_url=${target}`);
+}
+
+export function createHFAuth(getServer: () => Record<string, any>) {
+	let loggedInUser = $state("");
+	let isHFSpace = $state(false);
+	let isCheckingLogin = $state(true);
+	let hfToken = $state(
+		typeof localStorage !== "undefined"
+			? (localStorage.getItem("hf_token") ?? "")
+			: ""
+	);
+	let tokenUser = $state("");
+	let tokenStatus = $state<"idle" | "validating" | "invalid">("idle");
+
+	async function validateToken(token: string): Promise<void> {
+		if (!token) {
+			tokenUser = "";
+			tokenStatus = "idle";
+			return;
+		}
+		tokenStatus = "validating";
+		const name = await fetch_username(token);
+		if (name) {
+			tokenUser = name;
+			tokenStatus = "idle";
+		} else {
+			tokenUser = "";
+			tokenStatus = "invalid";
+		}
+	}
+
+	function saveToken(token: string): void {
+		hfToken = token.trim();
+		if (typeof localStorage !== "undefined") {
+			if (hfToken) localStorage.setItem("hf_token", hfToken);
+			else localStorage.removeItem("hf_token");
+		}
+		void validateToken(hfToken);
+	}
+
+	// Validate any token loaded from localStorage on init so the user
+	// sees the "Signed in as …" badge without needing to re-paste.
+	if (hfToken) void validateToken(hfToken);
+
+	async function getOAuthToken(): Promise<string> {
+		const s = getServer();
+		if (!s?.get_token) return "";
+		try {
+			return (await s.get_token()) || "";
+		} catch {
+			return "";
+		}
+	}
+
+	async function checkLoginStatus(): Promise<void> {
+		isHFSpace = window.location.hostname.endsWith(".hf.space");
+		const token = await getOAuthToken();
+		if (!token) {
+			loggedInUser = "";
+			isCheckingLogin = false;
+			return;
+		}
+		loggedInUser = (await fetch_username(token)) ?? "";
+		isCheckingLogin = false;
+	}
+
+	function handleLogin(): void {
+		redirect_to("/login/huggingface");
+	}
+
+	function handleLogout(): void {
+		redirect_to("/logout");
+	}
+
+	return {
+		get loggedInUser() {
+			return loggedInUser;
+		},
+		get isHFSpace() {
+			return isHFSpace;
+		},
+		get isCheckingLogin() {
+			return isCheckingLogin;
+		},
+		get hfToken() {
+			return hfToken;
+		},
+		get tokenUser() {
+			return tokenUser;
+		},
+		get tokenStatus() {
+			return tokenStatus;
+		},
+		saveToken,
+		handleLogin,
+		handleLogout,
+		getOAuthToken,
+		checkLoginStatus
+	};
+}

6.17.1/workflowcanvas/workflow/icons/AudioIcon.svelte

@@ -0,0 +1,16 @@
+<svg
+	width="14"
+	height="14"
+	viewBox="0 0 14 14"
+	fill="none"
+	stroke="currentColor"
+	stroke-width="1.4"
+	stroke-linecap="round"
+	aria-hidden="true"
+>
+	<path d="M2.5 6v2" />
+	<path d="M5 4v6" />
+	<path d="M7.5 2.5v9" />
+	<path d="M10 4.5v5" />
+	<path d="M12.5 6v2" />
+</svg>

6.17.1/workflowcanvas/workflow/icons/CheckIcon.svelte

@@ -0,0 +1,9 @@
+<svg width="11" height="11" viewBox="0 0 11 11" fill="none" aria-hidden="true">
+	<path
+		d="M2 5.5L4.5 8L9 3"
+		stroke="currentColor"
+		stroke-width="1.6"
+		stroke-linecap="round"
+		stroke-linejoin="round"
+	/>
+</svg>

6.17.1/workflowcanvas/workflow/icons/ChevronDownIcon.svelte

@@ -0,0 +1,13 @@
+<svg
+	viewBox="0 0 24 24"
+	width="16"
+	height="16"
+	fill="none"
+	stroke="currentColor"
+	stroke-width="2"
+	stroke-linecap="round"
+	stroke-linejoin="round"
+	aria-hidden="true"
+>
+	<polyline points="6 9 12 15 18 9"></polyline>
+</svg>

6.17.1/workflowcanvas/workflow/icons/ChevronLeftIcon.svelte

@@ -0,0 +1,13 @@
+<svg
+	viewBox="0 0 24 24"
+	width="16"
+	height="16"
+	fill="none"
+	stroke="currentColor"
+	stroke-width="2"
+	stroke-linecap="round"
+	stroke-linejoin="round"
+	aria-hidden="true"
+>
+	<polyline points="15 18 9 12 15 6"></polyline>
+</svg>

6.17.1/workflowcanvas/workflow/icons/CloseIcon.svelte

@@ -0,0 +1,8 @@
+<svg width="10" height="10" viewBox="0 0 10 10" fill="none" aria-hidden="true">
+	<path
+		d="M2 2L8 8M8 2L2 8"
+		stroke="currentColor"
+		stroke-width="1.5"
+		stroke-linecap="round"
+	/>
+</svg>

6.17.1/workflowcanvas/workflow/icons/DatasetIcon.svelte

@@ -0,0 +1,20 @@
+<svg width="14" height="14" viewBox="0 0 14 14" fill="none" aria-hidden="true">
+	<ellipse
+		cx="7"
+		cy="3.5"
+		rx="5"
+		ry="2"
+		stroke="currentColor"
+		stroke-width="1.5"
+	/>
+	<path
+		d="M2 3.5v3c0 1.1 2.24 2 5 2s5-.9 5-2v-3"
+		stroke="currentColor"
+		stroke-width="1.5"
+	/>
+	<path
+		d="M2 6.5v3c0 1.1 2.24 2 5 2s5-.9 5-2v-3"
+		stroke="currentColor"
+		stroke-width="1.5"
+	/>
+</svg>

6.17.1/workflowcanvas/workflow/icons/DownloadIcon.svelte

@@ -0,0 +1,15 @@
+<svg width="12" height="12" viewBox="0 0 12 12" fill="none" aria-hidden="true">
+	<path
+		d="M6 1.5v6.5M6 8L3 5M6 8l3-3"
+		stroke="currentColor"
+		stroke-width="1.4"
+		stroke-linecap="round"
+		stroke-linejoin="round"
+	/>
+	<path
+		d="M2 9.5v.5a1 1 0 0 0 1 1h6a1 1 0 0 0 1-1v-.5"
+		stroke="currentColor"
+		stroke-width="1.4"
+		stroke-linecap="round"
+	/>
+</svg>

6.17.1/workflowcanvas/workflow/icons/FunctionIcon.svelte

@@ -0,0 +1,14 @@
+<svg width="12" height="12" viewBox="0 0 12 12" fill="none" aria-hidden="true">
+	<path
+		d="M2 3h2.5a1 1 0 0 1 1 1v5a1 1 0 0 1-1 1H2"
+		stroke="currentColor"
+		stroke-width="1.4"
+		stroke-linecap="round"
+	/>
+	<path
+		d="M10 3H7.5a1 1 0 0 0-1 1v5a1 1 0 0 0 1 1H10"
+		stroke="currentColor"
+		stroke-width="1.4"
+		stroke-linecap="round"
+	/>
+</svg>

6.17.1/workflowcanvas/workflow/icons/ImageIcon.svelte

@@ -0,0 +1,19 @@
+<svg width="14" height="14" viewBox="0 0 14 14" fill="none" aria-hidden="true">
+	<rect
+		x="1.5"
+		y="2"
+		width="11"
+		height="10"
+		rx="1.5"
+		stroke="currentColor"
+		stroke-width="1.4"
+	/>
+	<circle cx="5" cy="5.5" r="1.1" stroke="currentColor" stroke-width="1.2" />
+	<path
+		d="M2 10l3-3 3 3 2-2 2 2"
+		stroke="currentColor"
+		stroke-width="1.4"
+		stroke-linecap="round"
+		stroke-linejoin="round"
+	/>
+</svg>

6.17.1/workflowcanvas/workflow/icons/Model3DIcon.svelte

@@ -0,0 +1,15 @@
+<svg width="14" height="14" viewBox="0 0 14 14" fill="none" aria-hidden="true">
+	<path
+		d="M7 1.6L12 4.3v5.4L7 12.4 2 9.7V4.3L7 1.6z"
+		stroke="currentColor"
+		stroke-width="1.4"
+		stroke-linejoin="round"
+	/>
+	<path
+		d="M2 4.3L7 7l5-2.7"
+		stroke="currentColor"
+		stroke-width="1.2"
+		stroke-linejoin="round"
+	/>
+	<path d="M7 7v5.4" stroke="currentColor" stroke-width="1.2" />
+</svg>

6.17.1/workflowcanvas/workflow/icons/OpenLinkIcon.svelte

@@ -0,0 +1,21 @@
+<svg width="12" height="12" viewBox="0 0 12 12" fill="none" aria-hidden="true">
+	<path
+		d="M5 2H3.5A1.5 1.5 0 0 0 2 3.5v5A1.5 1.5 0 0 0 3.5 10h5A1.5 1.5 0 0 0 10 8.5V7"
+		stroke="currentColor"
+		stroke-width="1.3"
+		stroke-linecap="round"
+	/>
+	<path
+		d="M7 2h3v3"
+		stroke="currentColor"
+		stroke-width="1.3"
+		stroke-linecap="round"
+		stroke-linejoin="round"
+	/>
+	<path
+		d="M10 2L5.5 6.5"
+		stroke="currentColor"
+		stroke-width="1.3"
+		stroke-linecap="round"
+	/>
+</svg>

6.17.1/workflowcanvas/workflow/icons/PlayIcon.svelte

@@ -0,0 +1,9 @@
+<svg
+	width="9"
+	height="10"
+	viewBox="0 0 9 10"
+	fill="currentColor"
+	aria-hidden="true"
+>
+	<path d="M0 0l9 5-9 5V0z" />
+</svg>

6.17.1/workflowcanvas/workflow/icons/PlusIcon.svelte

@@ -0,0 +1,8 @@
+<svg width="11" height="11" viewBox="0 0 11 11" fill="none" aria-hidden="true">
+	<path
+		d="M5.5 1v9M1 5.5h9"
+		stroke="currentColor"
+		stroke-width="1.8"
+		stroke-linecap="round"
+	/>
+</svg>

6.17.1/workflowcanvas/workflow/icons/SearchIcon.svelte

@@ -0,0 +1,9 @@
+<svg width="14" height="14" viewBox="0 0 14 14" fill="none" aria-hidden="true">
+	<circle cx="6" cy="6" r="4.5" stroke="currentColor" stroke-width="1.5" />
+	<path
+		d="M9.5 9.5L12.5 12.5"
+		stroke="currentColor"
+		stroke-width="1.5"
+		stroke-linecap="round"
+	/>
+</svg>

6.17.1/workflowcanvas/workflow/icons/StopIcon.svelte

@@ -0,0 +1,9 @@
+<svg
+	width="9"
+	height="9"
+	viewBox="0 0 9 9"
+	fill="currentColor"
+	aria-hidden="true"
+>
+	<rect width="9" height="9" rx="1.5" />
+</svg>

6.17.1/workflowcanvas/workflow/icons/TextIcon.svelte

@@ -0,0 +1,14 @@
+<svg width="14" height="14" viewBox="0 0 14 14" fill="none" aria-hidden="true">
+	<path
+		d="M3 3h8"
+		stroke="currentColor"
+		stroke-width="1.6"
+		stroke-linecap="round"
+	/>
+	<path
+		d="M7 3v8"
+		stroke="currentColor"
+		stroke-width="1.6"
+		stroke-linecap="round"
+	/>
+</svg>

6.17.1/workflowcanvas/workflow/icons/VideoIcon.svelte

@@ -0,0 +1,18 @@
+<svg width="14" height="14" viewBox="0 0 14 14" fill="none" aria-hidden="true">
+	<rect
+		x="1.5"
+		y="3.5"
+		width="8.5"
+		height="7"
+		rx="1.4"
+		stroke="currentColor"
+		stroke-width="1.4"
+	/>
+	<path
+		d="M10 6l2.5-1.5v5L10 8V6z"
+		stroke="currentColor"
+		stroke-width="1.4"
+		stroke-linejoin="round"
+		stroke-linecap="round"
+	/>
+</svg>

6.17.1/workflowcanvas/workflow/inference-stream.ts

@@ -0,0 +1,126 @@
+/**
+ * Browser-side streaming client for HF Inference text generation.
+ *
+ * Routes through `https://router.huggingface.co/v1/chat/completions`, HF's
+ * OpenAI-compatible unified endpoint. This bypasses our Python `call_model`
+ * server function for text-generation specifically so tokens stream into
+ * the canvas as they arrive instead of waiting for the full response.
+ *
+ * Other tasks (image, audio, classification, etc.) still go through the
+ * Python path — only text-generation gets the streaming treatment because
+ * it's the one task where partial output is meaningful.
+ */
+
+const ROUTER_URL = "https://router.huggingface.co/v1/chat/completions";
+
+export interface StreamTextOptions {
+	modelId: string;
+	prompt: string;
+	hfToken?: string;
+	provider?: string;
+	maxTokens?: number;
+	signal?: AbortSignal;
+	onChunk: (delta: string, accumulated: string) => void;
+}
+
+/**
+ * Stream a text-generation response token-by-token. Returns the final
+ * accumulated string when the stream ends. `onChunk` fires for each
+ * incremental delta with both the new delta and the running accumulator.
+ *
+ * Throws if the request fails or the stream cannot be opened — the caller
+ * is expected to surface the error (toast / node status).
+ */
+export async function stream_text_generation(
+	opts: StreamTextOptions
+): Promise<string> {
+	const headers: Record<string, string> = {
+		"Content-Type": "application/json"
+	};
+	if (opts.hfToken) headers["Authorization"] = `Bearer ${opts.hfToken}`;
+
+	const model =
+		opts.provider && opts.provider !== "auto"
+			? `${opts.modelId}:${opts.provider}`
+			: opts.modelId;
+
+	const body = JSON.stringify({
+		model,
+		messages: [{ role: "user", content: opts.prompt }],
+		max_tokens: opts.maxTokens ?? 512,
+		stream: true
+	});
+
+	const res = await fetch(ROUTER_URL, {
+		method: "POST",
+		headers,
+		body,
+		signal: opts.signal
+	});
+
+	if (!res.ok || !res.body) {
+		const detail = await res.text().catch(() => "");
+		throw new Error(
+			`HF router ${res.status}${detail ? `: ${detail.slice(0, 200)}` : ""}`
+		);
+	}
+
+	const reader = res.body.getReader();
+	const decoder = new TextDecoder("utf-8");
+	let buffer = "";
+	let accumulated = "";
+
+	try {
+		while (true) {
+			const { value, done } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+
+			// SSE frames are separated by blank lines; each `data:` line is a JSON
+			// chunk or the literal `[DONE]` sentinel.
+			let nl: number;
+			while ((nl = buffer.indexOf("\n")) !== -1) {
+				const line = buffer.slice(0, nl).trim();
+				buffer = buffer.slice(nl + 1);
+				if (!line.startsWith("data:")) continue;
+				const payload = line.slice(5).trim();
+				if (payload === "[DONE]") return accumulated;
+				try {
+					const chunk = JSON.parse(payload);
+					const delta = chunk?.choices?.[0]?.delta?.content ?? "";
+					if (delta) {
+						accumulated += delta;
+						opts.onChunk(delta, accumulated);
+					}
+				} catch {
+					// Malformed frame — skip; the next one usually recovers.
+				}
+			}
+		}
+	} finally {
+		try {
+			reader.releaseLock();
+		} catch {
+			/* noop */
+		}
+	}
+
+	return accumulated;
+}
+
+/**
+ * Pipeline tags eligible for browser-side streaming. Only text-generation
+ * variants benefit — image / audio / classification tasks are
+ * single-shot in nature, so the streaming router endpoint adds no value
+ * and would in fact be incorrect (it's a chat-completions API).
+ */
+export function is_streamable_text_task(
+	pipelineTag: string | undefined
+): boolean {
+	if (!pipelineTag) return false;
+	return (
+		pipelineTag === "text-generation" ||
+		pipelineTag === "text2text-generation" ||
+		pipelineTag === "conversational"
+	);
+}

6.17.1/workflowcanvas/workflow/node-library.ts

@@ -0,0 +1,316 @@
+import type { PortType } from "./workflow-types";
+import { PORT_REGISTRY } from "./workflow-modalities";
+import type { PortMeta } from "./workflow-modalities";
+
+export interface NodeTemplate {
+	label: string;
+	kind: "input" | "transform" | "output" | "component";
+	source: "local" | "space" | "model" | "dataset";
+	space_id?: string;
+	model_id?: string;
+	dataset_id?: string;
+	dataset_config?: string;
+	dataset_split?: string;
+	pipeline_tag?: string;
+	endpoint?: string;
+	category?: string;
+	inputs: { id: string; label: string; type: PortType }[];
+	outputs: { id: string; label: string; type: PortType }[];
+	width: number;
+	height: number;
+}
+
+/* ── HF Inference API task → port schemas ── */
+
+export interface TaskSchema {
+	inputs: { id: string; label: string; type: PortType }[];
+	outputs: { id: string; label: string; type: PortType }[];
+}
+
+export const TASK_SCHEMAS: Record<string, TaskSchema> = {
+	// Text → Text
+	"text-generation": {
+		inputs: [{ id: "in_0", label: "Prompt", type: "text" }],
+		outputs: [{ id: "out_0", label: "Text", type: "text" }]
+	},
+	"text2text-generation": {
+		inputs: [{ id: "in_0", label: "Text", type: "text" }],
+		outputs: [{ id: "out_0", label: "Text", type: "text" }]
+	},
+	summarization: {
+		inputs: [{ id: "in_0", label: "Text", type: "text" }],
+		outputs: [{ id: "out_0", label: "Summary", type: "text" }]
+	},
+	translation: {
+		inputs: [{ id: "in_0", label: "Text", type: "text" }],
+		outputs: [{ id: "out_0", label: "Translation", type: "text" }]
+	},
+	"fill-mask": {
+		inputs: [{ id: "in_0", label: "Text", type: "text" }],
+		outputs: [{ id: "out_0", label: "Result", type: "json" }]
+	},
+	conversational: {
+		inputs: [{ id: "in_0", label: "Message", type: "text" }],
+		outputs: [{ id: "out_0", label: "Reply", type: "text" }]
+	},
+	// Text → Classification
+	"text-classification": {
+		inputs: [{ id: "in_0", label: "Text", type: "text" }],
+		outputs: [{ id: "out_0", label: "Labels", type: "json" }]
+	},
+	"token-classification": {
+		inputs: [{ id: "in_0", label: "Text", type: "text" }],
+		outputs: [{ id: "out_0", label: "Entities", type: "json" }]
+	},
+	"zero-shot-classification": {
+		inputs: [
+			{ id: "in_0", label: "Text", type: "text" },
+			{ id: "in_1", label: "Labels", type: "text" }
+		],
+		outputs: [{ id: "out_0", label: "Scores", type: "json" }]
+	},
+	"sentence-similarity": {
+		inputs: [
+			{ id: "in_0", label: "Source", type: "text" },
+			{ id: "in_1", label: "Sentences", type: "text" }
+		],
+		outputs: [{ id: "out_0", label: "Scores", type: "json" }]
+	},
+	"question-answering": {
+		inputs: [
+			{ id: "in_0", label: "Question", type: "text" },
+			{ id: "in_1", label: "Context", type: "text" }
+		],
+		outputs: [{ id: "out_0", label: "Answer", type: "text" }]
+	},
+	"feature-extraction": {
+		inputs: [{ id: "in_0", label: "Text", type: "text" }],
+		outputs: [{ id: "out_0", label: "Embeddings", type: "json" }]
+	},
+	// Text → Image
+	"text-to-image": {
+		inputs: [{ id: "in_0", label: "Prompt", type: "text" }],
+		outputs: [{ id: "out_0", label: "Image", type: "image" }]
+	},
+	// Text → Audio
+	"text-to-speech": {
+		inputs: [{ id: "in_0", label: "Text", type: "text" }],
+		outputs: [{ id: "out_0", label: "Audio", type: "audio" }]
+	},
+	"text-to-audio": {
+		inputs: [{ id: "in_0", label: "Prompt", type: "text" }],
+		outputs: [{ id: "out_0", label: "Audio", type: "audio" }]
+	},
+	// Text → Video
+	"text-to-video": {
+		inputs: [{ id: "in_0", label: "Prompt", type: "text" }],
+		outputs: [{ id: "out_0", label: "Video", type: "video" }]
+	},
+	// Image → *
+	"image-classification": {
+		inputs: [{ id: "in_0", label: "Image", type: "image" }],
+		outputs: [{ id: "out_0", label: "Labels", type: "json" }]
+	},
+	"object-detection": {
+		inputs: [{ id: "in_0", label: "Image", type: "image" }],
+		outputs: [{ id: "out_0", label: "Detections", type: "json" }]
+	},
+	"image-segmentation": {
+		inputs: [{ id: "in_0", label: "Image", type: "image" }],
+		outputs: [{ id: "out_0", label: "Segments", type: "json" }]
+	},
+	"image-to-text": {
+		inputs: [{ id: "in_0", label: "Image", type: "image" }],
+		outputs: [{ id: "out_0", label: "Text", type: "text" }]
+	},
+	"image-to-image": {
+		inputs: [
+			{ id: "in_0", label: "Image", type: "image" },
+			{ id: "in_1", label: "Prompt", type: "text" }
+		],
+		outputs: [{ id: "out_0", label: "Image", type: "image" }]
+	},
+	"image-to-video": {
+		inputs: [{ id: "in_0", label: "Image", type: "image" }],
+		outputs: [{ id: "out_0", label: "Video", type: "video" }]
+	},
+	"depth-estimation": {
+		inputs: [{ id: "in_0", label: "Image", type: "image" }],
+		outputs: [{ id: "out_0", label: "Depth", type: "image" }]
+	},
+	"image-text-to-text": {
+		inputs: [
+			{ id: "in_0", label: "Image", type: "image" },
+			{ id: "in_1", label: "Prompt", type: "text" }
+		],
+		outputs: [{ id: "out_0", label: "Text", type: "text" }]
+	},
+	// Audio → *
+	"automatic-speech-recognition": {
+		inputs: [{ id: "in_0", label: "Audio", type: "audio" }],
+		outputs: [{ id: "out_0", label: "Text", type: "text" }]
+	},
+	"audio-classification": {
+		inputs: [{ id: "in_0", label: "Audio", type: "audio" }],
+		outputs: [{ id: "out_0", label: "Labels", type: "json" }]
+	},
+	"audio-to-audio": {
+		inputs: [{ id: "in_0", label: "Audio", type: "audio" }],
+		outputs: [{ id: "out_0", label: "Audio", type: "audio" }]
+	},
+	// Multimodal
+	"visual-question-answering": {
+		inputs: [
+			{ id: "in_0", label: "Image", type: "image" },
+			{ id: "in_1", label: "Question", type: "text" }
+		],
+		outputs: [{ id: "out_0", label: "Answer", type: "text" }]
+	},
+	"document-question-answering": {
+		inputs: [
+			{ id: "in_0", label: "Document", type: "image" },
+			{ id: "in_1", label: "Question", type: "text" }
+		],
+		outputs: [{ id: "out_0", label: "Answer", type: "text" }]
+	}
+};
+
+/**
+ * Build a reference/subject template for a port-registry entry. Reference
+ * and subject nodes share the same shape today (in/out of the same type) —
+ * the role tag in the workflow store disambiguates them at the data layer.
+ * Width/height stay constant; the runtime widget decides actual rendering.
+ */
+function componentTemplate(meta: PortMeta): NodeTemplate {
+	const height = meta.port_type === "number" ? 130 : 160;
+	return {
+		label: meta.label,
+		kind: "component",
+		source: "local",
+		inputs: [{ id: "in", label: meta.label, type: meta.port_type }],
+		outputs: [{ id: "out", label: meta.label, type: meta.port_type }],
+		width: 220,
+		height
+	};
+}
+
+export const LIBRARY: Record<string, NodeTemplate[]> = {
+	components: PORT_REGISTRY.map(componentTemplate),
+	spaces: [] as NodeTemplate[]
+};
+
+export function getComponentForPortType(type: string): NodeTemplate | null {
+	// `any`/`file` are inference-only fallbacks — default them to Image so
+	// the user gets a usable picker entry rather than nothing.
+	const lookup = (
+		type === "any" || type === "file" ? "image" : type
+	) as PortType;
+	return LIBRARY.components.find((c) => c.outputs[0]?.type === lookup) ?? null;
+}
+
+/* ── Expanded categories & pipeline-tag mapping ── */
+
+export const SPACE_CATEGORIES = [
+	{ key: "image", label: "Image" },
+	{ key: "audio", label: "Audio" },
+	{ key: "text", label: "Text" },
+	{ key: "video", label: "Video" },
+	{ key: "multimodal", label: "Multimodal" },
+	{ key: "3d", label: "3D" },
+	{ key: "chat", label: "Chat" },
+	{ key: "code", label: "Code" }
+];
+
+export const PIPELINE_TO_CATEGORY: Record<string, string> = {
+	// Image
+	"text-to-image": "image",
+	"image-to-image": "image",
+	"image-classification": "image",
+	"image-segmentation": "image",
+	"object-detection": "image",
+	"unconditional-image-generation": "image",
+	"image-feature-extraction": "image",
+	"depth-estimation": "image",
+	"image-to-text": "image",
+	// Audio
+	"text-to-speech": "audio",
+	"automatic-speech-recognition": "audio",
+	"audio-to-audio": "audio",
+	"audio-classification": "audio",
+	"voice-activity-detection": "audio",
+	// Text
+	"text-generation": "text",
+	"text2text-generation": "text",
+	translation: "text",
+	summarization: "text",
+	"text-classification": "text",
+	"question-answering": "text",
+	"fill-mask": "text",
+	"token-classification": "text",
+	"sentence-similarity": "text",
+	"feature-extraction": "text",
+	"zero-shot-classification": "text",
+	"table-question-answering": "text",
+	// Video
+	"text-to-video": "video",
+	"image-to-video": "video",
+	"video-classification": "video",
+	// 3D
+	"text-to-3d": "3d",
+	"image-to-3d": "3d",
+	// Multimodal
+	"visual-question-answering": "multimodal",
+	"image-text-to-text": "multimodal",
+	"document-question-answering": "multimodal",
+	"zero-shot-image-classification": "multimodal",
+	"video-text-to-text": "multimodal",
+	// Chat
+	conversational: "chat"
+};
+
+const KEYWORD_PATTERNS: [RegExp, string][] = [
+	// Video — check before image since "image to video" should be video
+	[/\b(video|animate|animation|motion|film|movie)\b/i, "video"],
+	// 3D
+	[/\b(3d|mesh|point.?cloud|nerf|gaussian.?splat|triposr)\b/i, "3d"],
+	// Audio
+	[/\b(audio|voice|speech|tts|whisper|music|sound|sing|talk)\b/i, "audio"],
+	// Chat
+	[
+		/\b(chat|conversation|assistant|llm|gpt|gemma|llama|mistral|qwen(?!.*(?:image|edit|video)))\b/i,
+		"chat"
+	],
+	// Multimodal
+	[/\b(multimodal|vision.?language|vqa|document.?q|ocr)\b/i, "multimodal"],
+	// Code
+	[/\b(code|program|compiler|debug|ide)\b/i, "code"],
+	// Image — broad, check last
+	[
+		/\b(image|photo|picture|paint|draw|sketch|pixel|diffus|flux|stable|edit.*image|image.*edit|face|swap|background|segm|detect|caption|upscal|super.?res|inpaint|outpaint|style.?transfer|lora|controlnet)\b/i,
+		"image"
+	]
+];
+
+export function categorizeSpace(
+	pipelineTag?: string | null,
+	tags?: string[] | null,
+	description?: string | null,
+	spaceId?: string | null
+): string | null {
+	if (pipelineTag && PIPELINE_TO_CATEGORY[pipelineTag]) {
+		return PIPELINE_TO_CATEGORY[pipelineTag];
+	}
+	if (tags) {
+		for (const tag of tags) {
+			if (PIPELINE_TO_CATEGORY[tag]) return PIPELINE_TO_CATEGORY[tag];
+		}
+	}
+	// Fall back to keyword matching on description + space ID
+	const text = [description ?? "", spaceId ?? ""].join(" ");
+	if (text.trim()) {
+		for (const [pattern, category] of KEYWORD_PATTERNS) {
+			if (pattern.test(text)) return category;
+		}
+	}
+	return null;
+}

6.17.1/workflowcanvas/workflow/space-api.ts

@@ -0,0 +1,325 @@
+import type { PortType, Port } from "./workflow-types";
+import { modalityForPort } from "./workflow-modalities";
+import type { ModalityConfig } from "./workflow-modalities";
+
+export function normalize_space_id(raw: string): string | null {
+	const trimmed = raw.trim().replace(/\/+$/, "");
+	if (!trimmed) return null;
+
+	if (/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(trimmed)) {
+		return trimmed;
+	}
+
+	const pageMatch = trimmed.match(
+		/^https?:\/\/(?:www\.)?huggingface\.co\/spaces\/([^/\s?#]+)\/([^/\s?#]+)/i
+	);
+	if (pageMatch) return `${pageMatch[1]}/${pageMatch[2]}`;
+
+	const sub = trimmed.match(/^https?:\/\/([^/]+)\.hf\.space/i);
+	if (sub) {
+		const parts = sub[1].split("-");
+		if (parts.length >= 2) {
+			return `${parts[0]}/${parts.slice(1).join("-")}`;
+		}
+	}
+
+	return null;
+}
+
+/** Map Gradio component types to our port types */
+export function componentToPortType(
+	component: string,
+	type?: string,
+	pythonType?: string,
+	labelHint?: string
+): PortType {
+	const c = component.toLowerCase();
+	if (pythonType) {
+		const cleaned = pythonType
+			.toLowerCase()
+			.replace(/^none\s*\|\s*/, "")
+			.replace(/\s*\|\s*none$/, "")
+			.trim();
+		if (cleaned === "str" || cleaned === "string") return "text";
+		if (cleaned === "int" || cleaned === "integer" || cleaned === "float")
+			return "number";
+		if (cleaned === "bool" || cleaned === "boolean") return "boolean";
+	}
+	if (c === "image" || c === "imageeditor" || c === "imageslider")
+		return "image";
+	if (c === "gallery") return "gallery";
+	if (c === "audio") return "audio";
+	if (c === "video") return "video";
+	if (c === "number" || c === "slider") return "number";
+	if (c === "checkbox") return "boolean";
+	if (c === "file" || c === "uploadbutton" || c === "downloadbutton")
+		return "file";
+	if (c === "model3d") return "model3d";
+	if (c === "json" || c === "dataframe") return "json";
+	if (c === "state") return "__skip__" as PortType; // internal, not user I/O
+	if (
+		c === "textbox" ||
+		c === "text" ||
+		c === "markdown" ||
+		c === "chatbot" ||
+		c === "label" ||
+		c === "code" ||
+		c === "highlightedtext" ||
+		c === "dropdown" ||
+		c === "radio" ||
+		c === "checkboxgroup" ||
+		c === "colorpicker" ||
+		c === "html"
+	)
+		return "text";
+
+	// gr.api endpoints use component="Api" with python_type carrying the
+	// real hint — primitives already handled at the top of the function.
+	if (pythonType) {
+		const cleaned = pythonType
+			.toLowerCase()
+			.replace(/^none\s*\|\s*/, "")
+			.replace(/\s*\|\s*none$/, "")
+			.trim();
+		if (
+			cleaned === "filepath" ||
+			cleaned === "file" ||
+			cleaned.includes("filedata")
+		) {
+			const l = (labelHint ?? "").toLowerCase();
+			if (/audio|wav|mp3|voice|sound|speech|tts|asr/.test(l)) return "audio";
+			if (/image|img|photo|picture|pic\b/.test(l)) return "image";
+			if (/video|mp4|movie|clip/.test(l)) return "video";
+			if (/model3d|mesh|glb|gltf|obj\b/.test(l)) return "model3d";
+			return "file";
+		}
+		if (
+			cleaned.includes("dict") ||
+			cleaned.includes("list") ||
+			cleaned.includes("any")
+		)
+			return "json";
+	}
+
+	// Fallback: check the type field from the API
+	if (type) {
+		const t = typeof type === "string" ? type.toLowerCase() : "";
+		if (t.includes("image") || t.includes("pil")) return "image";
+		if (t.includes("video") || t.includes("mp4")) return "video";
+		if (t.includes("audio") || t.includes("wav") || t.includes("mp3"))
+			return "audio";
+		if (t.includes("filepath") || t.includes("file")) return "file";
+		if (t === "number" || t === "float" || t === "int" || t === "integer")
+			return "number";
+		if (t === "bool" || t === "boolean") return "boolean";
+		if (t === "str" || t === "string") return "text";
+	}
+
+	return "any";
+}
+
+/** Prefixes that indicate utility/event-handler endpoints — skip these */
+const UTILITY_PREFIXES = [
+	"/on_",
+	"/handle_",
+	"/update_",
+	"/prepare_",
+	"/load_",
+	"/clear_",
+	"/reset_"
+];
+
+export interface EndpointSig {
+	name: string;
+	inputs: Port[];
+	outputs: Port[];
+}
+
+export interface SpaceApiInfo {
+	endpoint: string;
+	inputs: Port[];
+	outputs: Port[];
+	width: number;
+	endpoints: EndpointSig[];
+}
+
+const ORDINAL_LABEL = /^\d+(st|nd|rd|th)$/i;
+
+function parse_endpoint_sig(name: string, ep: any): EndpointSig {
+	const inputs = (ep.parameters ?? [])
+		.map((p: any, i: number) => {
+			const isApi = (p.component ?? "").toLowerCase() === "api";
+			const pyType = p.python_type?.type;
+			const labelHint = p.parameter_name || p.label || "";
+			const portType = componentToPortType(
+				p.component ?? "",
+				typeof p.type === "string" ? p.type : "",
+				pyType,
+				labelHint
+			);
+			if (portType === "__skip__") return null;
+			const hasDefault = p.parameter_has_default === true;
+			const useParamName =
+				(isApi || ORDINAL_LABEL.test(p.label ?? "")) && p.parameter_name;
+			const rawLabel = useParamName
+				? p.parameter_name
+				: p.label || p.parameter_name || `Input ${i}`;
+			return {
+				id: `in_${i}`,
+				label: rawLabel,
+				type: portType,
+				required: !hasDefault,
+				default_value:
+					hasDefault && p.default !== undefined ? p.default : undefined
+			};
+		})
+		.filter(Boolean) as Port[];
+
+	const outputs = (ep.returns ?? [])
+		.map((r: any, i: number) => {
+			const isApi = (r.component ?? "").toLowerCase() === "api";
+			const pyType = r.python_type?.type;
+			const labelHint = isApi
+				? `${r.parameter_name ?? ""} ${name ?? ""}`.trim()
+				: r.parameter_name || r.label || "";
+			const portType = componentToPortType(
+				r.component ?? "",
+				typeof r.type === "string" ? r.type : "",
+				pyType,
+				labelHint
+			);
+			if (portType === "__skip__") return null;
+			const useParamName =
+				(isApi || ORDINAL_LABEL.test(r.label ?? "")) && r.parameter_name;
+			const rawLabel = useParamName
+				? r.parameter_name
+				: r.label || `Output ${i}`;
+			return {
+				id: `out_${i}`,
+				label: rawLabel,
+				type: portType,
+				output_index: i
+			};
+		})
+		.filter(Boolean) as Port[];
+
+	if (inputs.length === 0)
+		inputs.push({ id: "in", label: "Input", type: "any" as PortType });
+	if (outputs.length === 0)
+		outputs.push({ id: "out", label: "Output", type: "any" as PortType });
+
+	return { name, inputs, outputs };
+}
+
+/** Cache for fetched API info */
+const spaceApiCache = new Map<string, SpaceApiInfo>();
+
+/**
+ * Fetch API info from a Space and return endpoint, inputs, outputs.
+ * Results are cached by space_id.
+ */
+export async function fetchSpaceApi(spaceId: string): Promise<SpaceApiInfo> {
+	const cached = spaceApiCache.get(spaceId);
+	if (cached) return cached;
+
+	const spaceUrl = spaceId.startsWith("http")
+		? spaceId
+		: `https://${spaceId.replace("/", "-").replaceAll(".", "-").toLowerCase()}.hf.space`;
+
+	// Try multiple API paths — older Spaces use /info, newer use /gradio_api/info
+	let infoRes: Response | null = null;
+	for (const path of ["/gradio_api/info", "/info", "/api/info"]) {
+		try {
+			const res = await Promise.race([
+				fetch(`${spaceUrl}${path}`),
+				new Promise<never>((_, reject) =>
+					setTimeout(() => reject(new Error("Timed out")), 10000)
+				)
+			]);
+			if (res.ok) {
+				infoRes = res;
+				break;
+			}
+		} catch {
+			/* try next */
+		}
+	}
+	if (!infoRes)
+		throw new Error(
+			"Could not connect to Space — it may be sleeping or have no Gradio API"
+		);
+
+	const api = await infoRes.json();
+	const named = api.named_endpoints ?? {};
+	const unnamed = api.unnamed_endpoints ?? {};
+
+	const all_endpoints: Array<[string, any]> = [
+		...Object.entries(named),
+		...Object.entries(unnamed)
+	].filter(([n]) => !UTILITY_PREFIXES.some((p) => n.startsWith(p)));
+
+	if (all_endpoints.length === 0) {
+		throw new Error("No suitable endpoints found");
+	}
+
+	// Default to /predict if present (most common Gradio convention), else
+	// the first non-utility endpoint. Users can switch via the node dropdown.
+	const default_index = Math.max(
+		0,
+		all_endpoints.findIndex(([n]) => n === "/predict")
+	);
+	const [epName, ep] = all_endpoints[default_index];
+	const endpoints: EndpointSig[] = all_endpoints.map(([n, e]) =>
+		parse_endpoint_sig(n, e)
+	);
+
+	const picked = parse_endpoint_sig(epName, ep);
+	const inputs = picked.inputs;
+	const outputs = picked.outputs;
+
+	const label = spaceId.split("/").pop() ?? spaceId;
+	const maxPortLen = Math.max(
+		...inputs.map((p: any) => (p.label as string).length),
+		...outputs.map((p: any) => (p.label as string).length),
+		label.length
+	);
+	const width = Math.max(280, Math.min(400, maxPortLen * 9 + 100));
+
+	const result = { endpoint: epName, inputs, outputs, width, endpoints };
+	spaceApiCache.set(spaceId, result);
+	return result;
+}
+
+/**
+ * Clamp inferred port types so a fallback `any` or `file` becomes the
+ * modality's canonical type when the modality is known. Models picked via
+ * `pipeline_tag` and Spaces picked via the modality picker carry that hint;
+ * passing it lets us avoid surfacing generic `any`/`file` ports in the UI.
+ *
+ * If `modality` is null (e.g. unknown), ports are returned unchanged.
+ */
+export function normalizeOperatorPorts(
+	modality: ModalityConfig | null,
+	ports: Port[]
+): Port[] {
+	if (!modality?.port_type) return ports;
+	const canonical = modality.port_type;
+	return ports.map((p) => {
+		if (p.type === "any" || p.type === "file") {
+			return { ...p, type: canonical };
+		}
+		return p;
+	});
+}
+
+/**
+ * Canonicalize a single port type using the modality registry. Used by
+ * schema lookups (TASK_SCHEMAS) to clamp legacy `any`/`file` entries.
+ * Pass-through for already-specific types.
+ */
+export function canonicalizePort(type: PortType, hint?: PortType): PortType {
+	if (type !== "any" && type !== "file") return type;
+	if (!hint) return type;
+	const modality = modalityForPort(hint);
+	return modality?.port_type ?? type;
+}

6.17.1/workflowcanvas/workflow/viewport-persistence.ts

@@ -0,0 +1,46 @@
+export interface Viewport {
+	x: number;
+	y: number;
+	zoom: number;
+}
+
+const DEFAULT_VIEWPORT: Viewport = { x: 0, y: 0, zoom: 1 };
+
+export function viewport_storage_key(name: string): string {
+	return `gradio_workflow_viewport:${name}`;
+}
+
+export function load_viewport(
+	name: string,
+	storage: Storage | undefined = typeof localStorage !== "undefined"
+		? localStorage
+		: undefined
+): Viewport {
+	if (!storage) return { ...DEFAULT_VIEWPORT };
+	try {
+		const raw = storage.getItem(viewport_storage_key(name));
+		if (!raw) return { ...DEFAULT_VIEWPORT };
+		const v = JSON.parse(raw);
+		if (
+			typeof v?.x === "number" &&
+			typeof v?.y === "number" &&
+			typeof v?.zoom === "number"
+		) {
+			return { x: v.x, y: v.y, zoom: v.zoom };
+		}
+	} catch {}
+	return { ...DEFAULT_VIEWPORT };
+}
+
+export function save_viewport(
+	name: string,
+	viewport: Viewport,
+	storage: Storage | undefined = typeof localStorage !== "undefined"
+		? localStorage
+		: undefined
+): void {
+	if (!storage) return;
+	try {
+		storage.setItem(viewport_storage_key(name), JSON.stringify(viewport));
+	} catch {}
+}

6.17.1/workflowcanvas/workflow/workflow-executor.ts

@@ -0,0 +1,526 @@
+import type {
+	Workflow,
+	WFNode,
+	WFEdge,
+	NodeDataValue,
+	NodeStatus,
+	FileValue
+} from "./workflow-types";
+import { toLegacyShape } from "./workflow-migration";
+import { topoSort } from "./workflow-graph";
+
+type StatusCallback = (
+	nodeId: string,
+	status: NodeStatus,
+	error?: string,
+	errorType?: string
+) => void;
+type OutputCallback = (
+	nodeId: string,
+	portId: string,
+	value: NodeDataValue
+) => void;
+type ServerCallFn = (
+	spaceId: string,
+	endpoint: string,
+	argsJson: string
+) => Promise<string>;
+type ServerCallModelFn = (
+	modelId: string,
+	pipelineTag: string,
+	argsJson: string,
+	provider?: string
+) => Promise<string>;
+type ServerFetchDatasetFn = (
+	datasetId: string,
+	config: string,
+	split: string,
+	offset: string,
+	length: string
+) => Promise<string>;
+type ServerCallPyFn = (fnName: string, argsJson: string) => Promise<string>;
+/**
+ * Browser-side streaming for text-generation tasks. Returns the final
+ * accumulated string. `onChunk` fires per delta so the executor can call
+ * `onOutput` incrementally and the UI updates live as tokens arrive.
+ */
+type StreamTextFn = (
+	modelId: string,
+	prompt: string,
+	provider: string | undefined,
+	signal: AbortSignal | undefined,
+	onChunk: (delta: string, accumulated: string) => void
+) => Promise<string>;
+
+function resolveInputs(
+	node: WFNode,
+	edges: WFEdge[],
+	dataMap: Record<string, Record<string, NodeDataValue>>
+): Record<string, NodeDataValue> {
+	const resolved: Record<string, NodeDataValue> = {};
+	for (const port of node.inputs) {
+		const edge = edges.find(
+			(e) => e.to_node_id === node.id && e.to_port_id === port.id
+		);
+		if (edge) {
+			resolved[port.id] =
+				dataMap[edge.from_node_id]?.[edge.from_port_id] ?? null;
+		} else {
+			resolved[port.id] =
+				node.data?.[port.id] ?? (port.default_value as NodeDataValue) ?? null;
+		}
+	}
+	return resolved;
+}
+
+async function toGradioArg(value: NodeDataValue): Promise<unknown> {
+	if (value === null) return null;
+	if (typeof value === "string") return value;
+	if (typeof value === "number") return value;
+	if (typeof value === "boolean") return value;
+	const fileVal = value as FileValue;
+	// Blob URLs need to be uploaded to our Gradio server first
+	if (fileVal.url.startsWith("blob:") || fileVal.url.startsWith("data:")) {
+		try {
+			const response = await fetch(fileVal.url);
+			if (!response.ok)
+				throw new Error(`Blob fetch failed: ${response.status}`);
+			const blob = await response.blob();
+			const formData = new FormData();
+			formData.append("files", blob, fileVal.name || "file");
+			// Try /gradio_api/upload first, then /upload
+			for (const path of ["/gradio_api/upload", "/upload"]) {
+				const uploadRes = await fetch(path, { method: "POST", body: formData });
+				if (uploadRes.ok) {
+					const files = await uploadRes.json();
+					return { path: files[0], url: files[0] };
+				}
+			}
+			throw new Error("Upload failed");
+		} catch (err) {
+			console.error("[Executor] File upload error:", err);
+			throw new Error(
+				`Failed to upload file: ${err instanceof Error ? err.message : err}`
+			);
+		}
+	}
+	// Remote URLs can be passed directly
+	return { url: fileVal.url };
+}
+
+const MEDIA_PORT_TYPES = new Set([
+	"image",
+	"audio",
+	"video",
+	"file",
+	"gallery",
+	"model3d"
+]);
+
+function output_matches_port_type(item: unknown, portType: string): boolean {
+	if (item === null || item === undefined) return false;
+	if (MEDIA_PORT_TYPES.has(portType)) {
+		if (typeof item === "string") {
+			return /^(https?:|blob:|data:|\/)/.test(item);
+		}
+		return (
+			typeof item === "object" &&
+			("path" in (item as object) || "url" in (item as object))
+		);
+	}
+	if (portType === "text") return typeof item === "string";
+	if (portType === "number") return typeof item === "number";
+	if (portType === "boolean") return typeof item === "boolean";
+	if (portType === "json")
+		return typeof item === "object" || Array.isArray(item);
+	return true;
+}
+
+function pick_response_item(
+	port: { type: string; output_index?: number },
+	port_index: number,
+	output_data: unknown[],
+	total_ports: number
+): unknown {
+	const primary =
+		typeof port.output_index === "number"
+			? output_data[port.output_index]
+			: total_ports === 1 && output_data.length > 1
+				? null
+				: output_data[port_index];
+
+	if (primary != null && output_matches_port_type(primary, port.type)) {
+		return primary;
+	}
+
+	const shape_match = output_data.find((item) =>
+		output_matches_port_type(item, port.type)
+	);
+	if (shape_match !== undefined) return shape_match;
+
+	return primary ?? output_data[0] ?? null;
+}
+
+function fromGradioOutput(result: unknown, portType: string): NodeDataValue {
+	if (result === null || result === undefined) return null;
+	if (
+		typeof result === "object" &&
+		!Array.isArray(result) &&
+		(result as Record<string, unknown>).__type__ === "update" &&
+		"value" in (result as Record<string, unknown>)
+	) {
+		return fromGradioOutput(
+			(result as Record<string, unknown>).value,
+			portType
+		);
+	}
+	if (Array.isArray(result)) {
+		if (result.length === 0) return null;
+		return fromGradioOutput(result[result.length - 1], portType);
+	}
+	if (typeof result === "number") return result;
+	if (typeof result === "boolean") return result;
+	if (typeof result === "string") {
+		if (
+			portType !== "text" &&
+			(result.startsWith("http://") ||
+				result.startsWith("https://") ||
+				result.startsWith("blob:") ||
+				result.startsWith("data:"))
+		) {
+			return {
+				name: "output",
+				url: result,
+				mime:
+					portType === "image"
+						? "image/png"
+						: portType === "audio"
+							? "audio/wav"
+							: "video/mp4"
+			} satisfies FileValue;
+		}
+		return result;
+	}
+	if (
+		typeof result === "object" &&
+		"url" in (result as Record<string, unknown>)
+	) {
+		const obj = result as Record<string, unknown>;
+		return {
+			name: (obj.orig_name as string) ?? "output",
+			url: obj.url as string,
+			mime: (obj.mime_type as string) ?? "application/octet-stream"
+		} satisfies FileValue;
+	}
+	return String(result);
+}
+
+export async function executeWorkflow(
+	workflow: Workflow,
+	onStatus: StatusCallback,
+	onOutput: OutputCallback,
+	signal?: AbortSignal,
+	serverCallSpace?: ServerCallFn,
+	serverCallModel?: ServerCallModelFn,
+	serverFetchDataset?: ServerFetchDatasetFn,
+	serverCallFn?: ServerCallPyFn,
+	stream_text_generation?: StreamTextFn
+): Promise<void> {
+	const { nodes, edges } = toLegacyShape(workflow);
+	const dataMap: Record<string, Record<string, NodeDataValue>> = {};
+	const failed_nodes = new Map<string, string>();
+
+	function mark_node_failed(node: WFNode, err: unknown): void {
+		const msg = err instanceof Error ? err.message : String(err);
+		const errorType = (err as { errorType?: string })?.errorType;
+		onStatus(node.id, "error", msg, errorType);
+		failed_nodes.set(node.id, node.label);
+		dataMap[node.id] = {};
+		for (const port of node.outputs) dataMap[node.id][port.id] = null;
+	}
+
+	function missing_input_message(node: WFNode, port: Port): string {
+		const edge = edges.find(
+			(e) => e.to_node_id === node.id && e.to_port_id === port.id
+		);
+		if (edge) {
+			const upstream = nodes.find((n) => n.id === edge.from_node_id);
+			if (upstream && failed_nodes.has(upstream.id)) {
+				return `"${port.label}" is missing — upstream node "${upstream.label}" failed`;
+			}
+		}
+		return `"${port.label}" is missing — an upstream node may have failed`;
+	}
+
+	// Seed input nodes (including component nodes with no incoming edges)
+	for (const node of nodes.filter((n) => {
+		if (n.kind === "input") return true;
+		if (n.kind === "component") {
+			return !edges.some((e) => e.to_node_id === n.id);
+		}
+		return false;
+	})) {
+		dataMap[node.id] = { ...(node.data ?? {}) };
+	}
+
+	// Build layers for parallel execution
+	const sorted = topoSort(nodes, edges);
+	const layers: WFNode[][] = [];
+	for (const node of sorted) {
+		const depDepth = edges
+			.filter((e) => e.to_node_id === node.id)
+			.map((e) =>
+				layers.findIndex((layer) => layer.some((n) => n.id === e.from_node_id))
+			)
+			.reduce((max, d) => Math.max(max, d), -1);
+		const layerIdx = depDepth + 1;
+		while (layers.length <= layerIdx) layers.push([]);
+		layers[layerIdx].push(node);
+	}
+
+	async function executeNode(node: WFNode): Promise<void> {
+		if (signal?.aborted) return;
+
+		// Component nodes with no incoming edges act as inputs
+		const isComponentInput =
+			node.kind === "component" && !edges.some((e) => e.to_node_id === node.id);
+
+		// Dataset operators take a single scalar "row_index" input. When wired,
+		// upstream supplies the offset; when unwired the inline default (set at
+		// picker time, edited on the node body) is used.
+		if (node.source === "dataset" && node.dataset_id) {
+			onStatus(node.id, "running");
+			try {
+				if (!serverFetchDataset)
+					throw new Error("Dataset fetch function not available");
+				const inputs = resolveInputs(node, edges, dataMap);
+				const raw = inputs["row_index"] ?? 0;
+				const n = typeof raw === "number" ? raw : Number(raw);
+				const offset = Math.max(0, Math.trunc(Number.isFinite(n) ? n : 0));
+				const resultJson = await serverFetchDataset(
+					node.dataset_id,
+					node.dataset_config ?? "default",
+					node.dataset_split ?? "train",
+					String(offset),
+					"1"
+				);
+				const result = JSON.parse(resultJson);
+				if (result.error) throw new Error(result.error);
+
+				const row = result.rows?.[0] ?? {};
+				dataMap[node.id] = {};
+				for (const port of node.outputs) {
+					const value = row[port.label] ?? null;
+					// Convert image/audio objects to file values
+					if (value && typeof value === "object" && "src" in value) {
+						const fileVal = {
+							name: port.label,
+							url: value.src,
+							mime: "application/octet-stream"
+						};
+						dataMap[node.id][port.id] = fileVal as NodeDataValue;
+						onOutput(node.id, port.id, fileVal as NodeDataValue);
+					} else {
+						dataMap[node.id][port.id] = value as NodeDataValue;
+						onOutput(node.id, port.id, value as NodeDataValue);
+					}
+				}
+				onStatus(node.id, "done");
+			} catch (err) {
+				mark_node_failed(node, err);
+			}
+			return;
+		}
+
+		if (node.kind === "input" || isComponentInput) {
+			onStatus(node.id, "done");
+			return;
+		}
+
+		// Component nodes with incoming edges act as outputs
+		const isComponentOutput =
+			node.kind === "component" && edges.some((e) => e.to_node_id === node.id);
+		if (node.kind === "output" || isComponentOutput) {
+			const inputs = resolveInputs(node, edges, dataMap);
+			const inputPort = node.inputs[0];
+			if (inputPort) {
+				const value = inputs[inputPort.id];
+				dataMap[node.id] = { [inputPort.id]: value };
+				onOutput(node.id, inputPort.id, value);
+				const outputPort = node.outputs[0];
+				if (outputPort) {
+					dataMap[node.id][outputPort.id] = value;
+				}
+			}
+			onStatus(node.id, "done");
+			return;
+		}
+
+		// Python function nodes (FnNode) call back to the Python server
+		if (node.source === "fn" && node.fn) {
+			onStatus(node.id, "running");
+			try {
+				if (!serverCallFn)
+					throw new Error("Python function call not available");
+				const inputs = resolveInputs(node, edges, dataMap);
+				for (const port of node.inputs) {
+					if (port.required && inputs[port.id] === null) {
+						throw new Error(missing_input_message(node, port));
+					}
+				}
+				const args = node.inputs.map((port) => inputs[port.id]);
+				const resultJson = await serverCallFn(node.fn, JSON.stringify(args));
+				const resultData = JSON.parse(resultJson);
+				if (
+					resultData &&
+					typeof resultData === "object" &&
+					"error" in resultData
+				) {
+					throw new Error(resultData.error);
+				}
+				dataMap[node.id] = {};
+				const outputData = Array.isArray(resultData)
+					? resultData
+					: [resultData];
+				node.outputs.forEach((port, i) => {
+					const value = fromGradioOutput(outputData[i] ?? null, port.type);
+					dataMap[node.id][port.id] = value;
+					onOutput(node.id, port.id, value);
+				});
+				onStatus(node.id, "done");
+			} catch (err) {
+				mark_node_failed(node, err);
+			}
+			return;
+		}
+
+		if (node.kind === "transform" && (node.space_id || node.model_id)) {
+			onStatus(node.id, "running");
+
+			try {
+				const inputs = resolveInputs(node, edges, dataMap);
+				for (const port of node.inputs) {
+					if (port.required && inputs[port.id] === null) {
+						throw new Error(missing_input_message(node, port));
+					}
+				}
+				const args = await Promise.all(
+					node.inputs.map((port) => toGradioArg(inputs[port.id]))
+				);
+
+				let resultJson: string;
+
+				if (node.source === "model" && node.model_id) {
+					if (!serverCallModel) {
+						throw new Error("Model call function not available");
+					}
+					// Prefer browser-side streaming for chat-completion-compatible
+					// text tasks so the UI receives tokens as they arrive. The
+					// Python path stays for every other task.
+					const tag = node.pipeline_tag ?? "text-generation";
+					const streamable =
+						(tag === "text-generation" ||
+							tag === "text2text-generation" ||
+							tag === "conversational") &&
+						!!stream_text_generation;
+					if (streamable) {
+						const prompt =
+							typeof args[0] === "string" ? args[0] : String(args[0] ?? "");
+						const outputPort = node.outputs[0];
+						const final = await stream_text_generation!(
+							node.model_id,
+							prompt,
+							node.provider,
+							signal,
+							(_delta, accumulated) => {
+								if (outputPort) onOutput(node.id, outputPort.id, accumulated);
+							}
+						);
+						resultJson = JSON.stringify([final]);
+					} else {
+						resultJson = await Promise.race([
+							serverCallModel(
+								node.model_id,
+								tag,
+								JSON.stringify(args),
+								node.provider
+							),
+							new Promise<never>((_, reject) =>
+								setTimeout(
+									() =>
+										reject(
+											new Error("Request timed out — model may be loading")
+										),
+									300000
+								)
+							)
+						]);
+					}
+				} else {
+					const endpointName = node.endpoint ?? "/predict";
+					if (!serverCallSpace) {
+						throw new Error("Server call function not available");
+					}
+					resultJson = await Promise.race([
+						serverCallSpace(node.space_id!, endpointName, JSON.stringify(args)),
+						new Promise<never>((_, reject) =>
+							setTimeout(
+								() =>
+									reject(
+										new Error("Request timed out — Space may be overloaded")
+									),
+								300000
+							)
+						)
+					]);
+				}
+
+				const resultData = JSON.parse(resultJson);
+
+				// Check for structured error from Python
+				if (
+					resultData &&
+					typeof resultData === "object" &&
+					"error" in resultData
+				) {
+					const suggestion = resultData.suggestion;
+					const errorType = resultData.error_type;
+					const title = resultData.title;
+					const rawMsg = title
+						? `${title}: ${resultData.error}`
+						: resultData.error;
+					const msg = suggestion || rawMsg;
+					const err = new Error(msg);
+					(err as any).errorType = errorType;
+					throw err;
+				}
+
+				dataMap[node.id] = {};
+				const outputData = Array.isArray(resultData)
+					? resultData
+					: [resultData];
+				node.outputs.forEach((port, i) => {
+					const raw = pick_response_item(
+						port,
+						i,
+						outputData,
+						node.outputs.length
+					);
+					const value = fromGradioOutput(raw, port.type);
+					dataMap[node.id][port.id] = value;
+					onOutput(node.id, port.id, value);
+				});
+
+				onStatus(node.id, "done");
+			} catch (err) {
+				mark_node_failed(node, err);
+			}
+		}
+	}
+
+	// Execute layers in parallel
+	for (const layer of layers) {
+		if (signal?.aborted) break;
+		await Promise.all(layer.map(executeNode));
+	}
+}

6.17.1/workflowcanvas/workflow/workflow-graph.ts

@@ -0,0 +1,146 @@
+/**
+ * Pure graph utilities used by the canvas — extracted so they can be
+ * unit-tested without standing up a Svelte component. Anything that
+ * computes a value from the workflow / node lists / edges and doesn't
+ * touch the DOM lives here.
+ */
+
+import type { NodeStatus, WFEdge, WFNode, Workflow } from "./workflow-types";
+
+/**
+ * Walk diagonally from (x, y) in 28px steps until an open spot is found
+ * that doesn't visually overlap an existing node. Used by code paths
+ * that drop a fresh node at a fixed fallback position (canvas center,
+ * picker create, etc.) — without this, successive adds stack identically.
+ */
+export function findFreeSpot(
+	nodes: { x: number; y: number }[],
+	x: number,
+	y: number
+): { x: number; y: number } {
+	let nx = x;
+	let ny = y;
+	while (nodes.some((n) => Math.abs(n.x - nx) < 8 && Math.abs(n.y - ny) < 8)) {
+		nx += 28;
+		ny += 28;
+	}
+	return { x: nx, y: ny };
+}
+
+/**
+ * Topological sort: returns a sorted list of nodes such that every edge
+ * goes from an earlier node to a later one. Standard Kahn's algorithm.
+ */
+export function topoSort(nodes: WFNode[], edges: WFEdge[]): WFNode[] {
+	const deg = new Map(nodes.map((n) => [n.id, 0]));
+	for (const e of edges)
+		deg.set(e.to_node_id, (deg.get(e.to_node_id) ?? 0) + 1);
+	const q = nodes.filter((n) => deg.get(n.id) === 0);
+	const out: WFNode[] = [];
+	while (q.length) {
+		const n = q.shift()!;
+		out.push(n);
+		for (const e of edges.filter((e) => e.from_node_id === n.id)) {
+			const d = (deg.get(e.to_node_id) ?? 1) - 1;
+			deg.set(e.to_node_id, d);
+			if (d === 0) q.push(nodes.find((nd) => nd.id === e.to_node_id)!);
+		}
+	}
+	return out;
+}
+
+/**
+ * Compute the effective input values for a node right now — mirrors the
+ * executor's `resolveInputs` so the canvas can detect staleness without
+ * re-running the graph. For each input port:
+ *  - if wired, take the upstream node's stored data for that output port,
+ *  - otherwise fall back to the node's own inline data or port default.
+ */
+export function resolveCurrentInputs(
+	node: WFNode,
+	allNodes: WFNode[],
+	edges: WFEdge[]
+): Record<string, unknown> {
+	const resolved: Record<string, unknown> = {};
+	for (const port of node.inputs) {
+		const edge = edges.find(
+			(e) => e.to_node_id === node.id && e.to_port_id === port.id
+		);
+		if (edge) {
+			const upstream = allNodes.find((n) => n.id === edge.from_node_id);
+			resolved[port.id] = upstream?.data?.[edge.from_port_id] ?? null;
+		} else {
+			resolved[port.id] = node.data?.[port.id] ?? port.default_value ?? null;
+		}
+	}
+	return resolved;
+}
+
+/**
+ * Compute the set of node IDs that are currently "stale": their last
+ * successful run happened with inputs that no longer match the current
+ * ones, OR an upstream node is stale (so re-running will change this
+ * one's inputs). Walks in topological order so transitive staleness
+ * propagates in a single pass.
+ *
+ * Pattern lifted from `gradio-app/daggr`'s edge-stale derivation.
+ */
+export function computeStaleNodes(
+	nodes: WFNode[],
+	edges: WFEdge[],
+	nodeStatus: Record<string, NodeStatus>,
+	inputSnapshots: Record<string, string>
+): Set<string> {
+	const stale = new Set<string>();
+	const sorted = topoSort(nodes, edges);
+	for (const node of sorted) {
+		if (nodeStatus[node.id] !== "done") continue;
+		const snapshot = inputSnapshots[node.id];
+		if (
+			snapshot &&
+			JSON.stringify(resolveCurrentInputs(node, nodes, edges)) !== snapshot
+		) {
+			stale.add(node.id);
+			continue;
+		}
+		for (const edge of edges) {
+			if (edge.to_node_id === node.id && stale.has(edge.from_node_id)) {
+				stale.add(node.id);
+				break;
+			}
+		}
+	}
+	return stale;
+}
+
+/**
+ * Build a sub-workflow containing `targetId` plus all of its transitive
+ * upstream dependencies. Used by per-node "run this" so we don't execute
+ * unrelated branches. Node IDs are stable, so callbacks from the executor
+ * still target the same status / output maps in the caller.
+ */
+export function buildUpstreamSubgraph(
+	workflow: Workflow,
+	targetId: string
+): Workflow {
+	const include = new Set<string>([targetId]);
+	const queue = [targetId];
+	while (queue.length) {
+		const cur = queue.shift()!;
+		for (const e of workflow.edges) {
+			if (e.to_node_id === cur && !include.has(e.from_node_id)) {
+				include.add(e.from_node_id);
+				queue.push(e.from_node_id);
+			}
+		}
+	}
+	return {
+		...workflow,
+		references: workflow.references.filter((n) => include.has(n.id)),
+		operators: workflow.operators.filter((n) => include.has(n.id)),
+		subjects: workflow.subjects.filter((n) => include.has(n.id)),
+		edges: workflow.edges.filter(
+			(e) => include.has(e.from_node_id) && include.has(e.to_node_id)
+		)
+	};
+}

6.17.1/workflowcanvas/workflow/workflow-migration.ts

@@ -0,0 +1,224 @@
+/**
+ * Schema v1 → v2 migration.
+ *
+ * v1 stored a flat `nodes` array tagged with `kind: "component" | "transform" | …`.
+ * v2 splits that into three role-collections (references / operators / subjects)
+ * so the data model expresses authoring intent, not just data flow. The graph
+ * topology is preserved exactly — edges still reference node ids — but the role
+ * tag drives studio-view rendering and lets future tooling reason about a
+ * workflow without re-deriving roles from edge topology every time.
+ *
+ * The migration is purposely conservative: when in doubt, prefer the role that
+ * keeps existing behavior (e.g. transforms always become operators, components
+ * become references unless they have incoming edges, in which case they're
+ * subjects).
+ */
+
+import type {
+	AnyNode,
+	OperatorKind,
+	OperatorNode,
+	PortType,
+	ReferenceNode,
+	SubjectNode,
+	WFEdge,
+	WFNode,
+	Workflow,
+	WorkflowV1
+} from "./workflow-types";
+
+export function isV2(wf: unknown): wf is Workflow {
+	if (!wf || typeof wf !== "object") return false;
+	const w = wf as Record<string, unknown>;
+	return (
+		w.schema_version === "2" &&
+		Array.isArray(w.references) &&
+		Array.isArray(w.operators) &&
+		Array.isArray(w.subjects) &&
+		Array.isArray(w.edges)
+	);
+}
+
+export function migrateToV2(raw: unknown): Workflow {
+	if (isV2(raw)) return raw;
+
+	const legacy = (raw ?? {}) as WorkflowV1;
+	const legacyNodes: WFNode[] = Array.isArray(legacy.nodes) ? legacy.nodes : [];
+	const edges: WFEdge[] = Array.isArray(legacy.edges) ? legacy.edges : [];
+
+	// Nodes with at least one incoming edge are "consumers" — when promoted from
+	// a v1 component, those become subjects (output tiles); otherwise references.
+	const hasIncoming = new Set<string>();
+	for (const e of edges) hasIncoming.add(e.to_node_id);
+
+	const references: ReferenceNode[] = [];
+	const operators: OperatorNode[] = [];
+	const subjects: SubjectNode[] = [];
+
+	for (const n of legacyNodes) {
+		const base = {
+			id: n.id,
+			label: n.label ?? "",
+			inputs: n.inputs ?? [],
+			outputs: n.outputs ?? [],
+			data: n.data ?? {},
+			x: n.x ?? 0,
+			y: n.y ?? 0,
+			width: n.width ?? 200,
+			height: n.height ?? 100
+		};
+
+		if (n.kind === "transform") {
+			const kind = inferOperatorKind(n);
+			operators.push({
+				...base,
+				role: "operator",
+				kind,
+				source: deriveSourceUri(n, kind),
+				space_id: n.space_id,
+				model_id: n.model_id,
+				dataset_id: n.dataset_id,
+				dataset_config: n.dataset_config,
+				dataset_split: n.dataset_split,
+				endpoint: n.endpoint,
+				pipeline_tag: n.pipeline_tag,
+				provider: n.provider,
+				fn: n.fn,
+				runtime: "client"
+			});
+			continue;
+		}
+
+		// Everything else (component / input / output / unknown) maps to either
+		// reference or subject based on edge topology.
+		const assetType: PortType = (n.outputs?.[0]?.type ??
+			n.inputs?.[0]?.type ??
+			"any") as PortType;
+
+		if (hasIncoming.has(n.id)) {
+			subjects.push({ ...base, role: "subject", asset_type: assetType });
+		} else {
+			references.push({ ...base, role: "reference", asset_type: assetType });
+		}
+	}
+
+	return {
+		schema_version: "2",
+		name: legacy.name ?? "My workflow",
+		runtime: { default: "client" },
+		references,
+		operators,
+		subjects,
+		edges,
+		view: { default: "canvas" }
+	};
+}
+
+function inferOperatorKind(n: WFNode): OperatorKind {
+	if (n.space_id || n.source === "space") return "space";
+	if (n.model_id || n.source === "model") return "model";
+	if (n.dataset_id || n.source === "dataset") return "dataset";
+	return "fn";
+}
+
+function deriveSourceUri(n: WFNode, kind: OperatorKind): string | undefined {
+	if (kind === "space" && n.space_id) return `hf://spaces/${n.space_id}`;
+	if (kind === "model" && n.model_id) return `hf://${n.model_id}`;
+	if (kind === "dataset" && n.dataset_id)
+		return `hf://datasets/${n.dataset_id}`;
+	if (kind === "fn") return n.fn ?? undefined;
+	return undefined;
+}
+
+// ─── Read helpers — keep store consumers from caring about which array a node lives in ─
+
+export function allNodes(wf: Workflow): AnyNode[] {
+	return [...wf.references, ...wf.operators, ...wf.subjects];
+}
+
+export function findNode(wf: Workflow, id: string): AnyNode | undefined {
+	return (
+		wf.references.find((n) => n.id === id) ??
+		wf.operators.find((n) => n.id === id) ??
+		wf.subjects.find((n) => n.id === id)
+	);
+}
+
+// ─── v2 → v1 adapter ────────────────────────────────────────────────────────
+//
+// The executor still reasons about v1 fields (`kind`, `source`, etc.). Rather
+// than rewriting it in the same pass, we expose a one-way projection that
+// reconstructs a v1-shaped node from a v2 node. Cheap, pure, deterministic.
+
+/**
+ * Project a v2 workflow into the legacy v1 shape that executor + any other
+ * still-v1 consumers expect. The migration sets the source identifiers and
+ * derives `kind` from role + edge topology so the v1 contract holds exactly.
+ */
+export function toLegacyShape(wf: Workflow): {
+	version: "1";
+	name: string;
+	nodes: WFNode[];
+	edges: WFEdge[];
+} {
+	const hasIncoming = new Set<string>();
+	for (const e of wf.edges) hasIncoming.add(e.to_node_id);
+
+	const nodes: WFNode[] = [];
+	for (const n of wf.references) {
+		nodes.push({
+			id: n.id,
+			kind: "component",
+			label: n.label,
+			source: "local",
+			inputs: n.inputs,
+			outputs: n.outputs,
+			x: n.x,
+			y: n.y,
+			width: n.width,
+			height: n.height,
+			data: n.data
+		});
+	}
+	for (const n of wf.operators) {
+		nodes.push({
+			id: n.id,
+			kind: "transform",
+			label: n.label,
+			source: n.kind,
+			space_id: n.space_id,
+			model_id: n.model_id,
+			dataset_id: n.dataset_id,
+			dataset_config: n.dataset_config,
+			dataset_split: n.dataset_split,
+			endpoint: n.endpoint,
+			endpoints: n.endpoints,
+			pipeline_tag: n.pipeline_tag,
+			provider: n.provider,
+			fn: n.fn,
+			inputs: n.inputs,
+			outputs: n.outputs,
+			x: n.x,
+			y: n.y,
+			width: n.width,
+			height: n.height,
+			data: n.data
+		});
+	}
+	for (const n of wf.subjects) {
+		nodes.push({
+			id: n.id,
+			kind: "component",
+			label: n.label,
+			source: "local",
+			inputs: n.inputs,
+			outputs: n.outputs,
+			x: n.x,
+			y: n.y,
+			width: n.width,
+			height: n.height,
+			data: n.data
+		});
+	}
+	return { version: "1", name: wf.name, nodes, edges: wf.edges };
+}

6.17.1/workflowcanvas/workflow/workflow-modalities.ts

@@ -0,0 +1,282 @@
+import type { PortType } from "./workflow-types";
+
+export interface SubTab {
+	key: string;
+	label: string;
+	/**
+	 * Used as `pipeline_tag=` on the models API AND as `filter=` on the
+	 * spaces API. For subtabs where Spaces have a category that differs
+	 * from the model pipeline tag (e.g. Edit → `image-editing` Space
+	 * category vs `image-to-image` model pipeline tag), use
+	 * `spaceTags` / `modelTags` to override.
+	 */
+	pipelineTags: string[];
+	/** Override for the spaces API. Falls back to `pipelineTags` when unset. */
+	spaceTags?: string[];
+	/** Override for the models API. Falls back to `pipelineTags` when unset. */
+	modelTags?: string[];
+	/** Freetext query fallback (used when no API tag exists, e.g. Enhance for models). */
+	query?: string;
+}
+
+export interface ModalityConfig {
+	key: string;
+	label: string;
+	category: string;
+	/**
+	 * Canonical port type produced by operators in this modality. Reference and
+	 * subject templates derived from this modality use this type for their port.
+	 * `null` for datasets (outputs are per-feature, no single canonical type).
+	 */
+	port_type: PortType | null;
+	acceptedCategories?: string[];
+	subtabs: SubTab[];
+}
+
+export const DATASET_MODALITY: ModalityConfig = {
+	key: "data",
+	label: "Data",
+	category: "data",
+	port_type: null,
+	subtabs: [{ key: "all", label: "All", pipelineTags: [] }]
+};
+
+export const MODEL_MODALITY: ModalityConfig = {
+	key: "model",
+	label: "Models",
+	category: "model",
+	port_type: null,
+	subtabs: [
+		{ key: "all", label: "All", pipelineTags: [] },
+		{
+			key: "text-to-image",
+			label: "Text→Image",
+			pipelineTags: ["text-to-image"]
+		},
+		{
+			key: "text-generation",
+			label: "Text Gen",
+			pipelineTags: ["text-generation"]
+		},
+		{
+			key: "image-to-text",
+			label: "Image→Text",
+			pipelineTags: ["image-to-text"]
+		},
+		{
+			key: "asr",
+			label: "ASR",
+			pipelineTags: ["automatic-speech-recognition"]
+		},
+		{ key: "tts", label: "TTS", pipelineTags: ["text-to-speech"] },
+		{
+			key: "text-to-video",
+			label: "Text→Video",
+			pipelineTags: ["text-to-video"]
+		},
+		{
+			key: "image-to-image",
+			label: "Image→Image",
+			pipelineTags: ["image-to-image"]
+		},
+		{
+			key: "image-to-video",
+			label: "Image→Video",
+			pipelineTags: ["image-to-video"]
+		}
+	]
+};
+
+export const MODALITIES: ModalityConfig[] = [
+	{
+		key: "image",
+		label: "Image",
+		category: "image",
+		port_type: "image",
+		subtabs: [
+			{ key: "all", label: "All", pipelineTags: [] },
+			{
+				key: "generate",
+				label: "Generate",
+				pipelineTags: ["text-to-image"],
+				spaceTags: ["image-generation"]
+			},
+			{
+				key: "edit",
+				label: "Edit",
+				pipelineTags: ["image-to-image"],
+				spaceTags: ["image-editing"]
+			},
+			{
+				key: "enhance",
+				label: "Enhance",
+				pipelineTags: [],
+				spaceTags: ["image-upscaling"],
+				query: "upscale super resolution restore enhance denoise"
+			},
+			{
+				key: "detect",
+				label: "Detect",
+				pipelineTags: ["object-detection", "image-segmentation"]
+			},
+			{
+				key: "removebg",
+				label: "Remove Background",
+				pipelineTags: [],
+				spaceTags: ["background-removal"],
+				query: "background removal remove background matting"
+			}
+		]
+	},
+	{
+		key: "audio",
+		label: "Audio",
+		category: "audio",
+		port_type: "audio",
+		subtabs: [
+			{ key: "all", label: "All", pipelineTags: [] },
+			{
+				key: "speech",
+				label: "Speech",
+				pipelineTags: ["text-to-speech"],
+				spaceTags: ["speech-synthesis"]
+			},
+			{
+				key: "music",
+				label: "Music",
+				pipelineTags: ["text-to-audio"],
+				spaceTags: ["music-generation"],
+				query: "music generation"
+			},
+			{
+				key: "transcribe",
+				label: "Transcribe",
+				pipelineTags: ["automatic-speech-recognition"],
+				// No matching HF Space category for ASR; freeform query
+				// catches the major transcription Spaces.
+				query: "speech recognition transcription whisper subtitle"
+			},
+			{
+				key: "clone",
+				label: "Clone Voice",
+				pipelineTags: [],
+				spaceTags: ["voice-cloning"],
+				query: "voice clone"
+			}
+		]
+	},
+	{
+		key: "video",
+		label: "Video",
+		category: "video",
+		port_type: "video",
+		subtabs: [
+			{ key: "all", label: "All", pipelineTags: [] },
+			{
+				key: "generate",
+				label: "Generate",
+				pipelineTags: ["text-to-video"],
+				spaceTags: ["video-generation"]
+			},
+			{
+				key: "animate",
+				label: "Animate",
+				pipelineTags: ["image-to-video"],
+				spaceTags: ["character-animation"]
+			}
+		]
+	},
+	{
+		key: "3d",
+		label: "3D",
+		category: "3d",
+		port_type: "model3d",
+		subtabs: [
+			{ key: "all", label: "All", pipelineTags: [] },
+			{
+				key: "from-text",
+				label: "From Text",
+				pipelineTags: ["text-to-3d"],
+				spaceTags: ["3d-modeling"]
+			},
+			{
+				key: "from-image",
+				label: "From Image",
+				pipelineTags: ["image-to-3d"],
+				spaceTags: ["3d-modeling"]
+			}
+		]
+	},
+	{
+		key: "text",
+		label: "Text",
+		category: "text",
+		port_type: "text",
+		acceptedCategories: ["text", "chat"],
+		subtabs: [
+			{ key: "all", label: "All", pipelineTags: [] },
+			{
+				key: "generate",
+				label: "Generate",
+				pipelineTags: ["text-generation"],
+				spaceTags: ["text-generation"]
+			},
+			{
+				key: "summarize",
+				label: "Summarize",
+				pipelineTags: ["summarization"],
+				spaceTags: ["text-summarization"]
+			},
+			{
+				key: "translate",
+				label: "Translate",
+				pipelineTags: ["translation"],
+				spaceTags: ["language-translation"]
+			},
+			{
+				key: "code",
+				label: "Code",
+				pipelineTags: [],
+				spaceTags: ["code-generation"],
+				query: "code generation programming copilot"
+			}
+		]
+	}
+];
+
+/**
+ * Port registry — single source of truth for every user-facing port type.
+ * Drives reference/subject template generation, port labels in the UI, and
+ * modality routing for the compatible-nodes popup. `any` and `file` are
+ * deliberately omitted: they exist only as schema-inference fallbacks and
+ * never appear as user-selectable reference / subject options.
+ */
+export interface PortMeta {
+	port_type: PortType;
+	/** Human label used for reference / subject templates and popup options. */
+	label: string;
+	/** MODALITIES key this port routes to in the picker, if any. */
+	modality_key?: string;
+}
+
+export const PORT_REGISTRY: PortMeta[] = [
+	{ port_type: "image", label: "Image", modality_key: "image" },
+	{ port_type: "audio", label: "Audio", modality_key: "audio" },
+	{ port_type: "video", label: "Video", modality_key: "video" },
+	{ port_type: "model3d", label: "3D", modality_key: "3d" },
+	{ port_type: "text", label: "Text", modality_key: "text" },
+	{ port_type: "number", label: "Number" },
+	{ port_type: "boolean", label: "Toggle" },
+	{ port_type: "json", label: "JSON" },
+	{ port_type: "gallery", label: "Gallery", modality_key: "image" }
+];
+
+export function portMeta(type: PortType): PortMeta | null {
+	return PORT_REGISTRY.find((p) => p.port_type === type) ?? null;
+}
+
+export function modalityForPort(type: PortType): ModalityConfig | null {
+	const meta = portMeta(type);
+	if (!meta?.modality_key) return null;
+	return MODALITIES.find((m) => m.key === meta.modality_key) ?? null;
+}

6.17.1/workflowcanvas/workflow/workflow-store.ts

@@ -0,0 +1,421 @@
+import { writable } from "svelte/store";
+import type {
+	AnyNode,
+	NodeData,
+	NodeDataValue,
+	NodeRole,
+	OperatorKind,
+	OperatorNode,
+	Port,
+	PortType,
+	ReferenceNode,
+	SubjectNode,
+	WFEdge,
+	Workflow
+} from "./workflow-types";
+import { ports_compatible } from "./workflow-types";
+import { allNodes, findNode, isV2, migrateToV2 } from "./workflow-migration";
+
+function uuid(): string {
+	return crypto.randomUUID();
+}
+
+const DEFAULT: Workflow = {
+	schema_version: "2",
+	name: "My workflow",
+	runtime: { default: "client" },
+	references: [
+		{
+			id: "ref_default",
+			role: "reference",
+			label: "Image",
+			asset_type: "image",
+			inputs: [{ id: "in", label: "Image", type: "image" }],
+			outputs: [{ id: "out", label: "Image", type: "image" }],
+			data: {},
+			x: 80,
+			y: 120,
+			width: 200,
+			height: 160
+		}
+	],
+	operators: [],
+	subjects: [],
+	edges: [],
+	view: { default: "canvas" }
+};
+
+// The canonical store of truth for the workflow body is the Python-side
+// `workflow.json` (server function `save_workflow` writes; `initialValue`
+// reads). The frontend store seeds with DEFAULT and is overwritten on mount
+// by the file's contents — see `WorkflowCanvas.svelte` `$effect` reading
+// `initialValue`. No localStorage persistence for the workflow body;
+// `hf_token` and other auth bits persist separately in `hf-auth.svelte.ts`.
+export const workflow = writable<Workflow>(DEFAULT);
+
+// Re-export read helpers so callers import them from one place
+export { allNodes, findNode, isV2, migrateToV2 };
+
+/**
+ * Strip session-bound media (blob: / data: URLs) from node data before
+ * serialising the workflow. blob: URLs die with the page that minted
+ * them, and data: URLs would bloat workflow.json with base64 payloads —
+ * so we drop the field entirely and let the user re-upload on refresh.
+ * Other data (text, numbers, server-served file paths) passes through.
+ */
+function is_session_url(v: unknown): boolean {
+	const url = (v as { url?: string } | null)?.url;
+	return (
+		typeof url === "string" &&
+		(url.startsWith("blob:") || url.startsWith("data:"))
+	);
+}
+
+export function revoke_blob_urls(
+	data: Record<string, unknown> | undefined
+): void {
+	for (const v of Object.values(data ?? {})) {
+		const url = (v as { url?: string } | null)?.url;
+		if (typeof url === "string" && url.startsWith("blob:")) {
+			URL.revokeObjectURL(url);
+		}
+	}
+}
+
+export function sanitize_for_save(wf: Workflow): Workflow {
+	return mapAllRoles(wf, (n) => {
+		if (!n.data) return n;
+		const cleaned: NodeData = {};
+		for (const [k, v] of Object.entries(n.data)) {
+			if (!is_session_url(v)) cleaned[k] = v as NodeDataValue;
+		}
+		return { ...n, data: cleaned };
+	});
+}
+
+// ─── Actions ────────────────────────────────────────────────────────────────
+
+function addReference(
+	template: Omit<ReferenceNode, "id" | "role" | "x" | "y" | "data">,
+	x: number,
+	y: number
+): string {
+	const id = uuid();
+	const data: Record<string, NodeDataValue> = {};
+	for (const port of template.inputs) {
+		if (port.default_value !== undefined) {
+			data[port.id] = port.default_value as NodeDataValue;
+		}
+	}
+	const node: ReferenceNode = {
+		...template,
+		role: "reference",
+		id,
+		x,
+		y,
+		data
+	};
+	workflow.update((wf) => ({ ...wf, references: [...wf.references, node] }));
+	return id;
+}
+
+export function addOperator(
+	template: Omit<OperatorNode, "id" | "role" | "x" | "y" | "data">,
+	x: number,
+	y: number
+): string {
+	const id = uuid();
+	const data: Record<string, NodeDataValue> = {};
+	for (const port of template.inputs) {
+		if (port.default_value !== undefined) {
+			data[port.id] = port.default_value as NodeDataValue;
+		}
+	}
+	const node: OperatorNode = { ...template, role: "operator", id, x, y, data };
+	workflow.update((wf) => ({ ...wf, operators: [...wf.operators, node] }));
+	return id;
+}
+
+function addSubject(
+	template: Omit<SubjectNode, "id" | "role" | "x" | "y" | "data">,
+	x: number,
+	y: number
+): string {
+	const id = uuid();
+	const node: SubjectNode = {
+		...template,
+		role: "subject",
+		id,
+		x,
+		y,
+		data: {}
+	};
+	workflow.update((wf) => ({ ...wf, subjects: [...wf.subjects, node] }));
+	return id;
+}
+
+/**
+ * Single entry point for adding a node. Accepts both v2-shaped templates and
+ * legacy v1-shaped ones (which still come from `node-library.ts` and the
+ * picker) and normalizes missing role-specific fields. Picks the matching
+ * array based on `role`.
+ */
+export function addNode(
+	role: NodeRole,
+	template: any,
+	x: number,
+	y: number
+): string {
+	const baseFields = {
+		label: template.label ?? "",
+		inputs: template.inputs ?? [],
+		outputs: template.outputs ?? [],
+		width: template.width ?? 200,
+		height: template.height ?? 100
+	};
+
+	if (role === "reference") {
+		const asset_type: PortType =
+			template.asset_type ??
+			template.outputs?.[0]?.type ??
+			template.inputs?.[0]?.type ??
+			"any";
+		return addReference({ ...baseFields, asset_type }, x, y);
+	}
+
+	if (role === "operator") {
+		// v1 templates carry `kind: "transform"` + `source: "space" | "model" | ...`
+		// v2 templates carry `kind: OperatorKind` directly. Normalize.
+		const opKind: OperatorKind =
+			template.source === "space" ||
+			template.source === "model" ||
+			template.source === "dataset" ||
+			template.source === "fn"
+				? template.source
+				: template.kind === "space" ||
+					  template.kind === "model" ||
+					  template.kind === "dataset" ||
+					  template.kind === "fn"
+					? template.kind
+					: template.space_id
+						? "space"
+						: template.model_id
+							? "model"
+							: template.dataset_id
+								? "dataset"
+								: "fn";
+		return addOperator(
+			{
+				...baseFields,
+				kind: opKind,
+				source:
+					template.source &&
+					typeof template.source === "string" &&
+					template.source.startsWith("hf://")
+						? template.source
+						: undefined,
+				space_id: template.space_id,
+				model_id: template.model_id,
+				dataset_id: template.dataset_id,
+				dataset_config: template.dataset_config,
+				dataset_split: template.dataset_split,
+				endpoint: template.endpoint,
+				endpoints: template.endpoints,
+				pipeline_tag: template.pipeline_tag,
+				provider: template.provider,
+				fn: template.fn,
+				runtime: template.runtime
+			},
+			x,
+			y
+		);
+	}
+
+	// subject
+	const asset_type: PortType =
+		template.asset_type ??
+		template.inputs?.[0]?.type ??
+		template.outputs?.[0]?.type ??
+		"any";
+	return addSubject({ ...baseFields, asset_type }, x, y);
+}
+
+function mapAllRoles(wf: Workflow, fn: (node: AnyNode) => AnyNode): Workflow {
+	return {
+		...wf,
+		references: wf.references.map((n) => fn(n) as ReferenceNode),
+		operators: wf.operators.map((n) => fn(n) as OperatorNode),
+		subjects: wf.subjects.map((n) => fn(n) as SubjectNode)
+	};
+}
+
+export function moveNode(id: string, x: number, y: number): void {
+	workflow.update((wf) =>
+		mapAllRoles(wf, (n) => (n.id === id ? { ...n, x, y } : n))
+	);
+}
+
+export function resizeNode(id: string, width: number, height: number): void {
+	workflow.update((wf) =>
+		mapAllRoles(wf, (n) => (n.id === id ? { ...n, width, height } : n))
+	);
+}
+
+export function updateNodeData(
+	nodeId: string,
+	portId: string,
+	value: NodeDataValue
+): void {
+	workflow.update((wf) =>
+		mapAllRoles(wf, (n) =>
+			n.id === nodeId ? { ...n, data: { ...n.data, [portId]: value } } : n
+		)
+	);
+}
+
+export function removeNode(id: string): void {
+	workflow.update((wf) => {
+		const node = findNode(wf, id);
+		if (node) revoke_blob_urls(node.data);
+		return {
+			...wf,
+			references: wf.references.filter((n) => n.id !== id),
+			operators: wf.operators.filter((n) => n.id !== id),
+			subjects: wf.subjects.filter((n) => n.id !== id),
+			edges: wf.edges.filter(
+				(e) => e.from_node_id !== id && e.to_node_id !== id
+			)
+		};
+	});
+}
+
+export function addEdge(e: Omit<WFEdge, "id">): void {
+	workflow.update((wf) => ({
+		...wf,
+		edges: [...wf.edges, { ...e, id: uuid() }]
+	}));
+}
+
+export function removeEdge(id: string): void {
+	workflow.update((wf) => ({
+		...wf,
+		edges: wf.edges.filter((e) => e.id !== id)
+	}));
+}
+
+export function hydrate_endpoints(
+	nodeId: string,
+	endpoints: { name: string; inputs: Port[]; outputs: Port[] }[]
+): void {
+	workflow.update((wf) => ({
+		...wf,
+		operators: wf.operators.map((n) =>
+			n.id === nodeId ? { ...n, endpoints } : n
+		)
+	}));
+}
+
+export function switch_endpoint(nodeId: string, endpointName: string): void {
+	workflow.update((wf) => {
+		const node = wf.operators.find((n) => n.id === nodeId);
+		if (!node || !node.endpoints) return wf;
+		const sig = node.endpoints.find((e) => e.name === endpointName);
+		if (!sig || sig.name === node.endpoint) return wf;
+
+		const input_by_id = new Map(sig.inputs.map((p) => [p.id, p]));
+		const output_by_id = new Map(sig.outputs.map((p) => [p.id, p]));
+
+		return {
+			...wf,
+			operators: wf.operators.map((n) =>
+				n.id === nodeId
+					? {
+							...n,
+							endpoint: sig.name,
+							inputs: sig.inputs,
+							outputs: sig.outputs,
+							data: {}
+						}
+					: n
+			),
+			edges: wf.edges.filter((e) => {
+				if (e.from_node_id === nodeId) {
+					const new_port = output_by_id.get(e.from_port_id);
+					if (!new_port) return false;
+					if (!ports_compatible(new_port.type, e.type)) return false;
+				}
+				if (e.to_node_id === nodeId) {
+					const new_port = input_by_id.get(e.to_port_id);
+					if (!new_port) return false;
+					if (!ports_compatible(new_port.type, e.type)) return false;
+				}
+				return true;
+			})
+		};
+	});
+}
+
+/**
+ * Replace an operator's source identity (Space → different Space, Space → Model,
+ * etc.). Clears all source-specific fields before applying the new template so
+ * stale ids can't linger.
+ */
+export function replaceNodeSource(
+	nodeId: string,
+	template: {
+		label?: string;
+		kind?: OperatorKind;
+		source?: string;
+		space_id?: string;
+		model_id?: string;
+		dataset_id?: string;
+		dataset_config?: string;
+		dataset_split?: string;
+		endpoint?: string;
+		pipeline_tag?: string;
+		inputs: Port[];
+		outputs: Port[];
+		width?: number;
+	}
+): void {
+	workflow.update((wf) => ({
+		...wf,
+		operators: wf.operators.map((n) => {
+			if (n.id !== nodeId) return n;
+			const stripped = { ...n } as OperatorNode;
+			delete stripped.space_id;
+			delete stripped.model_id;
+			delete stripped.dataset_id;
+			delete stripped.dataset_config;
+			delete stripped.dataset_split;
+			delete stripped.endpoint;
+			delete stripped.pipeline_tag;
+			delete stripped.source;
+			return {
+				...stripped,
+				...(template.kind && { kind: template.kind }),
+				...(template.source !== undefined && { source: template.source }),
+				...(template.space_id !== undefined && { space_id: template.space_id }),
+				...(template.model_id !== undefined && { model_id: template.model_id }),
+				...(template.dataset_id !== undefined && {
+					dataset_id: template.dataset_id
+				}),
+				...(template.dataset_config !== undefined && {
+					dataset_config: template.dataset_config
+				}),
+				...(template.dataset_split !== undefined && {
+					dataset_split: template.dataset_split
+				}),
+				...(template.endpoint !== undefined && { endpoint: template.endpoint }),
+				...(template.pipeline_tag !== undefined && {
+					pipeline_tag: template.pipeline_tag
+				}),
+				inputs: template.inputs,
+				outputs: template.outputs,
+				label: template.label ?? n.label,
+				width: template.width ?? n.width,
+				data: {}
+			};
+		})
+	}));
+}

6.17.1/workflowcanvas/workflow/workflow-types.ts

@@ -0,0 +1,203 @@
+/**
+ * Port types. The first nine are user-facing and have entries in
+ * `PORT_REGISTRY` (workflow-modalities.ts). `file` and `any` are
+ * inference-only fallbacks emitted by schema introspection when a more
+ * specific type can't be determined — they are never offered as
+ * reference / subject templates and should not appear in pickers.
+ */
+export type PortType =
+	| "image"
+	| "text"
+	| "audio"
+	| "video"
+	| "number"
+	| "boolean"
+	| "file"
+	| "json"
+	| "gallery"
+	| "model3d"
+	| "any";
+
+export function ports_compatible(a: PortType, b: PortType): boolean {
+	return a === "any" || b === "any" || a === b;
+}
+
+export interface Port {
+	id: string;
+	label: string;
+	type: PortType;
+	required?: boolean;
+	default_value?: unknown;
+	output_index?: number;
+}
+
+export interface FileValue {
+	name: string;
+	url: string;
+	mime: string;
+}
+
+export type NodeDataValue = string | number | boolean | FileValue | null;
+export type NodeData = Record<string, NodeDataValue>;
+export type NodeStatus = "idle" | "running" | "done" | "error";
+
+export interface WFNode {
+	id: string;
+	kind: "input" | "transform" | "output" | "component";
+	label: string;
+	source: "local" | "space" | "model" | "dataset" | "fn";
+	space_id?: string;
+	model_id?: string;
+	dataset_id?: string;
+	dataset_config?: string;
+	dataset_split?: string;
+	pipeline_tag?: string;
+	provider?: string;
+	endpoint?: string;
+	endpoints?: EndpointChoice[];
+	fn?: string;
+	inputs: Port[];
+	outputs: Port[];
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+	data: NodeData;
+}
+
+export interface WFEdge {
+	id: string;
+	from_node_id: string;
+	from_port_id: string;
+	to_node_id: string;
+	to_port_id: string;
+	type: PortType;
+}
+
+/**
+ * Legacy v1 workflow shape. Stays here only to make the migration code
+ * (workflow-migration.ts) type-checkable; the live store is v2.
+ */
+export interface WorkflowV1 {
+	version?: "1";
+	name?: string;
+	nodes?: WFNode[];
+	edges?: WFEdge[];
+}
+
+// ─── v2 schema ──────────────────────────────────────────────────────────────
+//
+// The graph is split into three role-collections at the JSON level:
+//   references — inputs you bring in (uploaded files, prompts, literals)
+//   operators  — transformations (spaces / models / datasets / Python fns)
+//   subjects   — the things being created (typed output tiles)
+//
+// All three share BaseNode. The role tag drives visual presentation
+// (studio view) and authoring intent; the data structure stays uniform
+// enough that the executor and canvas can treat them as peer nodes.
+
+export type NodeRole = "reference" | "operator" | "subject";
+
+export type OperatorKind = "space" | "model" | "dataset" | "fn";
+
+export type Runtime = "client" | "server" | "job";
+
+export interface BaseNode {
+	id: string;
+	label: string;
+	inputs: Port[];
+	outputs: Port[];
+	data: NodeData;
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+}
+
+export interface ReferenceNode extends BaseNode {
+	role: "reference";
+	asset_type: PortType;
+	/** Inline literal value, or in a later iteration an `hf://...` URI. */
+	value?: NodeDataValue;
+}
+
+export interface EndpointChoice {
+	name: string;
+	inputs: Port[];
+	outputs: Port[];
+}
+
+export interface OperatorNode extends BaseNode {
+	role: "operator";
+	kind: OperatorKind;
+	/** Canonical hub-native identifier when available (hf://...) or fn name. */
+	source?: string;
+	space_id?: string;
+	model_id?: string;
+	dataset_id?: string;
+	dataset_config?: string;
+	dataset_split?: string;
+	endpoint?: string;
+	endpoints?: EndpointChoice[];
+	pipeline_tag?: string;
+	fn?: string;
+	/** HF Inference provider override (e.g. "hf-inference", "together", "replicate"). Defaults to "auto" — let HF route. */
+	provider?: string;
+	/** Where this operator executes. Default inherited from workflow.runtime.default. */
+	runtime?: Runtime;
+}
+
+export interface SubjectNode extends BaseNode {
+	role: "subject";
+	asset_type: PortType;
+}
+
+export type AnyNode = ReferenceNode | OperatorNode | SubjectNode;
+
+export interface Workflow {
+	schema_version: "2";
+	/** Optional hub repo identifier, e.g. "username/my-workflow". */
+	id?: string;
+	name: string;
+	description?: string;
+	/** Lineage hook — set when a workflow was forked from another. */
+	parent?: string;
+	runtime?: {
+		default: Runtime;
+	};
+	references: ReferenceNode[];
+	operators: OperatorNode[];
+	subjects: SubjectNode[];
+	edges: WFEdge[];
+	view?: {
+		default?: "studio" | "canvas";
+	};
+}
+
+export const PORT_COLOR: Record<PortType, string> = {
+	image: "#4fd1a5",
+	text: "#8b83e8",
+	audio: "#f5a623",
+	video: "#4d9cf5",
+	number: "#e879a8",
+	boolean: "#f59e0b",
+	file: "#94a3b8",
+	json: "#22d3ee",
+	gallery: "#34d399",
+	model3d: "#a78bfa",
+	any: "#6b6e78"
+};
+
+export const PORT_COLOR_DIM: Record<PortType, string> = {
+	image: "rgba(79, 209, 165, 0.15)",
+	text: "rgba(139, 131, 232, 0.15)",
+	audio: "rgba(245, 166, 35, 0.15)",
+	video: "rgba(77, 156, 245, 0.15)",
+	number: "rgba(232, 121, 168, 0.15)",
+	boolean: "rgba(245, 158, 11, 0.15)",
+	file: "rgba(148, 163, 184, 0.15)",
+	json: "rgba(34, 211, 238, 0.15)",
+	gallery: "rgba(52, 211, 153, 0.15)",
+	model3d: "rgba(167, 139, 250, 0.15)",
+	any: "rgba(107, 110, 120, 0.10)"
+};