shaders 3.2.475 → 4.0.0

package/dist/core/Repeater-DU_EhoxD.js

@@ -1,762 +0,0 @@
-import { Ot as unpremultiplyAlpha, at as ZERO, c as p, ct as call, dt as expr, gt as formatFloat$1, ht as Expr, t as defineStd, ti as __export } from "./lower-DtoDQ7hV.js";
-import { i as transformBoolean } from "./transformations-CzFmhZww.js";
-import { n as crosses } from "./slots-BqIef2iV.js";
-var instanceParts_exports = /* @__PURE__ */ __export({
-	accumulateInstances: () => accumulateInstances,
-	formatFloat: () => formatFloat$1,
-	gridPlacement: () => gridPlacement,
-	instanceHueShift: () => instanceHueShift,
-	instanceVariation: () => instanceVariation,
-	linePlacement: () => linePlacement,
-	placementField: () => placementField,
-	radialPlacement: () => radialPlacement,
-	sourceRect: () => sourceRect
-});
-var PI = Math.PI;
-function sourceRect(f, src, crop) {
-	const { p: p$1, L } = f;
-	return [
-		`let ${p$1}_cropL = ${crop.left};`,
-		`let ${p$1}_cropR = ${crop.right};`,
-		`let ${p$1}_cropT = ${crop.top};`,
-		`let ${p$1}_cropB = ${crop.bottom};`,
-		`let ${p$1}_srcCx = (${src.cx}) + (${p$1}_cropL - ${p$1}_cropR) * (${src.hw});`,
-		`let ${p$1}_srcCy = (${src.cy}) + (${p$1}_cropT - ${p$1}_cropB) * (${src.hh});`,
-		`let ${p$1}_srcHw = max((${src.hw}) * (1.0 - ${p$1}_cropL - ${p$1}_cropR), ${L(1e-6)});`,
-		`let ${p$1}_srcHh = max((${src.hh}) * (1.0 - ${p$1}_cropT - ${p$1}_cropB), ${L(1e-6)});`,
-		`let ${p$1}_srcHwSq = ${p$1}_srcHw * ${p$1}_aspect;`,
-		`let ${p$1}_srcHhSq = ${p$1}_srcHh;`
-	];
-}
-function placementField(f, own) {
-	const { p: p$1, L } = f;
-	return [
-		`let ${p$1}_fieldCenterSq = vec2f((${own.cx}) * ${p$1}_aspect, ${own.cy});`,
-		`let ${p$1}_fieldHwSq = max((${own.hw}) * ${p$1}_aspect, ${L(1e-6)});`,
-		`let ${p$1}_fieldHh = max(${own.hh}, ${L(1e-6)});`
-	];
-}
-function gridPlacement(slots, flipMode) {
-	return {
-		requested: () => `(${slots.columns} * ${slots.rows})`,
-		body: (f) => {
-			const { p: p$1, L } = f;
-			const out = [
-				`let ${p$1}_cols = ${slots.columns};`,
-				`let ${p$1}_rows = ${slots.rows};`,
-				`let ${p$1}_col = ${p$1}_j - ${p$1}_cols * floor(${p$1}_j / ${p$1}_cols);`,
-				`let ${p$1}_row = floor(${p$1}_j / ${p$1}_cols);`,
-				`let ${p$1}_gapXSq = ${slots.gapX} * ${p$1}_aspect;`,
-				`let ${p$1}_gapY = ${slots.gapY};`,
-				`let ${p$1}_fieldW = ${p$1}_fieldHwSq * 2.0;`,
-				`let ${p$1}_fieldH = ${p$1}_fieldHh * 2.0;`,
-				`let ${p$1}_pitchX = (${p$1}_fieldW - ${p$1}_gapXSq * (${p$1}_cols - 1.0)) / ${p$1}_cols;`,
-				`let ${p$1}_pitchY = (${p$1}_fieldH - ${p$1}_gapY * (${p$1}_rows - 1.0)) / ${p$1}_rows;`,
-				`let ${p$1}_periodX = ${p$1}_pitchX + ${p$1}_gapXSq;`,
-				`let ${p$1}_periodY = ${p$1}_pitchY + ${p$1}_gapY;`,
-				`${p$1}_cellFitInv = max(${p$1}_srcHwSq * 2.0 / max(${p$1}_pitchX, ${L(1e-5)}), ${p$1}_srcHhSq * 2.0 / max(${p$1}_pitchY, ${L(1e-5)}));`,
-				`let ${p$1}_rowMod2 = ${p$1}_row - 2.0 * floor(${p$1}_row / 2.0);`,
-				`let ${p$1}_staggerOff = ${p$1}_rowMod2 * ${slots.stagger} * ${p$1}_periodX;`,
-				`let ${p$1}_cxArg = ${p$1}_col * ${p$1}_periodX + ${p$1}_staggerOff + ${p$1}_phase * ${p$1}_periodX;`,
-				`let ${p$1}_cxMod = ${p$1}_periodX * ${p$1}_cols;`,
-				`let ${p$1}_cellX = ${p$1}_cxArg - ${p$1}_cxMod * floor(${p$1}_cxArg / ${p$1}_cxMod);`,
-				`let ${p$1}_cyArg = ${p$1}_row * ${p$1}_periodY + ${p$1}_phase * ${p$1}_periodY;`,
-				`let ${p$1}_cyMod = ${p$1}_periodY * ${p$1}_rows;`,
-				`let ${p$1}_cellY = ${p$1}_cyArg - ${p$1}_cyMod * floor(${p$1}_cyArg / ${p$1}_cyMod);`,
-				`${p$1}_pos = vec2f(${p$1}_fieldCenterSq.x - ${p$1}_fieldW * 0.5 + ${p$1}_pitchX * 0.5 + ${p$1}_cellX, ${p$1}_fieldCenterSq.y - ${p$1}_fieldH * 0.5 + ${p$1}_pitchY * 0.5 + ${p$1}_cellY);`
-			];
-			if (flipMode === 1 || flipMode === 3) out.push(`${p$1}_flipX = 1.0 - (${p$1}_col - 2.0 * floor(${p$1}_col / 2.0)) * 2.0;`);
-			if (flipMode === 2 || flipMode === 3) out.push(`${p$1}_flipY = 1.0 - (${p$1}_row - 2.0 * floor(${p$1}_row / 2.0)) * 2.0;`);
-			return out;
-		}
-	};
-}
-function radialPlacement(anchorSq, slots) {
-	return {
-		requested: () => slots.count,
-		body: (f) => {
-			const { p: p$1, L } = f;
-			return [
-				`let ${p$1}_cSq = ${anchorSq};`,
-				`let ${p$1}_sweep = ${slots.sweep} * ${L(PI / 180)};`,
-				`let ${p$1}_start = ${slots.startAngle} * ${L(PI / 180)};`,
-				`let ${p$1}_ang = ${p$1}_start + ${p$1}_sweep * (${p$1}_j / ${p$1}_totalN) + ${p$1}_phase * ${p$1}_sweep;`,
-				`${p$1}_pos = ${p$1}_cSq + vec2f(cos(${p$1}_ang), sin(${p$1}_ang)) * ${slots.radius};`,
-				`${p$1}_layoutRot = select(0.0, ${p$1}_ang + ${L(PI / 2)}, ${slots.faceCenter} > 0.0);`
-			];
-		}
-	};
-}
-function linePlacement(anchorSq, slots) {
-	return {
-		requested: () => slots.count,
-		body: (f) => {
-			const { p: p$1, L } = f;
-			return [
-				`let ${p$1}_cSq = ${anchorSq};`,
-				`let ${p$1}_dirRad = ${slots.direction} * ${L(PI / 180)};`,
-				`let ${p$1}_dir = vec2f(cos(${p$1}_dirRad), sin(${p$1}_dirRad));`,
-				`let ${p$1}_tArg = ${p$1}_j + ${p$1}_phase;`,
-				`let ${p$1}_t = ${p$1}_tArg - ${p$1}_totalN * floor(${p$1}_tArg / ${p$1}_totalN);`,
-				`${p$1}_pos = ${p$1}_cSq + ${p$1}_dir * ${slots.spacing} * ${p$1}_t;`
-			];
-		}
-	};
-}
-function instanceVariation(f, slots) {
-	const { p: p$1, L } = f;
-	const hash = (off) => `fract(sin((${p$1}_hashBase + ${L(off)}) * 78.233) * 43758.5453)`;
-	return [
-		`let ${p$1}_hashBase = ${p$1}_j + ${p$1}_seed * 7.0;`,
-		`let ${p$1}_h1 = ${hash(.123)};`,
-		`let ${p$1}_h2 = ${hash(5.456)};`,
-		`let ${p$1}_h3 = ${hash(9.789)};`,
-		`let ${p$1}_h4 = ${hash(13.21)};`,
-		`let ${p$1}_h5 = ${hash(17.65)};`,
-		`let ${p$1}_scale = max(pow(${slots.scale}, ${p$1}_j) * (1.0 + ${slots.jitterScale} * (${p$1}_h3 - 0.5)), ${L(1e-4)});`,
-		`let ${p$1}_rot = ${p$1}_layoutRot + ${slots.rotation} * ${p$1}_j + ${slots.jitterRotation} * (${p$1}_h4 - 0.5) * ${L(PI * 2)};`,
-		`let ${p$1}_instOpacity = pow(${slots.opacity}, ${p$1}_j) * (1.0 - ${slots.jitterOpacity} * ${p$1}_h5);`,
-		`${p$1}_pos = ${p$1}_pos + vec2f((${p$1}_h1 - 0.5) * ${p$1}_fieldHwSq, (${p$1}_h2 - 0.5) * ${p$1}_fieldHh) * ${slots.jitterPosition};`
-	];
-}
-function instanceHueShift(f, hueShift) {
-	const { p: p$1, L } = f;
-	return [
-		`let ${p$1}_hueAngle = ${hueShift} * ${p$1}_j;`,
-		`let ${p$1}_cosH = cos(${p$1}_hueAngle);`,
-		`let ${p$1}_sinH = sin(${p$1}_hueAngle);`,
-		`let ${p$1}_kOMC = (1.0 - ${p$1}_cosH) * ${L(1 / 3)};`,
-		`let ${p$1}_sOS3 = ${p$1}_sinH / 1.7320508075688772;`,
-		`let ${p$1}_mA = ${p$1}_cosH + ${p$1}_kOMC;`,
-		`let ${p$1}_mB = ${p$1}_kOMC - ${p$1}_sOS3;`,
-		`let ${p$1}_mC = ${p$1}_kOMC + ${p$1}_sOS3;`,
-		`${p$1}_rgb = vec3f(${p$1}_src.r * ${p$1}_mA + ${p$1}_src.g * ${p$1}_mB + ${p$1}_src.b * ${p$1}_mC, ${p$1}_src.r * ${p$1}_mC + ${p$1}_src.g * ${p$1}_mA + ${p$1}_src.b * ${p$1}_mB, ${p$1}_src.r * ${p$1}_mB + ${p$1}_src.g * ${p$1}_mC + ${p$1}_src.b * ${p$1}_mA);`
-	];
-}
-function accumulateInstances(f, slots) {
-	const { p: p$1 } = f;
-	const out = [];
-	out.push(`let ${p$1}_totalN = min(max(${slots.placement.requested()}, 1.0), 64.0);`);
-	out.push(`var ${p$1}_accum = vec4f(0.0, 0.0, 0.0, 0.0);`);
-	out.push(`var ${p$1}_cellFitInv = 1.0;`);
-	const body = [];
-	body.push(`let ${p$1}_fi = f32(${p$1}_i);`);
-	body.push(slots.zBack ? `let ${p$1}_j = ${p$1}_totalN - 1.0 - ${p$1}_fi;` : `let ${p$1}_j = ${p$1}_fi;`);
-	body.push(`var ${p$1}_pos = vec2f(0.0, 0.0);`);
-	body.push(`var ${p$1}_layoutRot = 0.0;`);
-	body.push(`var ${p$1}_flipX = 1.0;`);
-	body.push(`var ${p$1}_flipY = 1.0;`);
-	body.push(...slots.placement.body(f));
-	body.push(...slots.variation);
-	body.push(`let ${p$1}_negRot = -${p$1}_rot;`);
-	body.push(`let ${p$1}_cosA = cos(${p$1}_negRot);`);
-	body.push(`let ${p$1}_sinA = sin(${p$1}_negRot);`);
-	body.push(`let ${p$1}_d0 = ${p$1}_pix - ${p$1}_pos;`);
-	body.push(`let ${p$1}_dr = vec2f(${p$1}_d0.x * ${p$1}_cosA - ${p$1}_d0.y * ${p$1}_sinA, ${p$1}_d0.x * ${p$1}_sinA + ${p$1}_d0.y * ${p$1}_cosA);`);
-	body.push(`let ${p$1}_dl = ${p$1}_dr / ${p$1}_scale;`);
-	body.push(`let ${p$1}_localU = ${p$1}_dl.x * ${p$1}_flipX * ${p$1}_cellFitInv / (${p$1}_srcHwSq * 2.0) + 0.5;`);
-	body.push(`let ${p$1}_localV = ${p$1}_dl.y * ${p$1}_flipY * ${p$1}_cellFitInv / (${p$1}_srcHhSq * 2.0) + 0.5;`);
-	const sample = [];
-	sample.push(`let ${p$1}_sampleUV = vec2f(${p$1}_srcCx - ${p$1}_srcHw + ${p$1}_localU * ${p$1}_srcHw * 2.0, ${p$1}_srcCy - ${p$1}_srcHh + ${p$1}_localV * ${p$1}_srcHh * 2.0);`);
-	sample.push(`let ${p$1}_src = textureSampleLevel(tex.$.${slots.texKey}, samp.$.linearClamp, ${p$1}_sampleUV, 0.0);`);
-	sample.push(`var ${p$1}_rgb = ${p$1}_src.rgb;`);
-	sample.push(...slots.hue);
-	sample.push(`let ${p$1}_a = ${p$1}_src.a * ${p$1}_instOpacity;`);
-	sample.push(`let ${p$1}_premul = ${p$1}_rgb * ${p$1}_a;`);
-	sample.push(`${p$1}_accum = vec4f(${p$1}_premul + ${p$1}_accum.rgb * (1.0 - ${p$1}_a), ${p$1}_a + ${p$1}_accum.a * (1.0 - ${p$1}_a));`);
-	body.push(`if (${p$1}_localU >= 0.0 && ${p$1}_localU <= 1.0 && ${p$1}_localV >= 0.0 && ${p$1}_localV <= 1.0) {`);
-	for (const s of sample) body.push(`  ${s}`);
-	body.push(`}`);
-	out.push(`for (var ${p$1}_i = 0u; ${p$1}_i < u32(${p$1}_totalN); ${p$1}_i++) {`);
-	for (const b of body) out.push(`  ${b}`);
-	out.push(`}`);
-	return out;
-}
-var { formatFloat } = instanceParts_exports;
-const grid = (slots) => ({
-	kind: "grid",
-	slots
-});
-const radial = (slots) => ({
-	kind: "radial",
-	slots
-});
-const line = (slots) => ({
-	kind: "line",
-	slots
-});
-const byMode = (mode, members) => ({
-	mode,
-	members
-});
-var MODE_MAP = {
-	grid: 0,
-	radial: 1,
-	linear: 2
-};
-var FLIP_MAP = {
-	"none": 0,
-	"alternate-flip-x": 1,
-	"alternate-flip-y": 2,
-	"both": 3
-};
-function repeatInstances(recipe) {
-	return (params) => {
-		const { uniforms, childNode, ctx, propValues, childBoundsParams, ownBoundsParams, convertToTexture } = params;
-		if (!childNode) return ZERO;
-		const texKey = convertToTexture(childNode).key;
-		const structural = (ref, map) => {
-			const v = propValues[ref.name];
-			return typeof v === "number" ? v : map[v] ?? 0;
-		};
-		const spec = "members" in recipe.placement ? [
-			recipe.placement.members.grid,
-			recipe.placement.members.radial,
-			recipe.placement.members.linear
-		][structural(recipe.placement.mode, MODE_MAP)] ?? recipe.placement.members.grid : recipe.placement;
-		const zBack = recipe.order ? propValues[recipe.order.name] === "backward" || propValues[recipe.order.name] === 1 : false;
-		const hueActive = recipe.hueShift ? (propValues[recipe.hueShift.name] ?? 0) !== 0 : false;
-		return new Expr((ec) => {
-			const f = {
-				p: ec.freshLocal("rep"),
-				L: formatFloat
-			};
-			const { p: p$1, L } = f;
-			const R = (ref) => {
-				const accessor = uniforms[ref.name];
-				if (!accessor) throw new Error(`std: repeatInstances binds unknown prop '${ref.name}'`);
-				return accessor._emit(ec);
-			};
-			const stmts = [];
-			stmts.push(`let ${p$1}_uv = ${ctx.uv._emit(ec)};`);
-			stmts.push(`let ${p$1}_aspect = ${ctx.aspect._emit(ec)};`);
-			stmts.push(`let ${p$1}_pix = vec2f(${p$1}_uv.x * ${p$1}_aspect, ${p$1}_uv.y);`);
-			const src = {
-				cx: childBoundsParams ? childBoundsParams.centerX._emit(ec) : L(.5),
-				cy: childBoundsParams ? childBoundsParams.centerY._emit(ec) : L(.5),
-				hw: childBoundsParams ? childBoundsParams.halfWidth._emit(ec) : L(.5),
-				hh: childBoundsParams ? childBoundsParams.halfHeight._emit(ec) : L(.5)
-			};
-			stmts.push(...sourceRect(f, src, {
-				left: R(recipe.source.crop.left),
-				right: R(recipe.source.crop.right),
-				top: R(recipe.source.crop.top),
-				bottom: R(recipe.source.crop.bottom)
-			}));
-			stmts.push(...placementField(f, {
-				cx: ownBoundsParams ? ownBoundsParams.centerX._emit(ec) : L(.5),
-				cy: ownBoundsParams ? ownBoundsParams.centerY._emit(ec) : L(.5),
-				hw: ownBoundsParams ? ownBoundsParams.halfWidth._emit(ec) : L(.5),
-				hh: ownBoundsParams ? ownBoundsParams.halfHeight._emit(ec) : L(.5)
-			}));
-			stmts.push(`let ${p$1}_phase = ${R(recipe.variation.phase)};`);
-			stmts.push(`let ${p$1}_seed = ${R(recipe.variation.seed)};`);
-			const anchorSq = childBoundsParams ? `vec2f((${childBoundsParams.centerX._emit(ec)}) * ${p$1}_aspect, ${childBoundsParams.centerY._emit(ec)})` : `${p$1}_fieldCenterSq`;
-			const placement = spec.kind === "grid" ? gridPlacement({
-				columns: R(spec.slots.columns),
-				rows: R(spec.slots.rows),
-				gapX: R(spec.slots.gapX),
-				gapY: R(spec.slots.gapY),
-				stagger: R(spec.slots.stagger)
-			}, structural(spec.slots.flip, FLIP_MAP)) : spec.kind === "radial" ? radialPlacement(anchorSq, {
-				count: R(spec.slots.count),
-				sweep: R(spec.slots.sweep),
-				startAngle: R(spec.slots.startAngle),
-				radius: R(spec.slots.radius),
-				faceCenter: R(spec.slots.faceCenter)
-			}) : linePlacement(anchorSq, {
-				count: R(spec.slots.count),
-				direction: R(spec.slots.direction),
-				spacing: R(spec.slots.spacing)
-			});
-			stmts.push(...accumulateInstances(f, {
-				placement,
-				variation: instanceVariation(f, {
-					scale: R(recipe.variation.scale),
-					rotation: R(recipe.variation.rotation),
-					opacity: R(recipe.variation.opacity),
-					jitterPosition: R(recipe.variation.jitter.position),
-					jitterRotation: R(recipe.variation.jitter.rotation),
-					jitterScale: R(recipe.variation.jitter.scale),
-					jitterOpacity: R(recipe.variation.jitter.opacity)
-				}),
-				hue: hueActive && recipe.hueShift ? instanceHueShift(f, R(recipe.hueShift)) : [],
-				zBack,
-				texKey
-			}));
-			for (const s of stmts) ec.statement(s);
-			return call(unpremultiplyAlpha, "unpremultiplyAlpha", [expr(`${p$1}_accum`)])._emit(ec);
-		});
-	};
-}
-const componentDefinition = defineStd({
-	name: "Repeater",
-	role: "structural",
-	species: "custom",
-	category: "Distortions",
-	description: "Repeat the child content in grid, radial or linear layouts with per-instance variation",
-	requiresRTT: true,
-	requiresChild: true,
-	wantsBoundsParams: true,
-	boundingBoxDeclaration: { aspectRatio: null },
-	props: {
-		mode: {
-			default: "grid",
-			transform: (value) => ({
-				grid: 0,
-				radial: 1,
-				linear: 2
-			})[value] ?? 0,
-			compileTime: true,
-			description: "Layout used to place the repeated instances",
-			ui: {
-				type: "select",
-				options: [
-					{
-						label: "Grid",
-						value: "grid"
-					},
-					{
-						label: "Radial",
-						value: "radial"
-					},
-					{
-						label: "Linear",
-						value: "linear"
-					}
-				],
-				label: "Mode",
-				group: "Layout"
-			}
-		},
-		cropLeft: {
-			default: 0,
-			description: "Crop inset from the left edge of the source element (fraction of its width)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: .49,
-				step: .005,
-				label: "Crop Left",
-				group: "Source"
-			}
-		},
-		cropRight: {
-			default: 0,
-			description: "Crop inset from the right edge of the source element (fraction of its width)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: .49,
-				step: .005,
-				label: "Crop Right",
-				group: "Source"
-			}
-		},
-		cropTop: {
-			default: 0,
-			description: "Crop inset from the top edge of the source element (fraction of its height)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: .49,
-				step: .005,
-				label: "Crop Top",
-				group: "Source"
-			}
-		},
-		cropBottom: {
-			default: 0,
-			description: "Crop inset from the bottom edge of the source element (fraction of its height)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: .49,
-				step: .005,
-				label: "Crop Bottom",
-				group: "Source"
-			}
-		},
-		columns: {
-			default: 3,
-			description: "Number of grid columns",
-			ui: {
-				type: ["range", "map"],
-				min: 1,
-				max: 12,
-				step: 1,
-				label: "Columns",
-				group: "Layout",
-				condition: { mode: "grid" }
-			}
-		},
-		rows: {
-			default: 3,
-			description: "Number of grid rows",
-			ui: {
-				type: ["range", "map"],
-				min: 1,
-				max: 12,
-				step: 1,
-				label: "Rows",
-				group: "Layout",
-				condition: { mode: "grid" }
-			}
-		},
-		gapX: {
-			default: .05,
-			description: "Horizontal gap between grid cells",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: .5,
-				step: .005,
-				label: "Gap X",
-				group: "Layout",
-				condition: { mode: "grid" },
-				dimensional: "canvas-width"
-			}
-		},
-		gapY: {
-			default: .05,
-			description: "Vertical gap between grid cells",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: .5,
-				step: .005,
-				label: "Gap Y",
-				group: "Layout",
-				condition: { mode: "grid" },
-				dimensional: "canvas-height"
-			}
-		},
-		stagger: {
-			default: 0,
-			description: "Horizontal offset applied to every other row (brick layout)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Stagger",
-				group: "Layout",
-				condition: { mode: "grid" }
-			}
-		},
-		flip: {
-			default: "none",
-			transform: (value) => ({
-				"none": 0,
-				"alternate-flip-x": 1,
-				"alternate-flip-y": 2,
-				"both": 3
-			})[value] ?? 0,
-			compileTime: true,
-			description: "Mirror alternating columns/rows for seamless tiling patterns",
-			ui: {
-				type: "select",
-				options: [
-					{
-						label: "None",
-						value: "none"
-					},
-					{
-						label: "Alternate Flip X",
-						value: "alternate-flip-x"
-					},
-					{
-						label: "Alternate Flip Y",
-						value: "alternate-flip-y"
-					},
-					{
-						label: "Both",
-						value: "both"
-					}
-				],
-				label: "Flip",
-				group: "Layout",
-				condition: { mode: "grid" }
-			}
-		},
-		count: {
-			default: 8,
-			description: "Number of repeated instances",
-			ui: {
-				type: ["range", "map"],
-				min: 1,
-				max: 64,
-				step: 1,
-				label: "Count",
-				group: "Layout",
-				condition: { mode: ["radial", "linear"] }
-			}
-		},
-		radius: {
-			default: .3,
-			description: "Orbit radius of the radial layout",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .005,
-				label: "Radius",
-				group: "Layout",
-				condition: { mode: "radial" },
-				dimensional: "canvas-height"
-			}
-		},
-		startAngle: {
-			default: 0,
-			description: "Angle of the first instance on the orbit",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 360,
-				step: 1,
-				label: "Start Angle",
-				group: "Layout",
-				condition: { mode: "radial" }
-			}
-		},
-		sweep: {
-			default: 360,
-			description: "Angular span the instances are distributed across",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 360,
-				step: 1,
-				label: "Sweep",
-				group: "Layout",
-				condition: { mode: "radial" }
-			}
-		},
-		faceCenter: {
-			default: false,
-			transform: transformBoolean,
-			description: "Rotate each instance to face the orbit center",
-			ui: {
-				type: "checkbox",
-				label: "Face Center",
-				group: "Layout",
-				condition: { mode: "radial" }
-			}
-		},
-		direction: {
-			default: 0,
-			description: "Direction of the linear layout in degrees (0 = rightward)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 360,
-				step: 1,
-				label: "Direction",
-				group: "Layout",
-				condition: { mode: "linear" }
-			}
-		},
-		spacing: {
-			default: .2,
-			description: "Distance between consecutive instances",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .005,
-				label: "Spacing",
-				group: "Layout",
-				condition: { mode: "linear" },
-				dimensional: "canvas-height"
-			}
-		},
-		instanceScale: {
-			default: 1,
-			description: "Progressive scale multiplier applied per instance (compounds with each copy)",
-			ui: {
-				type: ["range", "map"],
-				min: .5,
-				max: 2,
-				step: .005,
-				label: "Scale",
-				group: "Instances"
-			}
-		},
-		instanceRotation: {
-			default: 0,
-			transform: (value) => value * Math.PI / 180,
-			description: "Additional rotation in degrees applied per instance (accumulates with each copy)",
-			ui: {
-				type: ["range", "map"],
-				min: -180,
-				max: 180,
-				step: 1,
-				label: "Rotation",
-				group: "Instances"
-			}
-		},
-		instanceOpacity: {
-			default: 1,
-			description: "Progressive opacity falloff applied per instance (compounds with each copy)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .005,
-				label: "Opacity",
-				group: "Instances"
-			}
-		},
-		hueShift: {
-			default: 0,
-			transform: (value) => value * Math.PI / 180,
-			recompile: crosses(0),
-			description: "Hue rotation in degrees added per instance",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 360,
-				step: 1,
-				label: "Hue Shift",
-				group: "Instances"
-			}
-		},
-		phase: {
-			default: 0,
-			description: "Seamless layout animation phase (0-1 wraps to the identical layout)",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .001,
-				label: "Phase",
-				group: "Instances"
-			}
-		},
-		zOrder: {
-			default: "forward",
-			transform: (value) => value === "backward" ? 1 : 0,
-			compileTime: true,
-			description: "Stacking order of overlapping instances",
-			ui: {
-				type: "select",
-				options: [{
-					label: "Forward",
-					value: "forward"
-				}, {
-					label: "Backward",
-					value: "backward"
-				}],
-				label: "Z-Order",
-				group: "Instances"
-			}
-		},
-		jitterPosition: {
-			default: 0,
-			description: "Random per-instance position offset",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .005,
-				label: "Position",
-				group: "Jitter"
-			}
-		},
-		jitterRotation: {
-			default: 0,
-			description: "Random per-instance rotation",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .005,
-				label: "Rotation",
-				group: "Jitter"
-			}
-		},
-		jitterScale: {
-			default: 0,
-			description: "Random per-instance scale variation",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .005,
-				label: "Scale",
-				group: "Jitter"
-			}
-		},
-		jitterOpacity: {
-			default: 0,
-			description: "Random per-instance opacity variation",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 1,
-				step: .005,
-				label: "Opacity",
-				group: "Jitter"
-			}
-		},
-		seed: {
-			default: 0,
-			description: "Random seed for the jitter values",
-			ui: {
-				type: ["range", "map"],
-				min: 0,
-				max: 100,
-				step: 1,
-				label: "Seed",
-				group: "Jitter"
-			}
-		}
-	},
-	gpu: { fragment: repeatInstances({
-		source: { crop: {
-			left: p("cropLeft"),
-			right: p("cropRight"),
-			top: p("cropTop"),
-			bottom: p("cropBottom")
-		} },
-		placement: byMode(p("mode"), {
-			grid: grid({
-				columns: p("columns"),
-				rows: p("rows"),
-				gapX: p("gapX"),
-				gapY: p("gapY"),
-				stagger: p("stagger"),
-				flip: p("flip")
-			}),
-			radial: radial({
-				count: p("count"),
-				radius: p("radius"),
-				startAngle: p("startAngle"),
-				sweep: p("sweep"),
-				faceCenter: p("faceCenter")
-			}),
-			linear: line({
-				count: p("count"),
-				direction: p("direction"),
-				spacing: p("spacing")
-			})
-		}),
-		variation: {
-			scale: p("instanceScale"),
-			rotation: p("instanceRotation"),
-			opacity: p("instanceOpacity"),
-			jitter: {
-				position: p("jitterPosition"),
-				rotation: p("jitterRotation"),
-				scale: p("jitterScale"),
-				opacity: p("jitterOpacity")
-			},
-			seed: p("seed"),
-			phase: p("phase")
-		},
-		hueShift: p("hueShift"),
-		order: p("zOrder")
-	}) }
-});
-var Repeater_default = componentDefinition;
-export { componentDefinition as n, Repeater_default as t };