shaders 3.0.448 → 3.0.449

package/dist/core/porters-DBK1Aipq.js

@@ -0,0 +1,991 @@
+import { $t as vec2f, B as labToRgb, Et as max, I as convertMixSpaceToP3, J as oklchToOklab, L as convertP3ToMixSpaceCPU, P as MixStep, R as hslToRgb, Ut as arrayOf, V as lchToLab, Vt as data_exports, W as mixPreconvertedInSpace, X as sRGBToP3, _t as clamp, an as f32, cn as __export, et as src_default, g as expr, in as vec4f, nn as vec3f, nt as std_exports, on as i32, p as call, q as oklabToRgb, y as vec4, z as hsvToRgb } from "./edges-BXNBKxSN.js";
+import { a as transformColor, c as transformPosition, n as setColorSpaceMode, o as transformColorSpace, u as Color } from "./transformations-CsPUHppB.js";
+var colorStops_exports = /* @__PURE__ */ __export({
+	MAX_COLOR_STOPS: () => 8,
+	colorStopsPropConfig: () => colorStopsPropConfig$1,
+	colorStopsTransform: () => colorStopsTransform$1,
+	gradientStopsInSpace: () => gradientStopsInSpace,
+	mixColorStops: () => mixColorStops,
+	mixColorStopsRuntime: () => mixColorStopsRuntime,
+	packConvertedStops: () => packConvertedStops,
+	packStops: () => packStops,
+	resolveStops: () => resolveStops$1,
+	sortStops: () => sortStops$1
+});
+const MAX_COLOR_STOPS = 8;
+const colorStopsTransform$1 = (value) => value;
+function sortStops$1(stops) {
+	return stops.map((stop, index) => ({
+		stop,
+		index
+	})).sort((a, b) => a.stop.position - b.stop.position || a.index - b.index).map(({ stop }) => stop);
+}
+function resolveStops$1(props) {
+	if (Array.isArray(props.stops) && props.stops.length > 0) return sortStops$1(props.stops);
+	return [{
+		color: props.colorA ?? "#1aff00",
+		position: 0
+	}, {
+		color: props.colorB ?? "#0000ff",
+		position: 1
+	}];
+}
+function packStops(stops, toRGBA) {
+	const colors = new Array(32).fill(0);
+	const positions = new Array(8).fill(0);
+	const sorted = Array.isArray(stops) && stops.length > 0 ? sortStops$1(stops) : [];
+	const n = Math.min(sorted.length, 8);
+	for (let i = 0; i < n; i++) {
+		const c = toRGBA(sorted[i].color);
+		colors[i * 4] = c[0];
+		colors[i * 4 + 1] = c[1];
+		colors[i * 4 + 2] = c[2];
+		colors[i * 4 + 3] = c[3];
+		positions[i] = sorted[i].position;
+	}
+	return {
+		colors,
+		positions,
+		stopCount: n
+	};
+}
+function packConvertedStops(colors, stopCount, colorSpaceMode) {
+	const out = new Array(24).fill(0);
+	for (let i = 0; i < stopCount; i++) {
+		const c = convertP3ToMixSpaceCPU(colors[i * 4], colors[i * 4 + 1], colors[i * 4 + 2], colorSpaceMode);
+		out[i * 3] = c[0];
+		out[i * 3 + 1] = c[1];
+		out[i * 3 + 2] = c[2];
+	}
+	return out;
+}
+var initStep = src_default.fn([vec3f, f32], MixStep)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((conv, alpha) => {
+	"use gpu";
+	return MixStep({
+		conv,
+		alpha
+	});
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "conv"
+		}, {
+			"type": "i",
+			"name": "alpha"
+		}],
+		"body": [0, [[10, [
+			6,
+			"MixStep",
+			[[104, {
+				"conv": "conv",
+				"alpha": "alpha"
+			}]]
+		]]]],
+		"externalNames": ["MixStep"]
+	},
+	externals: () => ({ MixStep })
+}) && $.f)({}));
+var gradientSegmentStep = src_default.fn([
+	MixStep,
+	vec3f,
+	f32,
+	f32,
+	f32,
+	f32
+], MixStep)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((running, convI, alphaI, tClamped, posA, posB) => {
+	"use gpu";
+	const seg = clamp(__tsover_div(__tsover_sub(tClamped, posA), max(__tsover_sub(posB, posA), 1e-6)), 0, 1);
+	return mixPreconvertedInSpace(running.conv, running.alpha, convI, alphaI, seg);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "running"
+			},
+			{
+				"type": "i",
+				"name": "convI"
+			},
+			{
+				"type": "i",
+				"name": "alphaI"
+			},
+			{
+				"type": "i",
+				"name": "tClamped"
+			},
+			{
+				"type": "i",
+				"name": "posA"
+			},
+			{
+				"type": "i",
+				"name": "posB"
+			}
+		],
+		"body": [0, [[
+			13,
+			"seg",
+			[
+				6,
+				[
+					7,
+					"std",
+					"clamp"
+				],
+				[
+					[
+						1,
+						[
+							1,
+							"tClamped",
+							"-",
+							"posA"
+						],
+						"/",
+						[
+							6,
+							[
+								7,
+								"std",
+								"max"
+							],
+							[[
+								1,
+								"posB",
+								"-",
+								"posA"
+							], [5, "0.000001"]]
+						]
+					],
+					[5, "0"],
+					[5, "1"]
+				]
+			]
+		], [10, [
+			6,
+			"mixPreconvertedInSpace",
+			[
+				[
+					7,
+					"running",
+					"conv"
+				],
+				[
+					7,
+					"running",
+					"alpha"
+				],
+				"convI",
+				"alphaI",
+				"seg"
+			]
+		]]]],
+		"externalNames": ["std", "mixPreconvertedInSpace"]
+	},
+	externals: () => ({
+		std: std_exports,
+		mixPreconvertedInSpace
+	})
+}) && $.f)({}));
+var stepConv = src_default.fn([MixStep], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s) => {
+	"use gpu";
+	return s.conv;
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "s"
+		}],
+		"body": [0, [[10, [
+			7,
+			"s",
+			"conv"
+		]]]],
+		"externalNames": []
+	},
+	externals: () => ({})
+}) && $.f)({}));
+var stepAlpha = src_default.fn([MixStep], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s) => {
+	"use gpu";
+	return s.alpha;
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "s"
+		}],
+		"body": [0, [[10, [
+			7,
+			"s",
+			"alpha"
+		]]]],
+		"externalNames": []
+	},
+	externals: () => ({})
+}) && $.f)({}));
+var packRGBA = src_default.fn([vec3f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, a) => {
+	"use gpu";
+	return vec4f(rgb, a);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "rgb"
+		}, {
+			"type": "i",
+			"name": "a"
+		}],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"d",
+				"vec4f"
+			],
+			["rgb", "a"]
+		]]]],
+		"externalNames": ["d"]
+	},
+	externals: () => ({ d: data_exports })
+}) && $.f)({}));
+function mixColorStops(stopCount, colorSpaceMode, t, stops) {
+	if (stopCount <= 1) return null;
+	const tClamped = clamp(t, 0, 1);
+	let step = initStep(stops.convAt(0), stops.alphaAt(0));
+	for (let i = 1; i < stopCount; i++) step = gradientSegmentStep(step, stops.convAt(i), stops.alphaAt(i), tClamped, stops.positionAt(i - 1), stops.positionAt(i));
+	return packRGBA(convertMixSpaceToP3(stepConv(step), colorSpaceMode), stepAlpha(step));
+}
+const gradientStopsInSpace = src_default.fn([
+	f32,
+	arrayOf(vec4f, 8),
+	arrayOf(vec4f, 8 / 4),
+	arrayOf(vec3f, 8),
+	f32
+], MixStep)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, colors, positions, converted, stopCount) => {
+	"use gpu";
+	const clampedT = clamp(t, 0, 1);
+	const n = i32(stopCount);
+	const c0 = converted[0];
+	let conv = vec3f(c0.x, c0.y, c0.z);
+	let alpha = colors[0].w;
+	for (let i = 1; i < n; i++) {
+		const va = positions[__tsover_sub(i, 1) >> 2];
+		const vb = positions[i >> 2];
+		const posA = va[__tsover_sub(i, 1) & 3];
+		const posB = vb[i & 3];
+		const seg = clamp(__tsover_div(__tsover_sub(clampedT, posA), max(__tsover_sub(posB, posA), 1e-6)), 0, 1);
+		const step = mixPreconvertedInSpace(conv, alpha, converted[i], colors[i].w, seg);
+		conv = vec3f(step.conv.x, step.conv.y, step.conv.z);
+		alpha = step.alpha;
+	}
+	return MixStep({
+		conv,
+		alpha
+	});
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "t"
+			},
+			{
+				"type": "i",
+				"name": "colors"
+			},
+			{
+				"type": "i",
+				"name": "positions"
+			},
+			{
+				"type": "i",
+				"name": "converted"
+			},
+			{
+				"type": "i",
+				"name": "stopCount"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"clampedT",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						"t",
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"n",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					["stopCount"]
+				]
+			],
+			[
+				13,
+				"c0",
+				[
+					8,
+					"converted",
+					[5, "0"]
+				]
+			],
+			[
+				12,
+				"conv",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec3f"
+					],
+					[
+						[
+							7,
+							"c0",
+							"x"
+						],
+						[
+							7,
+							"c0",
+							"y"
+						],
+						[
+							7,
+							"c0",
+							"z"
+						]
+					]
+				]
+			],
+			[
+				12,
+				"alpha",
+				[
+					7,
+					[
+						8,
+						"colors",
+						[5, "0"]
+					],
+					"w"
+				]
+			],
+			[
+				14,
+				[
+					12,
+					"i",
+					[5, "1"]
+				],
+				[
+					1,
+					"i",
+					"<",
+					"n"
+				],
+				[
+					102,
+					"++",
+					"i"
+				],
+				[0, [
+					[
+						13,
+						"va",
+						[
+							8,
+							"positions",
+							[
+								1,
+								[
+									1,
+									"i",
+									"-",
+									[5, "1"]
+								],
+								">>",
+								[5, "2"]
+							]
+						]
+					],
+					[
+						13,
+						"vb",
+						[
+							8,
+							"positions",
+							[
+								1,
+								"i",
+								">>",
+								[5, "2"]
+							]
+						]
+					],
+					[
+						13,
+						"posA",
+						[
+							8,
+							"va",
+							[
+								1,
+								[
+									1,
+									"i",
+									"-",
+									[5, "1"]
+								],
+								"&",
+								[5, "3"]
+							]
+						]
+					],
+					[
+						13,
+						"posB",
+						[
+							8,
+							"vb",
+							[
+								1,
+								"i",
+								"&",
+								[5, "3"]
+							]
+						]
+					],
+					[
+						13,
+						"seg",
+						[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								[
+									1,
+									[
+										1,
+										"clampedT",
+										"-",
+										"posA"
+									],
+									"/",
+									[
+										6,
+										[
+											7,
+											"std",
+											"max"
+										],
+										[[
+											1,
+											"posB",
+											"-",
+											"posA"
+										], [5, "0.000001"]]
+									]
+								],
+								[5, "0"],
+								[5, "1"]
+							]
+						]
+					],
+					[
+						13,
+						"step",
+						[
+							6,
+							"mixPreconvertedInSpace",
+							[
+								"conv",
+								"alpha",
+								[
+									8,
+									"converted",
+									"i"
+								],
+								[
+									7,
+									[
+										8,
+										"colors",
+										"i"
+									],
+									"w"
+								],
+								"seg"
+							]
+						]
+					],
+					[
+						2,
+						"conv",
+						"=",
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							[
+								[
+									7,
+									[
+										7,
+										"step",
+										"conv"
+									],
+									"x"
+								],
+								[
+									7,
+									[
+										7,
+										"step",
+										"conv"
+									],
+									"y"
+								],
+								[
+									7,
+									[
+										7,
+										"step",
+										"conv"
+									],
+									"z"
+								]
+							]
+						]
+					],
+					[
+						2,
+						"alpha",
+						"=",
+						[
+							7,
+							"step",
+							"alpha"
+						]
+					]
+				]]
+			],
+			[10, [
+				6,
+				"MixStep",
+				[[104, {
+					"conv": "conv",
+					"alpha": "alpha"
+				}]]
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"d",
+			"mixPreconvertedInSpace",
+			"MixStep"
+		]
+	},
+	externals: () => ({
+		std: std_exports,
+		d: data_exports,
+		mixPreconvertedInSpace,
+		MixStep
+	})
+}) && $.f)({}));
+function backConvertToP3(conv, colorSpaceMode) {
+	switch (colorSpaceMode) {
+		case 1: return call(sRGBToP3, "sRGBToP3", [call(oklabToRgb, "oklabToRgb", [call(oklchToOklab, "oklchToOklab", [conv])])]);
+		case 2: return call(sRGBToP3, "sRGBToP3", [call(oklabToRgb, "oklabToRgb", [conv])]);
+		case 3: return call(sRGBToP3, "sRGBToP3", [call(hslToRgb, "hslToRgb", [conv])]);
+		case 4: return call(sRGBToP3, "sRGBToP3", [call(hsvToRgb, "hsvToRgb", [conv])]);
+		case 5: return call(sRGBToP3, "sRGBToP3", [call(labToRgb, "labToRgb", [call(lchToLab, "lchToLab", [conv])])]);
+		default: return conv;
+	}
+}
+function mixColorStopsRuntime(t, uniforms, colorSpaceMode) {
+	const acc = call(gradientStopsInSpace, "gradientStopsInSpace", [
+		t,
+		uniforms.colorsArray,
+		uniforms.positionsArray,
+		uniforms.convertedColorsArray,
+		uniforms.stopCount
+	]);
+	return vec4(backConvertToP3(acc.member("conv"), colorSpaceMode), acc.member("alpha"));
+}
+function colorStopsPropConfig$1() {
+	return {
+		default: null,
+		transform: colorStopsTransform$1,
+		compileTimeWhen: (previousValue, newValue) => {
+			const effective = (v) => {
+				const n = Array.isArray(v) ? v.length : 0;
+				return n > 1 ? n : 0;
+			};
+			return effective(previousValue) !== effective(newValue);
+		},
+		description: "Multi-stop gradient colors (overrides Color A / Color B when set)",
+		ui: {
+			type: "gradient-stops",
+			label: "Colors",
+			group: "Colors"
+		}
+	};
+}
+const MAX_COLOR_STOPS$1 = 8;
+const colorStopsTransform = (value) => value;
+function sortStops(stops) {
+	return stops.map((stop, index) => ({
+		stop,
+		index
+	})).sort((a, b) => a.stop.position - b.stop.position || a.index - b.index).map(({ stop }) => stop);
+}
+function resolveStops(props) {
+	if (Array.isArray(props.stops) && props.stops.length > 0) return sortStops(props.stops);
+	return [{
+		color: props.colorA ?? "#1aff00",
+		position: 0
+	}, {
+		color: props.colorB ?? "#0000ff",
+		position: 1
+	}];
+}
+function colorStopsPropConfig() {
+	return {
+		default: null,
+		transform: colorStopsTransform,
+		compileTimeWhen: (previousValue, newValue) => {
+			const effective = (v) => {
+				const n = Array.isArray(v) ? v.length : 0;
+				return n > 1 ? n : 0;
+			};
+			return effective(previousValue) !== effective(newValue);
+		},
+		description: "Multi-stop gradient colors (overrides Color A / Color B when set)",
+		ui: {
+			type: "gradient-stops",
+			label: "Colors",
+			group: "Colors"
+		}
+	};
+}
+var gpuColorSpaceMode = "p3-linear";
+function setColorSpaceModeGpu(mode) {
+	gpuColorSpaceMode = mode;
+	try {
+		setColorSpaceMode(mode);
+	} catch {}
+}
+function parseColorChannelsGpu(value) {
+	try {
+		const parsed = new Color(value);
+		const targetSpace = gpuColorSpaceMode === "srgb" ? "srgb-linear" : "p3-linear";
+		const coords = parsed.to(targetSpace).coords;
+		const alpha = Number(parsed.alpha);
+		return {
+			r: Number.isFinite(coords?.[0]) ? coords[0] : 0,
+			g: Number.isFinite(coords?.[1]) ? coords[1] : 0,
+			b: Number.isFinite(coords?.[2]) ? coords[2] : 0,
+			a: Number.isFinite(alpha) ? alpha : 1
+		};
+	} catch {
+		return {
+			r: 0,
+			g: 0,
+			b: 0,
+			a: 0
+		};
+	}
+}
+function transformColorGpu(value) {
+	const { r, g, b, a } = parseColorChannelsGpu(value);
+	return vec4f(r, g, b, a);
+}
+function colorToRGBA(value) {
+	const c = transformColorGpu(value);
+	return [
+		c.x,
+		c.y,
+		c.z,
+		c.w
+	];
+}
+function parsePositionAxis(val, isVertical) {
+	if (typeof val === "number") return val;
+	if (typeof val === "object" && val !== null) return val.value;
+	const str = val.toLowerCase().trim();
+	if (isVertical) {
+		if (str === "top") return 0;
+		if (str === "bottom") return 1;
+		if (str === "center") return .5;
+	} else {
+		if (str === "left") return 0;
+		if (str === "right") return 1;
+		if (str === "center") return .5;
+	}
+	console.warn(`Invalid position value: ${val}. Defaulting to center.`);
+	return .5;
+}
+function transformPositionGpu(value) {
+	let x = .5;
+	let y = .5;
+	if (typeof value === "string") {
+		const parts = value.toLowerCase().trim().split(/\s+/);
+		if (parts.includes("left")) x = 0;
+		else if (parts.includes("right")) x = 1;
+		else if (parts.includes("center") || parts.length === 1 && (parts[0] === "top" || parts[0] === "bottom")) x = .5;
+		if (parts.includes("top")) y = 0;
+		else if (parts.includes("bottom")) y = 1;
+		else if (parts.includes("center") || parts.length === 1 && (parts[0] === "left" || parts[0] === "right")) y = .5;
+		if (parts.length === 1 && parts[0] === "center") {
+			x = .5;
+			y = .5;
+		}
+	} else if (typeof value === "object" && value !== null) {
+		x = parsePositionAxis(value.x, false);
+		y = parsePositionAxis(value.y, true);
+	} else console.warn(`Invalid position value provided: ${value}. Defaulting to center.`);
+	return vec2f(x, 1 - y);
+}
+function gpuTransformFor(propTransform) {
+	if (!propTransform) return void 0;
+	if (propTransform === transformColor) return transformColorGpu;
+	if (propTransform === transformPosition) return transformPositionGpu;
+	if (propTransform === colorStopsTransform) return colorStopsTransform;
+	return propTransform;
+}
+function setShaderCanvasDimensions(width, height) {
+	if (width > 0);
+	if (height > 0);
+}
+function isDimensionalValue(v) {
+	return v != null && typeof v === "object" && typeof v.value === "number" && (v.unit === "px" || v.unit === "uv");
+}
+function buildExtraSizeProps(props) {
+	if (!props) return void 0;
+	let out;
+	for (const [name, cfg] of Object.entries(props)) {
+		const d = cfg?.ui?.dimensional;
+		if (d === "canvas-height" || d === "half-canvas-height" || d === "canvas-width" || d === "count-canvas-height") (out ??= /* @__PURE__ */ new Map()).set(name, d);
+	}
+	return out;
+}
+function buildDimensionalPlan(decl, extraSizeProps) {
+	const pb = decl?.propBindings;
+	const positionProps = /* @__PURE__ */ new Set();
+	const sizeProps = /* @__PURE__ */ new Map();
+	if (pb) for (const axis of [
+		"x",
+		"y",
+		"width",
+		"height"
+	]) {
+		const b = pb[axis];
+		if (!b) continue;
+		if (b.as === "position-x" || b.as === "position-y") positionProps.add(b.prop);
+		else if (b.as === "canvas-height" || b.as === "half-canvas-height") sizeProps.set(b.prop, b.as);
+	}
+	if (extraSizeProps) for (const [prop, conv] of extraSizeProps) sizeProps.set(prop, conv);
+	return positionProps.size > 0 || sizeProps.size > 0 ? {
+		positionProps,
+		sizeProps
+	} : null;
+}
+var resolveOriginEdges = (origin) => ({
+	ox: origin.includes("left") ? "start" : origin.includes("right") ? "end" : "center",
+	oy: origin.includes("top") ? "start" : origin.includes("bottom") ? "end" : "center"
+});
+var resolveOriginCenter = (anchorUV, edge, he) => edge === "start" ? anchorUV + he : edge === "end" ? anchorUV - he : anchorUV;
+function bindingSizePx(binding, v, width, height) {
+	const toPx = (val, dim) => isDimensionalValue(val) ? val.unit === "px" ? val.value : val.value * dim : typeof val === "number" ? val * dim : 0;
+	if (binding.as === "canvas-height") return toPx(v, height);
+	if (binding.as === "half-canvas-height") return toPx(v, 2 * height);
+	if (binding.as === "canvas-width") return toPx(v, width);
+	return 0;
+}
+function boxHalfExtentsUV(decl, props, width, height) {
+	if (decl?.computeBounds) {
+		const b = decl.computeBounds(props, width, height);
+		return {
+			hwx: width > 0 ? b.widthPx / width / 2 : 0,
+			hhy: height > 0 ? b.heightPx / height / 2 : 0
+		};
+	}
+	const pb = decl?.propBindings;
+	let hwx = 0, hhy = 0;
+	if (pb?.width && width > 0) hwx = bindingSizePx(pb.width, props[pb.width.prop], width, height) / (2 * width);
+	if (pb?.height && height > 0) hhy = bindingSizePx(pb.height, props[pb.height.prop], width, height) / (2 * height);
+	return {
+		hwx,
+		hhy
+	};
+}
+function resolvePositionAxis(v, dim, edge, he) {
+	let anchorUV;
+	if (isDimensionalValue(v)) if (v.unit === "px") {
+		const gap = dim > 0 ? v.value / dim : 0;
+		anchorUV = edge === "end" ? 1 - gap : edge === "center" ? .5 + gap : gap;
+	} else anchorUV = v.value;
+	else if (typeof v === "number") anchorUV = v;
+	else return v;
+	return resolveOriginCenter(anchorUV, edge, he);
+}
+function resolveSize(v, conversion, width, height) {
+	if (v.unit !== "px") return v.value;
+	if (conversion === "canvas-width") return width > 0 ? v.value / width : v.value;
+	if (height <= 0) return v.value;
+	if (conversion === "count-canvas-height") return v.value > 0 ? height / v.value : v.value;
+	return conversion === "canvas-height" ? v.value / height : v.value / (2 * height);
+}
+function resolveDimensionalProp(decl, propName, rawValue, origin, width, height, extraSizeProps, he) {
+	const plan = buildDimensionalPlan(decl, extraSizeProps);
+	if (!plan) return rawValue;
+	const { ox, oy } = resolveOriginEdges(origin);
+	if (plan.positionProps.has(propName)) {
+		if (!rawValue || typeof rawValue !== "object") return rawValue;
+		return {
+			...rawValue,
+			x: resolvePositionAxis(rawValue.x, width, ox, he?.hwx ?? 0),
+			y: resolvePositionAxis(rawValue.y, height, oy, he?.hhy ?? 0)
+		};
+	}
+	const conversion = plan.sizeProps.get(propName);
+	if (conversion && isDimensionalValue(rawValue)) return resolveSize(rawValue, conversion, width, height);
+	return rawValue;
+}
+function isDimensionalProp(decl, propName, extraSizeProps) {
+	const plan = buildDimensionalPlan(decl, extraSizeProps);
+	if (!plan) return false;
+	return plan.positionProps.has(propName) || plan.sizeProps.has(propName);
+}
+function createGpuUniformsMap(definition, reactiveProps, _instanceId) {
+	const uniformsMap = {};
+	const decl = definition.boundingBoxDeclaration;
+	const extraSizeProps = buildExtraSizeProps(definition.props);
+	const activeColorSpaceMode = resolveColorSpaceMode(definition.props, reactiveProps);
+	for (const [propName, propConfig] of Object.entries(definition.props)) {
+		const transform = propConfig.transform;
+		if (transform === colorStopsTransform) {
+			expandColorStops(uniformsMap, propName, propConfig, reactiveProps[propName], activeColorSpaceMode);
+			continue;
+		}
+		const rawValue = reactiveProps[propName];
+		let value = rawValue;
+		if (value === null || value === void 0) value = propConfig.default;
+		if (value === null || value === void 0) {
+			console.error(`[Shaders] Uniform "${propName}" is null/undefined after fallback. PropConfig:`, {
+				propName,
+				initialValue: rawValue,
+				default: propConfig.default,
+				hasTransform: !!transform
+			});
+			value = 0;
+		}
+		const gpuTransform = gpuTransformFor(transform);
+		const isDim = isDimensionalProp(decl, propName, extraSizeProps);
+		const cpu = !gpuTransform && !isDim && (typeof value === "string" || typeof value === "object" && value !== null && !Array.isArray(value));
+		uniformsMap[propName] = {
+			value,
+			transform: gpuTransform,
+			compileTime: propConfig.compileTime || false,
+			...propConfig.compileTimeWhen ? {
+				compileTimeWhen: propConfig.compileTimeWhen,
+				_lastCompiledValue: rawValue ?? propConfig.default
+			} : {},
+			...isDim ? { _rawDimensional: rawValue } : {},
+			...cpu ? { cpu: true } : {}
+		};
+	}
+	return uniformsMap;
+}
+function resolveColorSpaceMode(props, reactiveProps) {
+	for (const [name, cfg] of Object.entries(props)) if (cfg.transform === transformColorSpace) {
+		const raw = reactiveProps[name] ?? cfg.default;
+		return typeof raw === "string" ? transformColorSpace(raw) : 0;
+	}
+	return 0;
+}
+function expandColorStops(uniformsMap, propName, propConfig, rawValue, colorSpaceMode) {
+	const stops = rawValue ?? null;
+	const packed = packStops(stops, colorToRGBA);
+	const converted = packConvertedStops(packed.colors, packed.stopCount, colorSpaceMode);
+	uniformsMap[propName] = {
+		value: stops,
+		transform: colorStopsTransform,
+		cpu: true,
+		compileTime: propConfig.compileTime || false,
+		...propConfig.compileTimeWhen ? {
+			compileTimeWhen: propConfig.compileTimeWhen,
+			_lastCompiledValue: stops ?? propConfig.default
+		} : {}
+	};
+	uniformsMap.colorsArray = {
+		value: packed.colors,
+		schema: arrayOf(vec4f, 8)
+	};
+	uniformsMap.positionsArray = {
+		value: packed.positions,
+		schema: arrayOf(vec4f, 8 / 4)
+	};
+	uniformsMap.convertedColorsArray = {
+		value: converted,
+		schema: arrayOf(vec3f, 8)
+	};
+	uniformsMap.stopCount = {
+		value: packed.stopCount,
+		schema: f32
+	};
+}
+const rootPassthrough = {
+	name: "Root",
+	props: {},
+	fragment: ({ childNode }) => childNode ?? expr("vec4f(0.0, 0.0, 0.0, 0.0)")
+};
+function animatedTime(params, seedName, fieldName = "_animTime") {
+	const base = params.props.member(fieldName);
+	if (seedName) {
+		const seed = params.uniforms[seedName];
+		if (seed) return base.add(seed);
+	}
+	return base;
+}
+export { packConvertedStops as C, mixColorStopsRuntime as S, resolveStops as _, boxHalfExtentsUV as a, colorStops_exports as b, isDimensionalProp as c, setShaderCanvasDimensions as d, colorToRGBA as f, colorStopsTransform as g, colorStopsPropConfig as h, bindingSizePx as i, isDimensionalValue as l, MAX_COLOR_STOPS$1 as m, rootPassthrough as n, buildDimensionalPlan as o, setColorSpaceModeGpu as p, createGpuUniformsMap as r, buildExtraSizeProps as s, animatedTime as t, resolveDimensionalProp as u, sortStops as v, packStops as w, gradientStopsInSpace as x, MAX_COLOR_STOPS as y };