@actis/core 26.3.0 → 26.9.0

package/dist/index.mjs

@@ -1,122 +1,554 @@
+import { bindFramebufferInfo, createBufferInfoFromArrays, createFramebufferInfo, createProgramInfo, drawBufferInfo, resizeFramebufferInfo, setBuffersAndAttributes, setTextureFilteringForSize, setTextureParameters, setUniforms } from "twgl.js";
+//#region src/engine/FrameDriver.ts
+/**
+* Main-thread driver backed by `requestAnimationFrame`. Safe to construct
+* during SSR or in workers: scheduling becomes a no-op when rAF is missing.
+*/
+function rafFrameDriver() {
+	let id = -1;
+	return {
+		request(callback) {
+			if (typeof requestAnimationFrame === "undefined") return;
+			id = requestAnimationFrame(callback);
+		},
+		cancel() {
+			if (id === -1 || typeof cancelAnimationFrame === "undefined") {
+				id = -1;
+				return;
+			}
+			cancelAnimationFrame(id);
+			id = -1;
+		}
+	};
+}
+/**
+* Host-agnostic driver backed by a timer. Used inside workers, where
+* `requestAnimationFrame` is unavailable.
+*/
+function timerFrameDriver(intervalMs = 1e3 / 60) {
+	let id = -1;
+	return {
+		request(callback) {
+			if (typeof setTimeout === "undefined") return;
+			id = setTimeout(() => {
+				id = -1;
+				callback(typeof performance !== "undefined" ? performance.now() : Date.now());
+			}, intervalMs);
+		},
+		cancel() {
+			if (id === -1 || typeof clearTimeout === "undefined") {
+				id = -1;
+				return;
+			}
+			clearTimeout(id);
+			id = -1;
+		}
+	};
+}
+//#endregion
+//#region src/context/ContextCapabilities.ts
+function isWebGL2Context(gl) {
+	return typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext || typeof gl.texStorage2D === "function";
+}
+function detectGLContextCapabilities(gl) {
+	const isWebGL2 = isWebGL2Context(gl);
+	return Object.freeze({
+		isWebGL2,
+		supportsFloatTexture: isWebGL2 || gl.getExtension("OES_texture_float") !== null,
+		supportsFloatColorBuffer: isWebGL2 ? gl.getExtension("EXT_color_buffer_float") !== null : gl.getExtension("WEBGL_color_buffer_float") !== null,
+		supportsFloatTextureLinear: gl.getExtension("OES_texture_float_linear") !== null
+	});
+}
+//#endregion
+//#region src/fbo/FramebufferAttachmentSupport.ts
+function resolveFramebufferAttachmentOptions(gl, capabilities, options) {
+	if (!isFloatFramebufferAttachment(gl, options)) return { ...options };
+	const nextOptions = { ...options };
+	if (capabilities.isWebGL2 && nextOptions.internalFormat === void 0 && (nextOptions.format === void 0 || nextOptions.format === gl.RGBA)) nextOptions.internalFormat = gl.RGBA32F;
+	if (nextOptions.min === void 0 && nextOptions.mag === void 0 && nextOptions.minMag === void 0) {
+		nextOptions.min = gl.NEAREST;
+		nextOptions.mag = gl.NEAREST;
+	}
+	if (nextOptions.wrap === void 0 && nextOptions.wrapS === void 0 && nextOptions.wrapT === void 0) {
+		nextOptions.wrapS = gl.CLAMP_TO_EDGE;
+		nextOptions.wrapT = gl.CLAMP_TO_EDGE;
+	}
+	return nextOptions;
+}
+function assertFramebufferAttachmentSupport(gl, capabilities, options) {
+	if (!isFloatFramebufferAttachment(gl, options)) return;
+	if (!capabilities.supportsFloatTexture) throw new Error("OES_texture_float not supported");
+	if (!capabilities.supportsFloatColorBuffer) throw new Error(capabilities.isWebGL2 ? "EXT_color_buffer_float not supported" : "WEBGL_color_buffer_float not supported");
+	if (usesLinearFiltering(gl, options) && !capabilities.supportsFloatTextureLinear) throw new Error("OES_texture_float_linear not supported");
+}
+function isFloatFramebufferAttachment(gl, options) {
+	return options.attachment === void 0 && options.type === gl.FLOAT && options.samples === void 0;
+}
+function usesLinearFiltering(gl, options) {
+	return isLinearFilter(gl, options.min) || isLinearFilter(gl, options.mag) || isLinearFilter(gl, options.minMag);
+}
+function isLinearFilter(gl, filter) {
+	return filter === gl.LINEAR || filter === gl.LINEAR_MIPMAP_NEAREST || filter === gl.NEAREST_MIPMAP_LINEAR || filter === gl.LINEAR_MIPMAP_LINEAR;
+}
+//#endregion
+//#region src/fbo/FBO.ts
+/**
+* Wrapper around a WebGL framebuffer and its color attachment texture.
+*/
+var FBO = class {
+	constructor(gl, capabilities, width, height, texture) {
+		this.gl = gl;
+		this.capabilities = capabilities;
+		this.width = width;
+		this.height = height;
+		this.texture = texture;
+		this.framebufferInfo = this.create(width, height);
+	}
+	create(width, height) {
+		const attachmentOptions = this.getAttachmentOptions();
+		this.ensureAttachmentSupport(attachmentOptions);
+		const framebufferInfo = createFramebufferInfo(this.gl, [attachmentOptions], width, height);
+		this.assertFramebufferComplete(framebufferInfo);
+		this.clear(framebufferInfo);
+		this.texture.setHandle(framebufferInfo.attachments[0]);
+		this.texture.generateMipmap(this.gl, width, height);
+		return framebufferInfo;
+	}
+	get info() {
+		return this.framebufferInfo;
+	}
+	bind() {
+		bindFramebufferInfo(this.gl, this.framebufferInfo);
+	}
+	resize(width, height) {
+		this.width = width;
+		this.height = height;
+		const attachmentOptions = this.getAttachmentOptions();
+		this.ensureAttachmentSupport(attachmentOptions);
+		resizeFramebufferInfo(this.gl, this.framebufferInfo, [attachmentOptions], width, height);
+		this.assertFramebufferComplete(this.framebufferInfo);
+		this.texture.setHandle(this.framebufferInfo.attachments[0]);
+		this.clear();
+		this.texture.generateMipmap(this.gl, width, height);
+	}
+	clear(framebufferInfo = this.framebufferInfo) {
+		bindFramebufferInfo(this.gl, framebufferInfo);
+		this.gl.clearColor(0, 0, 0, 0);
+		this.gl.clear(this.gl.COLOR_BUFFER_BIT);
+		bindFramebufferInfo(this.gl, null);
+	}
+	getAttachmentOptions() {
+		return this.texture.getFramebufferAttachmentOptions(this.gl);
+	}
+	ensureAttachmentSupport(attachmentOptions) {
+		assertFramebufferAttachmentSupport(this.gl, this.capabilities, attachmentOptions);
+	}
+	assertFramebufferComplete(framebufferInfo) {
+		bindFramebufferInfo(this.gl, framebufferInfo);
+		const status = this.gl.checkFramebufferStatus(this.gl.FRAMEBUFFER);
+		bindFramebufferInfo(this.gl, null);
+		if (status !== this.gl.FRAMEBUFFER_COMPLETE) throw new Error(`FBO incomplete: 0x${status.toString(16)}`);
+	}
+};
+//#endregion
+//#region src/texture/TextureParameters.ts
+function getTextureFramebufferAttachmentOptions(gl, capabilities, options) {
+	const { auto, generateMipmaps, mag, magFilter, min, minFilter, minMag, wrap, wrapS, wrapT, ...rest } = options;
+	const resolvedMag = resolveTextureFilter(gl, mag ?? magFilter);
+	const resolvedMin = resolveTextureFilter(gl, min ?? minFilter);
+	const resolvedMinMag = resolveTextureFilter(gl, minMag);
+	const resolvedWrap = resolveTextureWrap(gl, wrap);
+	const resolvedWrapS = resolveTextureWrap(gl, wrapS);
+	const resolvedWrapT = resolveTextureWrap(gl, wrapT);
+	const shouldDefaultToFloatType = rest.type === void 0 && rest.attachment === void 0 && rest.internalFormat === void 0 && (rest.format === void 0 || rest.format === gl.RGBA);
+	return resolveFramebufferAttachmentOptions(gl, capabilities, {
+		...rest,
+		auto: auto ?? generateMipmaps,
+		...shouldDefaultToFloatType && { type: gl.FLOAT },
+		...resolvedMag !== void 0 && { mag: resolvedMag },
+		...resolvedMin !== void 0 && { min: resolvedMin },
+		...resolvedMinMag !== void 0 && { minMag: resolvedMinMag },
+		...resolvedWrap !== void 0 && { wrap: resolvedWrap },
+		...resolvedWrapS !== void 0 && { wrapS: resolvedWrapS },
+		...resolvedWrapT !== void 0 && { wrapT: resolvedWrapT }
+	});
+}
+function shouldUpdateTextureFiltering(options) {
+	return (options.auto ?? options.generateMipmaps) === true;
+}
+function resolveTextureFilter(gl, filter) {
+	if (filter === void 0) return void 0;
+	if (typeof filter === "number") return filter;
+	return {
+		"nearest": gl.NEAREST,
+		"linear": gl.LINEAR,
+		"nearest-mipmap-nearest": gl.NEAREST_MIPMAP_NEAREST,
+		"linear-mipmap-nearest": gl.LINEAR_MIPMAP_NEAREST,
+		"nearest-mipmap-linear": gl.NEAREST_MIPMAP_LINEAR,
+		"linear-mipmap-linear": gl.LINEAR_MIPMAP_LINEAR
+	}[filter] ?? gl.LINEAR;
+}
+function resolveTextureWrap(gl, wrap) {
+	if (wrap === void 0) return void 0;
+	if (typeof wrap === "number") return wrap;
+	return {
+		"repeat": gl.REPEAT,
+		"mirrored-repeat": gl.MIRRORED_REPEAT,
+		"clamp-to-edge": gl.CLAMP_TO_EDGE
+	}[wrap] ?? gl.CLAMP_TO_EDGE;
+}
+//#endregion
+//#region src/texture/Texture.ts
+/**
+* Minimal named wrapper around a WebGL texture handle.
+* Used internally for pass outputs and texture bindings.
+*/
+var Texture = class {
+	constructor(name, options = {}, handle, capabilities) {
+		this.name = name;
+		this.capabilities = capabilities;
+		this.options = Object.freeze({ ...options });
+		this.handleValue = handle;
+	}
+	get handle() {
+		return this.handleValue;
+	}
+	applyParameters(gl) {
+		if (!this.handleValue) return;
+		setTextureParameters(gl, this.handleValue, this.getFramebufferAttachmentOptions(gl));
+	}
+	generateMipmap(gl, width, height) {
+		if (!this.handleValue || !shouldUpdateTextureFiltering(this.options)) return false;
+		const options = this.getFramebufferAttachmentOptions(gl);
+		setTextureFilteringForSize(gl, this.handleValue, options, width, height, options.internalFormat ?? options.format ?? gl.RGBA);
+		return true;
+	}
+	getFramebufferAttachmentOptions(gl) {
+		return getTextureFramebufferAttachmentOptions(gl, this.getCapabilities(gl), this.options);
+	}
+	setHandle(handle) {
+		this.handleValue = handle;
+		return this;
+	}
+	getCapabilities(gl) {
+		if (!this.capabilities) this.capabilities = detectGLContextCapabilities(gl);
+		return this.capabilities;
+	}
+};
+//#endregion
 //#region src/pass/Pass.ts
 /**
 * Represents a render pass in the WebGL pipeline.
-* Responsible for managing framebuffer, texture, and draw calls for a single pass.
 */
 var Pass = class {
-	constructor(gl, shader, width, height, offscreen = true, textures = []) {
+	constructor(gl, capabilities, shader, geometry, width, height, offscreen = true, textures = [], pingPong = false, textureOptions = {}) {
 		this.gl = gl;
 		this.shader = shader;
+		this.bufferInfo = geometry;
 		this.width = width;
 		this.height = height;
-		this.texture = this.createTexture();
-		this.framebuffer = this.createFramebuffer(this.texture);
-		this.next = null;
 		this.offscreen = offscreen;
+		this.pingPong = offscreen && pingPong;
 		this.textures = textures;
-		this.positionAttributeLocation = this.shader.getAttribLocation("a_position");
-		this.positionBuffer = this.createPositionBuffer();
+		this.fbos = [];
+		this.readBufferIndex = 0;
+		if (this.offscreen) {
+			const framebufferCount = this.pingPong ? 2 : 1;
+			for (let index = 0; index < framebufferCount; index++) this.fbos.push(new FBO(gl, capabilities, width, height, new Texture(shader.passName, textureOptions, void 0, capabilities)));
+		}
+	}
+	get fbo() {
+		return this.readFBO;
+	}
+	get texture() {
+		return this.readFBO?.texture;
 	}
 	use() {
 		this.shader.use();
-		if (this.offscreen) {
-			this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, this.framebuffer);
-			this.gl.viewport(0, 0, this.width, this.height);
-		} else {
-			this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, null);
+		if (this.offscreen && this.writeFBO) this.writeFBO.bind();
+		else {
+			bindFramebufferInfo(this.gl, null);
 			this.gl.viewport(0, 0, this.gl.canvas.width, this.gl.canvas.height);
 		}
 	}
 	resize(width, height) {
 		this.width = width;
 		this.height = height;
-		if (this.offscreen) {
-			this.texture = this.createTexture();
-			this.framebuffer = this.createFramebuffer(this.texture);
-		}
+		if (this.offscreen) this.fbos.forEach((fbo) => fbo.resize(width, height));
 	}
 	draw() {
-		const positions = new Float32Array([
-			-1,
-			-1,
-			1,
-			-1,
-			-1,
-			1,
-			-1,
-			1,
-			1,
-			-1,
-			1,
-			1
-		]);
-		this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.positionBuffer);
-		this.gl.bufferData(this.gl.ARRAY_BUFFER, positions, this.gl.STATIC_DRAW);
-		this.gl.enableVertexAttribArray(this.positionAttributeLocation);
-		this.gl.vertexAttribPointer(this.positionAttributeLocation, 2, this.gl.FLOAT, false, 0, 0);
-		this.textures.forEach((texture, index) => {
-			this.gl.activeTexture(this.gl.TEXTURE0 + index);
-			this.gl.bindTexture(this.gl.TEXTURE_2D, texture);
-			this.shader.setUniform(`u_texture${index}`, "1i", index);
+		setBuffersAndAttributes(this.gl, this.shader.programInfo, this.bufferInfo);
+		drawBufferInfo(this.gl, this.bufferInfo);
+		if (this.pingPong) this.swap();
+		this.texture?.generateMipmap(this.gl, this.width, this.height);
+	}
+	clear() {
+		this.readBufferIndex = 0;
+		this.fbos.forEach((fbo) => fbo.clear());
+	}
+	get readFBO() {
+		return this.fbos[this.readBufferIndex] ?? null;
+	}
+	get writeFBO() {
+		if (!this.offscreen) return null;
+		if (!this.pingPong) return this.readFBO;
+		return this.fbos[(this.readBufferIndex + 1) % this.fbos.length] ?? null;
+	}
+	swap() {
+		this.readBufferIndex = (this.readBufferIndex + 1) % this.fbos.length;
+	}
+};
+//#endregion
+//#region src/pipeline/graph/KahnPipelineSorter.ts
+var KahnPipelineSorter = class {
+	sort(registry) {
+		const entries = registry.getAll();
+		const graph = this.buildGraph(entries, registry);
+		return this.topoSort(entries, graph, registry);
+	}
+	buildGraph(entries, registry) {
+		const inDegree = /* @__PURE__ */ new Map();
+		const adjacency = /* @__PURE__ */ new Map();
+		for (const entry of entries) {
+			inDegree.set(entry.name, 0);
+			adjacency.set(entry.name, []);
+		}
+		for (const entry of entries) for (const dep of entry.dependencies) {
+			if (!registry.has(dep)) throw new Error(`Pass "${entry.name}" depends on "${dep}", which is not registered`);
+			adjacency.get(dep).push(entry.name);
+			inDegree.set(entry.name, inDegree.get(entry.name) + 1);
+		}
+		return {
+			inDegree,
+			adjacency
+		};
+	}
+	topoSort(entries, { inDegree, adjacency }, registry) {
+		const queue = entries.filter((entry) => inDegree.get(entry.name) === 0).map((entry) => entry.name);
+		const ordered = [];
+		while (queue.length > 0) {
+			const name = queue.shift();
+			const entry = registry.get(name);
+			if (entry === void 0) throw new Error(`Internal error: pass "${name}" is referenced in the graph but missing from the registry`);
+			ordered.push(entry.pass);
+			for (const dependent of adjacency.get(name) ?? []) {
+				const nextDegree = inDegree.get(dependent) - 1;
+				inDegree.set(dependent, nextDegree);
+				if (nextDegree === 0) queue.push(dependent);
+			}
+		}
+		if (ordered.length !== entries.length) {
+			const cyclic = entries.map((entry) => entry.name).filter((name) => (inDegree.get(name) ?? 0) > 0);
+			throw new Error(`Pipeline contains a cyclic dependency among: ${cyclic.join(", ")}`);
+		}
+		return ordered;
+	}
+};
+//#endregion
+//#region src/pipeline/graph/PipelineGraph.ts
+var PipelineGraph = class {
+	constructor() {
+		this.entries = /* @__PURE__ */ new Map();
+	}
+	add(entry) {
+		if (this.entries.has(entry.name)) throw new Error(`Pass "${entry.name}" is already registered`);
+		this.entries.set(entry.name, {
+			...entry,
+			dependencies: [...entry.dependencies]
 		});
-		this.gl.drawArrays(this.gl.TRIANGLES, 0, positions.length / 2);
-	}
-	createTexture() {
-		const texture = this.gl.createTexture();
-		this.gl.bindTexture(this.gl.TEXTURE_2D, texture);
-		this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_S, this.gl.CLAMP_TO_EDGE);
-		this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_T, this.gl.CLAMP_TO_EDGE);
-		this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MIN_FILTER, this.gl.NEAREST);
-		this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MAG_FILTER, this.gl.NEAREST);
-		this.gl.texImage2D(this.gl.TEXTURE_2D, 0, this.gl.RGBA, this.width, this.height, 0, this.gl.RGBA, this.gl.UNSIGNED_BYTE, null);
-		return texture;
-	}
-	createFramebuffer(texture) {
-		const framebuffer = this.gl.createFramebuffer();
-		this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, framebuffer);
-		this.gl.framebufferTexture2D(this.gl.FRAMEBUFFER, this.gl.COLOR_ATTACHMENT0, this.gl.TEXTURE_2D, texture, 0);
-		this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, null);
-		return framebuffer;
-	}
-	createPositionBuffer() {
-		const buffer = this.gl.createBuffer();
-		this.gl.bindBuffer(this.gl.ARRAY_BUFFER, buffer);
-		return buffer;
+	}
+	clear() {
+		this.entries.clear();
+	}
+	get(name) {
+		const entry = this.entries.get(name);
+		if (entry === void 0) return void 0;
+		return {
+			...entry,
+			dependencies: [...entry.dependencies]
+		};
+	}
+	getAll() {
+		return [...this.entries.values()];
+	}
+	has(name) {
+		return this.entries.has(name);
+	}
+};
+//#endregion
+//#region src/pipeline/Pipeline.ts
+/**
+* Orchestrates pass storage and dependency resolution for the render graph
+*/
+var Pipeline = class {
+	constructor(registry = new PipelineGraph(), sorter = new KahnPipelineSorter()) {
+		this.registry = registry;
+		this.sorter = sorter;
+		this.orderedPasses = [];
+		this.dirty = false;
+	}
+	add(name, pass, dependencies = []) {
+		const sanitizedDependencies = dependencies.filter((dependency) => {
+			if (dependency !== name) return true;
+			if (pass.pingPong) return false;
+			throw new Error(`Pass "${name}" samples itself and requires pingPong to read the previous frame`);
+		});
+		this.registry.add({
+			name,
+			pass,
+			dependencies: sanitizedDependencies
+		});
+		this.dirty = true;
+	}
+	clear() {
+		this.registry.clear();
+		this.orderedPasses = [];
+		this.dirty = false;
+	}
+	resize(width, height) {
+		this.forEach((pass) => {
+			pass.resize(width, height);
+		});
+	}
+	forEach(callback) {
+		for (const pass of this.getOrderedPasses()) callback(pass);
+	}
+	get(name) {
+		return this.registry.get(name)?.pass;
+	}
+	toArray() {
+		return [...this.getOrderedPasses()];
+	}
+	getOrderedPasses() {
+		if (this.dirty) {
+			this.orderedPasses = this.sorter.sort(this.registry);
+			this.dirty = false;
+		}
+		return this.orderedPasses;
+	}
+};
+//#endregion
+//#region src/pipeline/PipelineCompiler.ts
+var PipelineCompiler = class {
+	compile(config) {
+		if (config.passes.length === 0) return { passes: [] };
+		const plannedPasses = config.passes.map((passConfig) => this.planPassConfig(passConfig));
+		const canvasPassName = this.resolveCanvasPassName(plannedPasses);
+		return { passes: plannedPasses.map((passConfig) => this.resolveRenderTarget(passConfig, canvasPassName)) };
+	}
+	planPassConfig(passConfig) {
+		const textures = [...passConfig.textures];
+		return {
+			...passConfig,
+			textures,
+			dependencies: [...new Set(textures.filter((textureName) => textureName !== "" && textureName !== passConfig.name))],
+			pingPong: textures.includes(passConfig.name) || Boolean(passConfig.pingPong)
+		};
+	}
+	resolveCanvasPassName(passConfigs) {
+		const passConfigsByName = new Map(passConfigs.map((passConfig) => [passConfig.name, passConfig]));
+		const declarationIndexByName = new Map(passConfigs.map((passConfig, index) => [passConfig.name, index]));
+		const dependentsByName = new Map(passConfigs.map((passConfig) => [passConfig.name, []]));
+		for (const passConfig of passConfigs) for (const dependency of passConfig.dependencies) {
+			const dependents = dependentsByName.get(dependency);
+			if (!dependents || !passConfigsByName.has(dependency)) throw new Error(`Pass "${passConfig.name}" depends on "${dependency}", which is not registered`);
+			dependents.push(passConfig.name);
+		}
+		const canvasPasses = passConfigs.filter((passConfig) => (dependentsByName.get(passConfig.name)?.length ?? 0) === 0).map((passConfig) => passConfig.name);
+		if (canvasPasses.length === 0) throw new Error("Pipeline must contain at least one terminal pass that can be presented to the canvas.");
+		if (canvasPasses.length === 1) return canvasPasses[0];
+		const upstreamMemo = /* @__PURE__ */ new Map();
+		const depthMemo = /* @__PURE__ */ new Map();
+		return canvasPasses.map((name) => ({
+			name,
+			score: this.scoreCanvasPass(name, declarationIndexByName.get(name), passConfigsByName, upstreamMemo, depthMemo)
+		})).sort((left, right) => this.compareCanvasPassScore(right.score, left.score))[0].name;
+	}
+	resolveRenderTarget(passConfig, canvasPassName) {
+		const presentToCanvas = passConfig.name === canvasPassName;
+		const offscreen = !presentToCanvas || passConfig.pingPong;
+		return {
+			...passConfig,
+			offscreen,
+			presentToCanvas
+		};
+	}
+	scoreCanvasPass(passName, declarationIndex, passConfigsByName, upstreamMemo, depthMemo) {
+		return {
+			upstreamCount: this.collectUpstreamPasses(passName, passConfigsByName, /* @__PURE__ */ new Set(), upstreamMemo).size,
+			depth: this.computeDependencyDepth(passName, passConfigsByName, /* @__PURE__ */ new Set(), depthMemo),
+			declarationIndex
+		};
+	}
+	collectUpstreamPasses(passName, passConfigsByName, visiting, memo) {
+		const memoized = memo.get(passName);
+		if (memoized) return memoized;
+		const passConfig = passConfigsByName.get(passName);
+		if (!passConfig) throw new Error(`Pass "${passName}" is not registered`);
+		if (visiting.has(passName)) throw new Error(`Pipeline contains a cyclic dependency involving "${passName}"`);
+		visiting.add(passName);
+		const upstreamPasses = /* @__PURE__ */ new Set();
+		for (const dependency of passConfig.dependencies) {
+			upstreamPasses.add(dependency);
+			for (const ancestor of this.collectUpstreamPasses(dependency, passConfigsByName, visiting, memo)) upstreamPasses.add(ancestor);
+		}
+		visiting.delete(passName);
+		memo.set(passName, upstreamPasses);
+		return upstreamPasses;
+	}
+	computeDependencyDepth(passName, passConfigsByName, visiting, memo) {
+		const memoized = memo.get(passName);
+		if (memoized !== void 0) return memoized;
+		const passConfig = passConfigsByName.get(passName);
+		if (!passConfig) throw new Error(`Pass "${passName}" is not registered`);
+		if (visiting.has(passName)) throw new Error(`Pipeline contains a cyclic dependency involving "${passName}"`);
+		visiting.add(passName);
+		let depth = 0;
+		for (const dependency of passConfig.dependencies) depth = Math.max(depth, 1 + this.computeDependencyDepth(dependency, passConfigsByName, visiting, memo));
+		visiting.delete(passName);
+		memo.set(passName, depth);
+		return depth;
+	}
+	compareCanvasPassScore(left, right) {
+		if (left.upstreamCount !== right.upstreamCount) return left.upstreamCount - right.upstreamCount;
+		if (left.depth !== right.depth) return left.depth - right.depth;
+		return left.declarationIndex - right.declarationIndex;
 	}
 };
 //#endregion
 //#region src/shader/Shader.ts
 const ERROR_LOG_REGEX = /ERROR: 0:(\d+): (.*)(?=\n|$)/;
+const GLSL_300_ES_REGEX = /^\s*#version\s+300\s+es\b/m;
+const DEFAULT_VERTEX_SHADER_GLSL100 = `
+      attribute vec4 a_position;
+      void main() {
+        gl_Position = a_position;
+      }`;
+const DEFAULT_VERTEX_SHADER_GLSL300ES = `#version 300 es
+in vec4 a_position;
+void main() {
+  gl_Position = a_position;
+}`;
 /**
-* Compiles and manages a WebGL shader program.
+* Compiles and manages a WebGL shader program using twgl.js.
 * Responsible for compiling, linking, and providing access to uniforms and attributes.
 */
 var Shader = class {
-	constructor(gl, vertexSource, fragmentSource, onError, passName) {
+	constructor(gl, capabilities, vertexSource, fragmentSource, onError, passName) {
+		this.capabilities = capabilities;
 		this.gl = gl;
 		this.onError = onError;
 		this.passName = passName;
-		this.uniformLocations = /* @__PURE__ */ new Map();
-		const vertexShader = this.compileShader(vertexSource || this.defaultVertexShader(), gl.VERTEX_SHADER);
-		const fragmentShader = this.compileShader(fragmentSource, gl.FRAGMENT_SHADER);
-		this.program = this.linkProgram(vertexShader, fragmentShader);
-	}
-	compileShader(source, type) {
-		const shader = this.gl.createShader(type);
-		if (!shader) throw new Error("Failed to create shader");
-		this.gl.shaderSource(shader, source);
-		this.gl.compileShader(shader);
-		if (!this.gl.getShaderParameter(shader, this.gl.COMPILE_STATUS)) {
-			const log = this.gl.getShaderInfoLog(shader);
-			this.gl.deleteShader(shader);
-			const coords = this.extractErrorCoords(log || "");
+		const sources = [vertexSource || this.defaultVertexShader(fragmentSource), fragmentSource];
+		const programInfo = createProgramInfo(this.gl, sources, (msg) => {
+			const coords = this.extractErrorCoords(msg);
 			this.onError({
 				passName: this.passName,
 				coords
 			});
-			throw new Error(`Failed to compile shader: ${log}`);
-		}
-		return shader;
+		});
+		if (!programInfo) throw new Error(`Failed to create program for pass ${passName}`);
+		this.programInfo = programInfo;
 	}
 	extractErrorCoords(log) {
 		const match = ERROR_LOG_REGEX.exec(log);
@@ -126,79 +558,277 @@ var Shader = class {
 		};
 		return {
 			line: 0,
-			message: ""
+			message: log
 		};
 	}
-	linkProgram(vertexShader, fragmentShader) {
-		const program = this.gl.createProgram();
-		if (!program) throw new Error("Failed to create program");
-		if (vertexShader) this.gl.attachShader(program, vertexShader);
-		this.gl.attachShader(program, fragmentShader);
-		this.gl.linkProgram(program);
-		if (!this.gl.getProgramParameter(program, this.gl.LINK_STATUS)) {
-			const log = this.gl.getProgramInfoLog(program);
-			this.gl.deleteProgram(program);
-			throw new Error(`Failed to link program: ${log}`);
+	use() {
+		this.gl.useProgram(this.programInfo.program);
+	}
+	setUniforms(uniforms) {
+		setUniforms(this.programInfo, uniforms);
+	}
+	getAttribLocation(name) {
+		return this.gl.getAttribLocation(this.programInfo.program, name);
+	}
+	defaultVertexShader(fragmentSource) {
+		if (GLSL_300_ES_REGEX.test(fragmentSource)) {
+			if (!this.capabilities.isWebGL2) throw new Error(`Pass "${this.passName}" requires WebGL2 for GLSL ES 3.00 shaders`);
+			return DEFAULT_VERTEX_SHADER_GLSL300ES;
 		}
-		return program;
+		return DEFAULT_VERTEX_SHADER_GLSL100;
 	}
-	use() {
-		this.gl.useProgram(this.program);
+};
+//#endregion
+//#region src/types/renderer.ts
+const TEXTURE_CHANNEL_COUNT = 4;
+//#endregion
+//#region src/types/uniform.ts
+function isStaticUniformProvider(provider) {
+	return typeof provider.resolve !== "function";
+}
+//#endregion
+//#region src/uniform/UniformManager.ts
+const DATE_UNIFORM_PROVIDER = {
+	id: "uniform:date",
+	resolve: (context) => ({ u_date: context.date })
+};
+const FRAME_UNIFORM_PROVIDER = {
+	id: "uniform:frame",
+	resolve: (context) => ({
+		u_frame: context.frame,
+		u_frameRate: context.frameRate,
+		u_time: context.time,
+		u_timeDelta: context.timeDelta
+	})
+};
+const RESOLUTION_UNIFORM_PROVIDER = {
+	id: "uniform:resolution",
+	resolve: (context) => ({ u_resolution: context.resolution })
+};
+const MOUSE_UNIFORM_PROVIDER = {
+	id: "uniform:mouse",
+	resolve: (context) => ({ u_mouse: context.mouse })
+};
+const TEXTURE_UNIFORM_PROVIDER = {
+	id: "uniform:textures",
+	resolve: ({ textures }) => {
+		if (textures.length === 0) return;
+		return textures.reduce((uniforms, texture, index) => {
+			uniforms[`u_texture${index}`] = texture?.handle ?? null;
+			return uniforms;
+		}, {});
 	}
-	setUniform(name, type, ...values) {
-		let location = this.uniformLocations.get(name);
-		if (!location) {
-			location = this.gl.getUniformLocation(this.program, name);
-			this.uniformLocations.set(name, location);
+};
+/**
+* Resolves shader uniforms through a composable provider pipeline.
+* Later providers override earlier values, which keeps the default set extensible.
+*/
+var UniformManager = class UniformManager {
+	constructor(runtimeStateProvider = UniformManager.createDefaultRuntimeSnapshot, providers = UniformManager.createDefaultProviders()) {
+		this.providers = /* @__PURE__ */ new Map();
+		this.runtimeStateProvider = runtimeStateProvider;
+		providers.forEach((provider) => this.registerProvider(provider));
+	}
+	static createDefaultProviders() {
+		return [
+			DATE_UNIFORM_PROVIDER,
+			FRAME_UNIFORM_PROVIDER,
+			RESOLUTION_UNIFORM_PROVIDER,
+			MOUSE_UNIFORM_PROVIDER,
+			TEXTURE_UNIFORM_PROVIDER
+		];
+	}
+	static createDefaultRuntimeSnapshot() {
+		return {
+			now: /* @__PURE__ */ new Date(0),
+			frame: 0,
+			frameRate: 0,
+			mouse: [0, 0],
+			time: 0,
+			timeDelta: 0
+		};
+	}
+	registerProvider(provider) {
+		const id = provider.id.trim();
+		if (!id) throw new Error("Uniform provider id must not be empty");
+		if (typeof provider.resolve !== "function") throw new TypeError(`Uniform provider "${id}" must define a resolve function`);
+		if (this.providers.has(id)) throw new Error(`Uniform provider "${id}" is already registered`);
+		this.providers.set(id, {
+			...provider,
+			id
+		});
+	}
+	unregisterProvider(id) {
+		return this.providers.delete(id.trim());
+	}
+	resolve(request) {
+		const context = this.createContext(request);
+		const uniforms = {};
+		for (const provider of this.providers.values()) {
+			const resolvedUniforms = this.resolveProvider(provider, context);
+			if (!resolvedUniforms) continue;
+			Object.assign(uniforms, resolvedUniforms);
 		}
-		switch (type) {
-			case "1f":
-				this.gl.uniform1f(location, values[0]);
-				break;
-			case "1i":
-				this.gl.uniform1i(location, values[0]);
-				break;
-			case "2fv":
-				this.gl.uniform2fv(location, values[0]);
-				break;
-			case "3fv":
-				this.gl.uniform3fv(location, values[0]);
-				break;
-			case "4fv":
-				this.gl.uniform4fv(location, values[0]);
-				break;
+		return uniforms;
+	}
+	resolveProvider(provider, context) {
+		try {
+			const resolvedUniforms = provider.resolve(context);
+			if (resolvedUniforms === void 0) return;
+			if (!this.isUniformMap(resolvedUniforms)) throw new Error("Uniform provider must return an object map or undefined");
+			return resolvedUniforms;
+		} catch (error) {
+			throw new Error(`Failed to resolve uniforms for provider "${provider.id}" on ${context.target} "${context.passName}": ${this.toErrorMessage(error)}`);
 		}
 	}
-	getAttribLocation(name) {
-		return this.gl.getAttribLocation(this.program, name);
+	isUniformMap(value) {
+		return value !== null && !Array.isArray(value) && typeof value === "object";
 	}
-	defaultVertexShader() {
-		return `
-      attribute vec4 a_position;
-      void main() {
-        gl_Position = a_position;
-      }`;
+	createContext(request) {
+		const runtimeState = this.getRuntimeState();
+		const passName = request.passName.trim();
+		if (!passName) throw new Error("Uniform request passName must not be empty");
+		if (!this.isTarget(request.target)) throw new Error(`Uniform request target "${String(request.target)}" is invalid`);
+		return {
+			target: request.target,
+			passName,
+			date: this.toDateUniformValue(runtimeState.now),
+			frame: runtimeState.frame,
+			frameRate: runtimeState.frameRate,
+			mouse: this.clonePair(runtimeState.mouse, "runtime mouse"),
+			resolution: this.clonePair(request.resolution, "uniform resolution"),
+			textures: [...request.textures ?? []],
+			time: runtimeState.time,
+			timeDelta: runtimeState.timeDelta
+		};
+	}
+	getRuntimeState() {
+		const runtimeState = this.runtimeStateProvider();
+		if (!this.isRuntimeState(runtimeState)) throw new Error("Uniform runtime state provider returned an invalid state object");
+		return runtimeState;
+	}
+	isRuntimeState(value) {
+		if (value === null || typeof value !== "object") return false;
+		const runtimeState = value;
+		return runtimeState.now instanceof Date && this.isNumber(runtimeState.frame) && this.isNumber(runtimeState.frameRate) && this.isPair(runtimeState.mouse) && this.isNumber(runtimeState.time) && this.isNumber(runtimeState.timeDelta);
+	}
+	isTarget(value) {
+		return value === "pass" || value === "present";
+	}
+	isPair(value) {
+		return Array.isArray(value) && value.length === 2 && this.isNumber(value[0]) && this.isNumber(value[1]);
+	}
+	isNumber(value) {
+		return typeof value === "number" && Number.isFinite(value);
+	}
+	clonePair(value, label) {
+		if (!this.isPair(value)) throw new Error(`${label} must be a pair of finite numbers`);
+		return [value[0], value[1]];
+	}
+	toDateUniformValue(now) {
+		return [
+			now.getFullYear(),
+			now.getMonth() + 1,
+			now.getDate(),
+			now.getHours() * 3600 + now.getMinutes() * 60 + now.getSeconds() + now.getMilliseconds() / 1e3
+		];
+	}
+	toErrorMessage(error) {
+		if (error instanceof Error) return error.message;
+		return String(error);
 	}
 };
 //#endregion
-//#region src/engine/WebGLRenderer.ts
+//#region src/engine/ScreenTriangle.ts
+const triangleCache = /* @__PURE__ */ new WeakMap();
 /**
-* Renderer class responsible for managing the WebGL context, render passes, and animation loop.
+* Provides a cached full-screen triangle (Screen Triangle) BufferInfo.
+*
+* Uses a single large triangle instead of a two-triangle quad for full-screen passes.
+* This improves cache coherency by maintaining spatial locality during rasterization,
+* avoiding the cache invalidation that occurs when switching between quad triangles.
+*
+* Vertices are at (-1, -1), (-1, 3), (3, -1) in clip space, covering the viewport
+* after clipping.
+*
+* @see {@link https://michaldrobot.com/2014/04/01/gcn-execution-patterns-in-full-screen-passes/}
 */
-var WebGLRenderer = class {
-	constructor(canvas, onError) {
-		this.canvas = canvas;
-		this.animationRequestID = -1;
-		this.gl = this.initializeWebGLContext(canvas);
-		this.passes = null;
+function getScreenTriangle(gl) {
+	let bufferInfo = triangleCache.get(gl);
+	if (!bufferInfo) {
+		bufferInfo = createBufferInfoFromArrays(gl, { a_position: {
+			numComponents: 2,
+			data: new Float32Array([
+				-1,
+				-1,
+				-1,
+				3,
+				3,
+				-1
+			])
+		} });
+		triangleCache.set(gl, bufferInfo);
+	}
+	return bufferInfo;
+}
+//#endregion
+//#region src/engine/RendererCore.ts
+/**
+* Host-agnostic WebGL renderer core: GL context, passes, uniforms, loop.
+*
+* Deliberately free of DOM APIs (`window`, `document`, listeners, rAF) so it
+* can run inside a worker against an `OffscreenCanvas`. Hosts own the
+* surrounding concerns and feed the core explicitly:
+* - viewport size via {@link setDisplaySize}
+* - pointer position via {@link setPointer} (device pixels, Y-up)
+* - frame scheduling via the injected {@link FrameDriver}
+*/
+var RendererCore = class RendererCore {
+	static {
+		this.presentFragmentShader = `
+    precision highp float;
+    uniform sampler2D u_texture0;
+    uniform vec2 u_resolution;
+
+    void main() {
+      vec2 uv = gl_FragCoord.xy / u_resolution;
+      gl_FragColor = texture2D(u_texture0, uv);
+    }
+  `;
+	}
+	constructor(options) {
+		this.frameScheduled = false;
+		this.thumbnailScratchFramebuffer = null;
+		this.thumbnailScratchTexture = null;
+		this.thumbnailScratchWidth = 0;
+		this.thumbnailScratchHeight = 0;
+		this.canvas = options.canvas;
+		this.frameDriver = options.frameDriver ?? timerFrameDriver();
+		this.gl = this.initializeWebGLContext(options.canvas);
+		this.capabilities = detectGLContextCapabilities(this.gl);
+		this.pipeline = new Pipeline();
+		this.passConfigs = /* @__PURE__ */ new Map();
 		this.textureMap = /* @__PURE__ */ new Map();
 		this.now = /* @__PURE__ */ new Date();
-		this.onError = onError;
+		this.compiler = new PipelineCompiler();
+		this.screenTriangle = getScreenTriangle(this.gl);
+		this.uniformManager = new UniformManager(() => ({
+			now: this.now,
+			frame: this.currentFrame,
+			frameRate: this.frameRate,
+			mouse: [this.mouseX, this.mouseY],
+			time: this.currentTime,
+			timeDelta: this.timeDelta
+		}));
+		this.onError = options.onError || (({ passName, coords }) => {
+			console.error(`[Actis] Error in pass "${passName}" at line ${coords.line}: ${coords.message}`);
+		});
+		this.presentShader = new Shader(this.gl, this.capabilities, void 0, RendererCore.presentFragmentShader, () => {}, "__actis_present__");
 		this.mouseX = 0;
 		this.mouseY = 0;
 		this.time = 0;
 		this.timeDelta = 0;
-		this.realToCSSPixels = typeof window !== "undefined" ? window.devicePixelRatio || 1 : 1;
+		this.realToCSSPixels = options.pixelRatio ?? 1;
 		this.paused = false;
 		this.playbackTime = 0;
 		this.lastTime = 0;
@@ -206,8 +836,8 @@ var WebGLRenderer = class {
 		this.currentFrame = 0;
 		this.currentTime = 0;
 		this.startTime = 0;
-		this.initMouseEvents();
-		if (typeof window !== "undefined") window.addEventListener("resize", this.resizeCanvasToDisplaySize.bind(this));
+		this.pausedAt = 0;
+		this.boundRender = (time) => this.render(time);
 	}
 	initializeWebGLContext(canvas) {
 		const opts = {
@@ -219,122 +849,964 @@ var WebGLRenderer = class {
 			preserveDrawingBuffer: true,
 			powerPreference: "high-performance"
 		};
-		const gl = canvas.getContext("webgl2", opts) || canvas.getContext("experimental-webgl2", opts) || canvas.getContext("webgl", opts) || canvas.getContext("experimental-webgl", opts);
+		const legacy = canvas;
+		const gl = canvas.getContext("webgl2", opts) || canvas.getContext("webgl", opts) || legacy.getContext("experimental-webgl2", opts) || legacy.getContext("experimental-webgl", opts);
 		if (!gl) throw new Error("WebGL not supported");
 		return gl;
 	}
-	initMouseEvents() {
-		this.canvas.addEventListener("mousemove", this.setMousePosition.bind(this));
-		this.canvas.addEventListener("touchstart", this.preventDefault, { passive: false });
-		this.canvas.addEventListener("touchmove", this.handleTouchMove.bind(this), { passive: false });
+	/**
+	* Pointer position in device pixels, Y-up relative to the drawing buffer.
+	* Hosts compute this from DOM events; the core performs no layout reads.
+	*/
+	setPointer(x, y) {
+		this.mouseX = x;
+		this.mouseY = y;
 	}
-	setMousePosition(e) {
-		const mouse = {
-			x: e.clientX || e.pageX,
-			y: e.clientY || e.pageY
+	setPixelRatio(ratio) {
+		if (Number.isFinite(ratio) && ratio > 0) this.realToCSSPixels = ratio;
+	}
+	/**
+	* Explicit drawing-buffer size. Replaces the implicit
+	* `clientWidth`-based resize, which `OffscreenCanvas` cannot provide.
+	*/
+	setDisplaySize(width, height) {
+		const w = Math.max(1, Math.floor(width));
+		const h = Math.max(1, Math.floor(height));
+		if (this.canvas.width === w && this.canvas.height === h) return;
+		this.canvas.width = w;
+		this.canvas.height = h;
+		this.pipeline.resize(w, h);
+		this.syncPassTextures();
+	}
+	addPass(pass) {
+		this.pipeline.add(pass.shader.passName, pass);
+	}
+	getPass(name) {
+		return this.pipeline.get(name);
+	}
+	getPasses() {
+		return this.pipeline.toArray();
+	}
+	forEachPass(callback) {
+		this.pipeline.forEach(callback);
+	}
+	getPassNames() {
+		return this.pipeline.toArray().map((pass) => pass.shader.passName);
+	}
+	/**
+	* Capture downscaled raw pixels of a pass output. Hosts encode these for
+	* display (2D canvas on the main thread, `ImageBitmap` in a worker).
+	* Returns null when unavailable. Never throws.
+	*/
+	capturePassPixels(name, maxSize = 64) {
+		try {
+			const pass = this.pipeline.get(name);
+			const srcInfo = pass?.fbo?.info;
+			const srcFramebuffer = srcInfo?.framebuffer;
+			const srcWidth = pass?.width ?? 0;
+			const srcHeight = pass?.height ?? 0;
+			if (!pass || !srcInfo || !srcFramebuffer || !srcWidth || !srcHeight) return null;
+			const scale = Math.min(1, maxSize / Math.max(srcWidth, srcHeight));
+			const thumbWidth = Math.max(1, Math.round(srcWidth * scale));
+			const thumbHeight = Math.max(1, Math.round(srcHeight * scale));
+			const gl2 = this.gl;
+			if (!!gl2 && typeof gl2.blitFramebuffer === "function" && this.capabilities.isWebGL2) return this.capturePassViaBlit(gl2, srcFramebuffer, srcWidth, srcHeight, thumbWidth, thumbHeight);
+			return this.capturePassViaFullRead(srcInfo, srcWidth, srcHeight, thumbWidth, thumbHeight);
+		} catch {
+			return null;
+		}
+	}
+	capturePassViaBlit(gl2, srcFramebuffer, srcWidth, srcHeight, thumbWidth, thumbHeight) {
+		const gl = this.gl;
+		this.ensureThumbnailScratch(thumbWidth, thumbHeight);
+		if (!this.thumbnailScratchFramebuffer) return null;
+		gl2.bindFramebuffer(gl2.READ_FRAMEBUFFER, srcFramebuffer);
+		gl2.bindFramebuffer(gl2.DRAW_FRAMEBUFFER, this.thumbnailScratchFramebuffer);
+		gl2.blitFramebuffer(0, 0, srcWidth, srcHeight, 0, 0, thumbWidth, thumbHeight, gl2.COLOR_BUFFER_BIT, gl2.LINEAR);
+		gl2.bindFramebuffer(gl2.READ_FRAMEBUFFER, this.thumbnailScratchFramebuffer);
+		gl2.bindFramebuffer(gl2.DRAW_FRAMEBUFFER, null);
+		const pixels = new Uint8Array(thumbWidth * thumbHeight * 4);
+		gl.readPixels(0, 0, thumbWidth, thumbHeight, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+		bindFramebufferInfo(gl, null);
+		return {
+			data: pixels,
+			width: thumbWidth,
+			height: thumbHeight
 		};
-		const rect = this.canvas.getBoundingClientRect();
-		if (mouse.x >= rect.left && mouse.x <= rect.right && mouse.y >= rect.top && mouse.y <= rect.bottom) {
-			this.mouseX = (mouse.x - rect.left) * this.realToCSSPixels;
-			this.mouseY = this.canvas.height - (mouse.y - rect.top) * this.realToCSSPixels;
+	}
+	capturePassViaFullRead(srcInfo, srcWidth, srcHeight, thumbWidth, thumbHeight) {
+		const gl = this.gl;
+		bindFramebufferInfo(gl, srcInfo);
+		const pixels = new Uint8Array(srcWidth * srcHeight * 4);
+		gl.readPixels(0, 0, srcWidth, srcHeight, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+		bindFramebufferInfo(gl, null);
+		const thumb = new Uint8Array(thumbWidth * thumbHeight * 4);
+		const xRatio = srcWidth / thumbWidth;
+		const yRatio = srcHeight / thumbHeight;
+		for (let y = 0; y < thumbHeight; y++) {
+			const srcY = Math.min(srcHeight - 1, Math.floor(y * yRatio));
+			for (let x = 0; x < thumbWidth; x++) {
+				const srcX = Math.min(srcWidth - 1, Math.floor(x * xRatio));
+				const s = (srcY * srcWidth + srcX) * 4;
+				const d = (y * thumbWidth + x) * 4;
+				thumb[d] = pixels[s] ?? 0;
+				thumb[d + 1] = pixels[s + 1] ?? 0;
+				thumb[d + 2] = pixels[s + 2] ?? 0;
+				thumb[d + 3] = 255;
+			}
 		}
+		return {
+			data: thumb,
+			width: thumbWidth,
+			height: thumbHeight
+		};
 	}
-	handleTouchMove(e) {
-		e.preventDefault();
-		if (e.touches.length > 0) this.setMousePosition(e.touches[0]);
+	ensureThumbnailScratch(width, height) {
+		const gl = this.gl;
+		if (this.thumbnailScratchFramebuffer && this.thumbnailScratchWidth === width && this.thumbnailScratchHeight === height) return;
+		this.disposeThumbnailScratch();
+		const texture = gl.createTexture();
+		if (!texture) return;
+		gl.bindTexture(gl.TEXTURE_2D, texture);
+		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+		gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+		const framebuffer = gl.createFramebuffer();
+		if (!framebuffer) {
+			gl.deleteTexture(texture);
+			return;
+		}
+		gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+		gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+		gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+		gl.bindTexture(gl.TEXTURE_2D, null);
+		this.thumbnailScratchTexture = texture;
+		this.thumbnailScratchFramebuffer = framebuffer;
+		this.thumbnailScratchWidth = width;
+		this.thumbnailScratchHeight = height;
 	}
-	preventDefault(e) {
-		e.preventDefault();
+	disposeThumbnailScratch() {
+		const gl = this.gl;
+		if (this.thumbnailScratchFramebuffer) {
+			gl.deleteFramebuffer(this.thumbnailScratchFramebuffer);
+			this.thumbnailScratchFramebuffer = null;
+		}
+		if (this.thumbnailScratchTexture) {
+			gl.deleteTexture(this.thumbnailScratchTexture);
+			this.thumbnailScratchTexture = null;
+		}
+		this.thumbnailScratchWidth = 0;
+		this.thumbnailScratchHeight = 0;
 	}
-	addPass(pass) {
-		if (this.passes) {
-			let current = this.passes;
-			while (current.next) current = current.next;
-			current.next = pass;
-		} else this.passes = pass;
-	}
-	resizeCanvasToDisplaySize() {
-		const displayWidth = Math.floor(this.canvas.clientWidth * this.realToCSSPixels);
-		const displayHeight = Math.floor(this.canvas.clientHeight * this.realToCSSPixels);
-		if (this.canvas.width !== displayWidth || this.canvas.height !== displayHeight) {
-			this.canvas.width = displayWidth;
-			this.canvas.height = displayHeight;
-			let current = this.passes;
-			while (current) {
-				current.resize(displayWidth, displayHeight);
-				current = current.next;
-			}
+	getMetrics() {
+		return {
+			paused: this.paused,
+			time: this.currentTime,
+			frameRate: this.frameRate,
+			width: this.canvas.width,
+			height: this.canvas.height
+		};
+	}
+	getContextState() {
+		return Object.freeze({
+			capabilities: this.capabilities,
+			webglVersion: this.capabilities.isWebGL2 ? 2 : 1
+		});
+	}
+	clear() {
+		this.resetPlaybackState();
+		this.pipeline.forEach((pass) => pass.clear());
+		this.syncPassTextures();
+		this.clearCanvas();
+		if (this.getPasses().length > 0) this.renderFrame();
+	}
+	registerUniformProvider(provider) {
+		if (isStaticUniformProvider(provider)) {
+			const { id, values } = provider;
+			this.uniformManager.registerProvider({
+				id,
+				resolve: () => values
+			});
+			return;
 		}
+		this.uniformManager.registerProvider(provider);
 	}
-	updateUniforms(pass) {
-		pass.shader.setUniform("u_date", "4fv", [
-			this.now.getFullYear(),
-			this.now.getMonth() + 1,
-			this.now.getDate(),
-			this.now.getHours() * 3600 + this.now.getMinutes() * 60 + this.now.getSeconds() + this.now.getMilliseconds() / 1e3
-		]);
-		pass.shader.setUniform("u_frame", "1i", this.currentFrame);
-		pass.shader.setUniform("u_time", "1f", this.currentTime);
-		pass.shader.setUniform("u_timeDelta", "1f", this.timeDelta);
-		pass.shader.setUniform("u_frameRate", "1f", this.frameRate);
-		pass.shader.setUniform("u_resolution", "2fv", [pass.width, pass.height]);
-		pass.shader.setUniform("u_mouse", "2fv", [this.mouseX, this.mouseY]);
+	unregisterUniformProvider(providerId) {
+		return this.uniformManager.unregisterProvider(providerId);
 	}
 	updateTime(currentTime) {
+		this.now = /* @__PURE__ */ new Date();
 		if (this.paused) {
 			this.timeDelta = 0;
+			this.frameRate = 0;
 			return;
 		}
 		const t = currentTime ?? (typeof performance !== "undefined" ? performance.now() : Date.now());
+		const hasStarted = this.startTime !== 0;
 		if (this.startTime === 0) this.startTime = t;
-		if (this.lastTime === 0) this.lastTime = t;
-		this.timeDelta = (t - this.startTime) / 1e3;
-		this.currentTime += this.timeDelta;
-		this.frameRate = 1 / this.timeDelta;
+		if (this.pausedAt !== 0) {
+			if (hasStarted) this.startTime += t - this.pausedAt;
+			this.pausedAt = 0;
+			this.lastTime = t;
+			this.timeDelta = 0;
+		} else if (this.lastTime === 0) {
+			this.lastTime = t;
+			this.timeDelta = 0;
+		} else {
+			this.timeDelta = (t - this.lastTime) / 1e3;
+			this.lastTime = t;
+		}
+		this.currentTime = (t - this.startTime) / 1e3;
+		this.time = this.currentTime;
+		this.playbackTime = this.currentTime;
+		this.frameRate = this.timeDelta > 0 ? 1 / this.timeDelta : 0;
 		this.currentFrame++;
-		this.startTime = t;
 	}
 	render(currentTime) {
-		this.updateTime(currentTime);
-		this.resizeCanvasToDisplaySize();
-		let current = this.passes;
-		while (current) {
-			current.use();
-			this.updateUniforms(current);
-			current.draw();
-			current = current.next;
+		this.frameScheduled = false;
+		this.renderFrame(currentTime);
+		if (!this.paused) {
+			this.frameScheduled = true;
+			this.frameDriver.request(this.boundRender);
 		}
-		if (typeof requestAnimationFrame !== "undefined") this.animationRequestID = requestAnimationFrame(this.render.bind(this));
 	}
 	setup(config) {
-		const displayWidth = Math.floor(this.canvas.clientWidth * this.realToCSSPixels);
-		const displayHeight = Math.floor(this.canvas.clientHeight * this.realToCSSPixels);
-		config.passes.forEach((passConfig) => {
+		this.cancelScheduledFrame();
+		this.pipeline.clear();
+		this.passConfigs.clear();
+		this.textureMap.clear();
+		this.resetPlaybackState();
+		this.clearCanvas();
+		const displayWidth = this.canvas.width;
+		const displayHeight = this.canvas.height;
+		let pipelinePlan;
+		try {
+			pipelinePlan = this.compiler.compile(config);
+		} catch (error) {
+			console.error(`[Actis] Failed to compile pipeline: ${error.message}`);
+			return;
+		}
+		let setupFailed = false;
+		pipelinePlan.passes.forEach((passConfig) => {
 			try {
-				const shader = new Shader(this.gl, passConfig.vertexShader, passConfig.fragmentShader, this.onError, passConfig.name);
-				const offscreen = passConfig.offscreen || passConfig.name !== "MainBuffer";
-				const pass = new Pass(this.gl, shader, displayWidth, displayHeight, offscreen, passConfig.textures.map((textureName) => this.textureMap.get(textureName)));
-				this.addPass(pass);
-				this.textureMap.set(passConfig.name, pass.texture);
+				const shader = new Shader(this.gl, this.capabilities, passConfig.vertexShader, passConfig.fragmentShader, this.onError, passConfig.name);
+				const pass = new Pass(this.gl, this.capabilities, shader, this.screenTriangle, displayWidth, displayHeight, passConfig.offscreen, [], passConfig.pingPong, passConfig.texture);
+				this.pipeline.add(passConfig.name, pass, passConfig.dependencies);
+				this.passConfigs.set(passConfig.name, passConfig);
+				if (pass.texture) this.textureMap.set(passConfig.name, pass.texture);
 			} catch (error) {
+				setupFailed = true;
 				console.error(`Error in pass ${passConfig.name}: ${error.message}`);
 			}
 		});
+		if (setupFailed) {
+			this.pipeline.clear();
+			this.passConfigs.clear();
+			this.textureMap.clear();
+			this.clearCanvas();
+			return;
+		}
+		this.syncPassTextures();
 	}
 	play() {
+		if (this.frameScheduled) {
+			this.paused = false;
+			return;
+		}
 		this.paused = false;
-		this.animationRequestID = requestAnimationFrame(this.render.bind(this));
+		this.frameScheduled = true;
+		this.frameDriver.request(this.boundRender);
+	}
+	resume() {
+		this.play();
 	}
 	pause() {
+		if (this.paused) return;
 		this.paused = true;
-		cancelAnimationFrame(this.animationRequestID);
+		this.pausedAt = typeof performance !== "undefined" ? performance.now() : Date.now();
+		this.cancelScheduledFrame();
 	}
 	reset() {
+		this.clear();
+	}
+	/**
+	* Release loop scheduling and GL scratch resources. Passes keep their GL
+	* objects; hosts owning the context decide its lifetime.
+	*/
+	dispose() {
+		this.cancelScheduledFrame();
+		this.disposeThumbnailScratch();
+	}
+	renderFrame(currentTime) {
+		this.updateTime(currentTime);
+		let presentedTexture;
+		this.pipeline.forEach((pass) => {
+			this.syncPassTexturesForPass(pass);
+			pass.use();
+			const uniforms = this.uniformManager.resolve({
+				target: "pass",
+				passName: pass.shader.passName,
+				resolution: [pass.width, pass.height],
+				textures: this.getTextureBindings(pass.textures)
+			});
+			pass.shader.setUniforms(uniforms);
+			pass.draw();
+			this.updateTextureMapForPass(pass);
+			if (this.passConfigs.get(pass.shader.passName)?.presentToCanvas) presentedTexture = pass.texture;
+		});
+		if (presentedTexture) this.presentTexture(presentedTexture);
+	}
+	syncPassTextures() {
+		this.textureMap.clear();
+		this.pipeline.forEach((pass) => {
+			this.updateTextureMapForPass(pass);
+		});
+		this.pipeline.forEach((pass) => {
+			this.syncPassTexturesForPass(pass);
+		});
+	}
+	syncPassTexturesForPass(pass) {
+		const passName = pass.shader.passName;
+		const passConfig = this.passConfigs.get(passName);
+		if (!passConfig) return;
+		pass.textures = passConfig.textures.map((textureName) => {
+			const texture = this.textureMap.get(textureName);
+			if (!texture) {
+				console.warn(`Texture ${textureName} not found for pass ${passName}`);
+				return;
+			}
+			return texture;
+		});
+	}
+	updateTextureMapForPass(pass) {
+		const texture = pass.texture;
+		if (!texture) return;
+		this.textureMap.set(pass.shader.passName, texture);
+	}
+	presentTexture(texture) {
+		if (!texture.handle) return;
+		bindFramebufferInfo(this.gl, null);
+		this.gl.viewport(0, 0, this.gl.canvas.width, this.gl.canvas.height);
+		this.presentShader.use();
+		setBuffersAndAttributes(this.gl, this.presentShader.programInfo, this.screenTriangle);
+		const uniforms = this.uniformManager.resolve({
+			target: "present",
+			passName: this.presentShader.passName,
+			resolution: [this.gl.canvas.width, this.gl.canvas.height],
+			textures: this.getTextureBindings([texture])
+		});
+		this.presentShader.setUniforms(uniforms);
+		drawBufferInfo(this.gl, this.screenTriangle);
+	}
+	getTextureBindings(textures) {
+		const slotCount = Math.max(4, textures.length);
+		return Array.from({ length: slotCount }, (_, index) => textures[index]);
+	}
+	cancelScheduledFrame() {
+		this.frameScheduled = false;
+		this.frameDriver.cancel();
+	}
+	clearCanvas() {
+		bindFramebufferInfo(this.gl, null);
+		this.gl.viewport(0, 0, this.gl.canvas.width, this.gl.canvas.height);
+		this.gl.clearColor(0, 0, 0, 0);
+		this.gl.clear(this.gl.COLOR_BUFFER_BIT);
+	}
+	resetPlaybackState() {
+		this.now = /* @__PURE__ */ new Date();
+		this.time = 0;
+		this.timeDelta = 0;
 		this.playbackTime = 0;
+		this.lastTime = 0;
+		this.frameRate = 0;
 		this.currentFrame = 0;
+		this.currentTime = 0;
+		this.startTime = 0;
+		this.pausedAt = 0;
+	}
+};
+//#endregion
+//#region src/engine/WebGLRenderer.ts
+/**
+* Main-thread `WebGLRenderer`: {@link RendererCore} plus the DOM shell —
+* pointer/resize listeners, `requestAnimationFrame` loop, and 2D-canvas
+* thumbnail encoding.
+*
+* @deprecated Prefer `createRenderer(canvas)` — worker-first with automatic
+* main-thread fallback and the same public surface. Direct construction
+* always renders on the main thread; use `createRenderer(canvas,
+* { mode: 'main' })` to pin that explicitly.
+*/
+var WebGLRenderer = class WebGLRenderer extends RendererCore {
+	constructor(canvas, onError) {
+		super({
+			canvas,
+			onError,
+			pixelRatio: typeof window !== "undefined" ? window.devicePixelRatio || 1 : 1,
+			frameDriver: rafFrameDriver()
+		});
+		this.thumbnailCanvas = null;
+		this.resizeObserver = null;
+		this.displayCanvas = canvas;
+		this.handleResize = () => this.syncSizeToDisplay();
+		this.handleMouseMove = (e) => this.setMousePosition(e);
+		this.handleTouchStart = (e) => e.preventDefault();
+		this.handleTouchMove = (e) => {
+			e.preventDefault();
+			if (e.touches.length > 0) this.setMousePosition(e.touches[0]);
+		};
+		canvas.addEventListener("mousemove", this.handleMouseMove);
+		canvas.addEventListener("touchstart", this.handleTouchStart, { passive: false });
+		canvas.addEventListener("touchmove", this.handleTouchMove, { passive: false });
+		if (typeof window !== "undefined") window.addEventListener("resize", this.handleResize);
+		if (typeof ResizeObserver !== "undefined") {
+			this.resizeObserver = new ResizeObserver(this.handleResize);
+			this.resizeObserver.observe(canvas);
+		}
+		this.syncSizeToDisplay();
+	}
+	setMousePosition(e) {
+		const mouse = {
+			x: e.clientX || e.pageX,
+			y: e.clientY || e.pageY
+		};
+		const rect = this.displayCanvas.getBoundingClientRect();
+		if (mouse.x >= rect.left && mouse.x <= rect.right && mouse.y >= rect.top && mouse.y <= rect.bottom) this.setPointer((mouse.x - rect.left) * this.realToCSSPixels, this.displayCanvas.height - (mouse.y - rect.top) * this.realToCSSPixels);
+	}
+	syncSizeToDisplay() {
+		const width = Math.floor(this.displayCanvas.clientWidth * this.realToCSSPixels);
+		const height = Math.floor(this.displayCanvas.clientHeight * this.realToCSSPixels);
+		this.setDisplaySize(width, height);
+	}
+	/**
+	* Capture a downscaled data-URL thumbnail of a pass output.
+	* Cheap by design: blits to a small scratch FBO (WebGL2) so only
+	* thumbnail-sized pixels are read back. Returns null when unavailable.
+	*/
+	capturePassDataURL(name, maxSize = 64) {
+		const pixels = this.capturePassPixels(name, maxSize);
+		if (!pixels) return null;
+		return WebGLRenderer.pixelsToDataURL(this.thumbnailCanvasRef(), pixels.data, pixels.width, pixels.height);
+	}
+	thumbnailCanvasRef() {
+		if (!this.thumbnailCanvas) this.thumbnailCanvas = document.createElement("canvas");
+		return this.thumbnailCanvas;
+	}
+	/** Encode bottom-up GL pixels to a data URL. Shared with worker hosts. */
+	static pixelsToDataURL(canvas, pixels, width, height) {
+		const target = canvas;
+		if (target.width !== width || target.height !== height) {
+			target.width = width;
+			target.height = height;
+		}
+		const ctx = target.getContext("2d");
+		if (!ctx) return null;
+		const image = ctx.createImageData(width, height);
+		const rowBytes = width * 4;
+		for (let y = 0; y < height; y++) {
+			const src = (height - 1 - y) * rowBytes;
+			image.data.set(pixels.subarray(src, src + rowBytes), y * rowBytes);
+		}
+		ctx.putImageData(image, 0, 0);
+		return target.toDataURL();
+	}
+	dispose() {
+		this.displayCanvas.removeEventListener("mousemove", this.handleMouseMove);
+		this.displayCanvas.removeEventListener("touchstart", this.handleTouchStart);
+		this.displayCanvas.removeEventListener("touchmove", this.handleTouchMove);
+		if (typeof window !== "undefined") window.removeEventListener("resize", this.handleResize);
+		this.resizeObserver?.disconnect();
+		this.resizeObserver = null;
+		super.dispose();
+	}
+};
+//#endregion
+//#region src/worker/host.ts
+/**
+* Map a client-coordinate pointer event to device pixels (Y-up), or null
+* when outside the canvas. Shared by the main-thread shell and worker hosts
+* so both paths handle edges identically.
+*/
+function normalizePointer(canvas, clientX, clientY, pixelRatio) {
+	const rect = canvas.getBoundingClientRect();
+	if (clientX < rect.left || clientX > rect.right || clientY < rect.top || clientY > rect.bottom) return null;
+	return [(clientX - rect.left) * pixelRatio, canvas.height - (clientY - rect.top) * pixelRatio];
+}
+function currentPixelRatio() {
+	return typeof window !== "undefined" ? window.devicePixelRatio || 1 : 1;
+}
+/**
+* Wire a visible canvas to a renderer target. Installs resize observation
+* (window resize + layout changes from panels/sidebars) and pointer
+* listeners, pushing normalized values to the target. Returns a dispose
+* function removing every listener/observer.
+*/
+function attachRendererHost(canvas, target) {
+	const syncSize = () => {
+		const ratio = currentPixelRatio();
+		target.setPixelRatio(ratio);
+		target.setDisplaySize(Math.floor(canvas.clientWidth * ratio), Math.floor(canvas.clientHeight * ratio));
+	};
+	const handleResize = () => syncSize();
+	const handleMouseMove = (e) => {
+		const point = normalizePointer(canvas, e.clientX || e.pageX, e.clientY || e.pageY, target.realToCSSPixels);
+		if (point) target.setPointer(point[0], point[1]);
+	};
+	const handleTouchStart = (e) => e.preventDefault();
+	const handleTouchMove = (e) => {
+		e.preventDefault();
+		const touch = e.touches[0];
+		if (!touch) return;
+		const point = normalizePointer(canvas, touch.clientX, touch.clientY, target.realToCSSPixels);
+		if (point) target.setPointer(point[0], point[1]);
+	};
+	canvas.addEventListener("mousemove", handleMouseMove);
+	canvas.addEventListener("touchstart", handleTouchStart, { passive: false });
+	canvas.addEventListener("touchmove", handleTouchMove, { passive: false });
+	if (typeof window !== "undefined") window.addEventListener("resize", handleResize);
+	let resizeObserver = null;
+	if (typeof ResizeObserver !== "undefined") {
+		resizeObserver = new ResizeObserver(handleResize);
+		resizeObserver.observe(canvas);
+	}
+	syncSize();
+	return () => {
+		canvas.removeEventListener("mousemove", handleMouseMove);
+		canvas.removeEventListener("touchstart", handleTouchStart);
+		canvas.removeEventListener("touchmove", handleTouchMove);
+		if (typeof window !== "undefined") window.removeEventListener("resize", handleResize);
+		resizeObserver?.disconnect();
+	};
+}
+//#endregion
+//#region src/worker/OffscreenWebGLRenderer.ts
+function thumbnailKey(name, maxSize) {
+	return `${name}@${maxSize}`;
+}
+/**
+* Main-thread proxy for a worker-hosted {@link RendererCore}. Same public
+* surface as {@link WebGLRenderer}: fire-and-forget commands cross the
+* boundary, while synchronous reads (`getMetrics`, `getPassNames`,
+* `capturePassDataURL`) are served from caches the worker pushes.
+* Construct via {@link createRenderer}, never directly.
+*/
+var OffscreenWebGLRenderer = class {
+	constructor(canvas, worker, options) {
+		this.isOffscreenRenderer = true;
+		this.mouseX = 0;
+		this.mouseY = 0;
+		this.time = 0;
+		this.timeDelta = 0;
+		this.realToCSSPixels = 1;
+		this.paused = false;
+		this.playbackTime = 0;
 		this.lastTime = 0;
 		this.frameRate = 0;
+		this.currentFrame = 0;
+		this.currentTime = 0;
+		this.startTime = 0;
+		this.passNames = [];
+		this.metrics = {
+			paused: false,
+			time: 0,
+			frameRate: 0,
+			width: 0,
+			height: 0
+		};
+		this.contextState = null;
+		this.thumbnails = /* @__PURE__ */ new Map();
+		this.captureId = 0;
+		this.disposed = false;
+		this.displayCanvas = canvas;
+		this.worker = worker;
+		this.onError = options?.onError ?? (({ passName, coords }) => {
+			console.error(`[Actis] Error in pass "${passName}" at line ${coords.line}: ${coords.message}`);
+		});
+		this.detachHost = options?.detachHost ?? null;
+		this.encodeCanvas = typeof document !== "undefined" ? document.createElement("canvas") : null;
+	}
+	/**
+	* Take over the worker message stream. Called by the factory once the
+	* init handshake succeeds; replays the buffered first event.
+	*/
+	connect(firstEvent) {
+		this.worker.onmessage = (event) => this.handleEvent(event.data);
+		if (firstEvent) this.handleEvent(firstEvent);
+	}
+	/** Late-bind host teardown (the host needs the proxy to exist first). */
+	setDetachHost(detach) {
+		this.detachHost = detach;
+	}
+	/** The visible canvas (transferred control; the browser composites it). */
+	get canvas() {
+		return this.displayCanvas;
+	}
+	post(command, transfer) {
+		if (this.disposed) return;
+		this.worker.postMessage(command, transfer ?? []);
+	}
+	handleEvent(event) {
+		switch (event.type) {
+			case "metrics":
+				this.applyMetrics(event.metrics);
+				break;
+			case "passes":
+				this.passNames = [...event.names];
+				break;
+			case "context":
+				this.contextState = Object.freeze({
+					capabilities: { ...event.capabilities },
+					webglVersion: event.webglVersion
+				});
+				break;
+			case "error":
+				this.onError(event.details);
+				break;
+			case "capture-result":
+				this.applyCapture(event.name, event.maxSize, event.data, event.width, event.height);
+				break;
+			case "ready":
+			case "fatal": break;
+		}
+	}
+	applyMetrics(next) {
+		this.metrics = { ...next };
+		this.paused = next.paused;
+		this.time = next.time;
+		this.currentTime = next.time;
+		this.playbackTime = next.time;
+		this.frameRate = next.frameRate;
+	}
+	applyCapture(name, maxSize, data, width, height) {
+		if (!data || !this.encodeCanvas) return;
+		const url = WebGLRenderer.pixelsToDataURL(this.encodeCanvas, new Uint8Array(data), width, height);
+		if (url) this.thumbnails.set(thumbnailKey(name, maxSize), url);
+	}
+	setup(config) {
+		this.passNames = [];
+		this.post({
+			type: "setup",
+			config
+		});
+	}
+	play() {
+		this.paused = false;
+		this.post({ type: "play" });
+	}
+	resume() {
+		this.play();
+	}
+	pause() {
+		this.paused = true;
+		this.post({ type: "pause" });
+	}
+	reset() {
+		this.post({ type: "reset" });
+	}
+	clear() {
+		this.post({ type: "clear" });
+	}
+	setPointer(x, y) {
+		this.mouseX = x;
+		this.mouseY = y;
+		this.post({
+			type: "pointer",
+			x,
+			y
+		});
+	}
+	setPixelRatio(ratio) {
+		if (Number.isFinite(ratio) && ratio > 0) this.realToCSSPixels = ratio;
+	}
+	setDisplaySize(width, height) {
+		this.metrics = {
+			...this.metrics,
+			width,
+			height
+		};
+		this.post({
+			type: "resize",
+			width,
+			height,
+			pixelRatio: this.realToCSSPixels
+		});
+	}
+	registerUniformProvider(provider) {
+		if (!isStaticUniformProvider(provider)) throw new Error(`[Actis] Function uniform providers cannot cross the worker boundary (provider "${provider.id}"). Use a static { id, values } provider, or create the renderer with mode: "main".`);
+		this.post({
+			type: "register-provider",
+			provider: {
+				id: provider.id,
+				values: provider.values
+			}
+		});
+	}
+	unregisterUniformProvider(providerId) {
+		this.post({
+			type: "unregister-provider",
+			id: providerId
+		});
+		return true;
+	}
+	getPassNames() {
+		return [...this.passNames];
+	}
+	getMetrics() {
+		return { ...this.metrics };
+	}
+	getContextState() {
+		if (this.contextState) return this.contextState;
+		return Object.freeze({
+			capabilities: {
+				isWebGL2: false,
+				supportsFloatColorBuffer: false,
+				supportsFloatTexture: false,
+				supportsFloatTextureLinear: false
+			},
+			webglVersion: 1
+		});
+	}
+	/**
+	* Last encoded thumbnail for a pass, or null until the worker round-trip
+	* completes. Call {@link requestPassCapture} first (e.g. on a poll
+	* interval); the following read observes the fresh frame.
+	*/
+	capturePassDataURL(name, maxSize = 64) {
+		return this.thumbnails.get(thumbnailKey(name, maxSize)) ?? null;
+	}
+	/** Ask the worker to capture and push a fresh thumbnail for `name`. */
+	requestPassCapture(name, maxSize = 64) {
+		this.captureId += 1;
+		this.post({
+			type: "capture",
+			id: this.captureId,
+			name,
+			maxSize
+		});
+	}
+	addPass(_pass) {
+		throw new Error("[Actis] addPass() requires mode: \"main\" — Pass objects cannot cross the worker boundary. Use setup() with a RendererConfig instead.");
+	}
+	getPass(_name) {
+		throw new Error("[Actis] getPass() requires mode: \"main\" — Pass objects cannot cross the worker boundary.");
+	}
+	getPasses() {
+		throw new Error("[Actis] getPasses() requires mode: \"main\" — Pass objects cannot cross the worker boundary. Use getPassNames() instead.");
+	}
+	forEachPass(_callback) {
+		throw new Error("[Actis] forEachPass() requires mode: \"main\" — Pass objects cannot cross the worker boundary.");
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.detachHost?.();
+		try {
+			this.worker.postMessage({ type: "dispose" });
+		} catch {}
+		this.worker.terminate();
 	}
 };
 //#endregion
-export { Pass, Shader, WebGLRenderer };
+//#region src/worker/createRenderer.ts
+var WorkerUnsupportedError = class extends Error {
+	constructor(reason, options) {
+		super(`[Actis] Offscreen worker renderer unavailable: ${reason}`, options);
+		this.name = "WorkerUnsupportedError";
+		this.reason = reason;
+	}
+};
+/**
+* Canvases already handed to a worker. Transfer is irreversible and the DOM
+* exposes no "transferred" flag, so the factory stamps every canvas it
+* transfers to fail fast with a clear error instead of a raw DOMException.
+*/
+const transferredCanvases = /* @__PURE__ */ new WeakSet();
+/**
+* Whether this canvas was already transferred by {@link createRenderer}.
+* A stamped canvas can never render on the main thread again — mount a
+* fresh element and dispose the previous renderer first.
+*/
+function isCanvasAlreadyTransferred(canvas) {
+	return transferredCanvases.has(canvas);
+}
+function resolveWorkerUrl(explicit) {
+	if (explicit) return explicit;
+	try {
+		const entry = import.meta.url.endsWith(".ts") ? "./worker-entry.ts" : "./worker-entry.mjs";
+		return new URL(entry, import.meta.url).href;
+	} catch {
+		return null;
+	}
+}
+/** Cheap pre-flight: no GPU at all means the worker path cannot succeed. */
+function hasWebGL() {
+	try {
+		if (typeof document === "undefined") return false;
+		const canvas = document.createElement("canvas");
+		return !!(canvas.getContext("webgl2") || canvas.getContext("webgl"));
+	} catch {
+		return false;
+	}
+}
+function canTransfer(canvas) {
+	return typeof canvas.transferControlToOffscreen === "function";
+}
+function spawnWorker(url) {
+	return new Worker(url, {
+		type: "module",
+		name: "actis-renderer"
+	});
+}
+function waitForReady(worker, timeoutMs) {
+	return new Promise((resolve, reject) => {
+		const timer = typeof setTimeout !== "undefined" ? setTimeout(() => {
+			worker.onmessage = null;
+			reject(/* @__PURE__ */ new Error("handshake-timeout"));
+		}, timeoutMs) : null;
+		worker.onmessage = (event) => {
+			const data = event.data;
+			if (data?.type === "ready") {
+				if (timer !== null && typeof clearTimeout !== "undefined") clearTimeout(timer);
+				worker.onmessage = null;
+				if (data.version !== 1) {
+					reject(/* @__PURE__ */ new Error("version-mismatch"));
+					return;
+				}
+				resolve();
+			}
+		};
+		worker.onerror = () => {
+			if (timer !== null && typeof clearTimeout !== "undefined") clearTimeout(timer);
+			reject(/* @__PURE__ */ new Error("spawn-failed"));
+		};
+	});
+}
+/**
+* Create a renderer, worker-first by default.
+*
+* `auto` probes `Worker` -> `transferControlToOffscreen` -> WebGL ->
+* handshake, falling back to the main-thread `WebGLRenderer` at the first
+* failure (`onFallback` reports why). `worker` throws
+* {@link WorkerUnsupportedError} instead of falling back; `main` always
+* constructs {@link WebGLRenderer} directly.
+*
+* Note: transferring a canvas is irreversible. A GPU that works on the main
+* thread is assumed to work in the worker; the pre-flight probe plus versioned
+* handshake make a post-transfer failure unlikely. If the worker still dies
+* after transfer, the canvas cannot be recovered on the main thread, so
+* creation throws {@link WorkerUnsupportedError} (`worker-transferred-fatal`)
+* even in `auto` mode.
+*/
+async function createRenderer(canvas, options = {}) {
+	const { mode = "auto", onFallback, onError, handshakeTimeoutMs = 2e3, attachHost = true } = options;
+	const strict = mode === "worker";
+	const fail = (reason) => {
+		if (strict) throw new WorkerUnsupportedError(reason);
+		onFallback?.(reason);
+		if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") console.info(`[Actis] Offscreen worker unavailable (${reason}); using main-thread renderer.`);
+		try {
+			return new WebGLRenderer(canvas, onError);
+		} catch (error) {
+			throw new WorkerUnsupportedError(reason, { cause: error });
+		}
+	};
+	if (mode === "main" || typeof window === "undefined" || typeof document === "undefined") {
+		if (mode === "main") {
+			if (isCanvasAlreadyTransferred(canvas)) throw new WorkerUnsupportedError("canvas-already-bound", { cause: /* @__PURE__ */ new Error("This canvas was transferred to a worker by a previous createRenderer() call. Transfer is irreversible: dispose the previous renderer and mount a fresh canvas element.") });
+			return new WebGLRenderer(canvas, onError);
+		}
+		return fail("ssr-no-dom");
+	}
+	if (isCanvasAlreadyTransferred(canvas)) {
+		const err = new WorkerUnsupportedError("canvas-already-bound", { cause: /* @__PURE__ */ new Error("This canvas was transferred to a worker by a previous createRenderer() call. Transfer is irreversible: dispose the previous renderer and mount a fresh canvas element.") });
+		if (strict) throw err;
+		onFallback?.("canvas-already-bound");
+		throw err;
+	}
+	if (typeof Worker === "undefined" && !options.worker) return fail("no-worker");
+	if (!canTransfer(canvas)) return fail("no-offscreen-canvas");
+	if (!hasWebGL()) return fail("no-webgl");
+	let worker = options.worker ?? null;
+	if (!worker) {
+		const workerUrl = resolveWorkerUrl(options.workerUrl);
+		if (!workerUrl) return fail("worker-spawn-failed");
+		try {
+			worker = spawnWorker(workerUrl);
+		} catch {
+			return fail("worker-spawn-failed");
+		}
+	}
+	try {
+		await waitForReady(worker, handshakeTimeoutMs);
+	} catch (error) {
+		worker.terminate();
+		const message = error?.message;
+		return fail(message === "version-mismatch" ? "worker-version-mismatch" : message === "spawn-failed" ? "worker-spawn-failed" : "worker-handshake-timeout");
+	}
+	const rectWidth = Math.max(1, Math.floor(canvas.clientWidth || 1));
+	const rectHeight = Math.max(1, Math.floor(canvas.clientHeight || 1));
+	const pixelRatio = window.devicePixelRatio || 1;
+	let offscreen;
+	try {
+		offscreen = canvas.transferControlToOffscreen();
+		transferredCanvases.add(canvas);
+	} catch {
+		worker.terminate();
+		return fail("no-offscreen-canvas");
+	}
+	const hosted = new OffscreenWebGLRenderer(canvas, worker, { onError });
+	if (attachHost) hosted.setDetachHost(attachRendererHost(canvas, {
+		setDisplaySize: (w, h) => hosted.setDisplaySize(w, h),
+		setPixelRatio: (r) => hosted.setPixelRatio(r),
+		setPointer: (x, y) => hosted.setPointer(x, y),
+		get realToCSSPixels() {
+			return hosted.realToCSSPixels;
+		}
+	}));
+	const init = {
+		type: "init",
+		version: 1,
+		canvas: offscreen,
+		width: Math.max(1, Math.floor(rectWidth * pixelRatio)),
+		height: Math.max(1, Math.floor(rectHeight * pixelRatio)),
+		pixelRatio
+	};
+	const firstEvent = await new Promise((resolve) => {
+		const timer = typeof setTimeout !== "undefined" ? setTimeout(resolve, handshakeTimeoutMs, null) : null;
+		const done = (value) => {
+			if (timer !== null && typeof clearTimeout !== "undefined") clearTimeout(timer);
+			worker.onmessage = null;
+			resolve(value);
+		};
+		worker.onmessage = (event) => {
+			const data = event.data;
+			if (data?.type === "fatal") done(data);
+			else if (data?.type === "context" || data?.type === "metrics" || data?.type === "error") done(data);
+		};
+		worker.onerror = () => done({
+			type: "fatal",
+			reason: "worker-gl-unavailable"
+		});
+		try {
+			worker.postMessage(init, [offscreen]);
+		} catch {
+			done({
+				type: "fatal",
+				reason: "worker-gl-unavailable"
+			});
+		}
+	});
+	if (firstEvent === null || firstEvent.type === "fatal") {
+		worker.terminate();
+		hosted.dispose();
+		const mapped = (firstEvent?.reason ?? "").startsWith("version-mismatch") ? "worker-version-mismatch" : "worker-gl-unavailable";
+		onFallback?.("worker-transferred-fatal");
+		throw new WorkerUnsupportedError(mapped);
+	}
+	hosted.connect(firstEvent);
+	return hosted;
+}
+//#endregion
+export { FBO, OffscreenWebGLRenderer, Pass, Pipeline, RendererCore, Shader, TEXTURE_CHANNEL_COUNT, Texture, WebGLRenderer, WorkerUnsupportedError, createRenderer, isCanvasAlreadyTransferred, rafFrameDriver, timerFrameDriver };