@simpludify/core 0.1.4 → 0.1.5

package/dist/index.js

@@ -1583,7 +1583,7 @@ var RandomManager = class {
 };
 // packages/core/src/foundation/version.ts
 /** Source workspace version; checked against package.json by the build validator. */
-var ENGINE_VERSION = "0.1.4";
+var ENGINE_VERSION = "0.1.5";
 // packages/core/src/scene/actor.ts
 var inputPhase$1 = ComponentPhase.Input;
 var updatePhase$1 = ComponentPhase.Update;
@@ -4877,6 +4877,10 @@ var InputSystem = class {
 	dead = false;
 	playback = false;
 	frames;
+	/** @internal Device hosts may reject live gestures during Replay playback. */
+	get liveInput() {
+		return !this.dead && !this.playback;
+	}
 	get sourceCount() {
 		let count = this.keyboards.size;
 		for (const actions of this.actions) count += actions.sourceCount;
@@ -5309,6 +5313,18 @@ var ScenePointer = class {
 	lifetime = new Lifetime();
 	events = new EventBus();
 	removeScene;
+	targets;
+	/** @internal Exactly one Scene virtual-input provider shares the existing router. */
+	attachTargets(provider) {
+		if (this.disposed || this.targets) throw new EngineError("INVALID_VIRTUAL_INPUT", "Scene already has virtual input or is disposed");
+		this.targets = provider;
+		return () => {
+			if (this.targets === provider) this.targets = void 0;
+		};
+	}
+	/** @internal */ pickTarget(data) {
+		return this.targets?.disposed ? void 0 : this.targets?.pick(data);
+	}
 	constructor(scene) {
 		this.scene = scene;
 		this.removeScene = scene.onDispose(() => this.dispose());
@@ -5331,6 +5347,7 @@ var ScenePointer = class {
 /** @internal Device-independent routing state; DOM is only an adapter. */
 var PointerRouting = class {
 	released;
+	targetOwners = /* @__PURE__ */ new Map();
 	controlOwners = /* @__PURE__ */ new Map();
 	scrollOwners = /* @__PURE__ */ new Map();
 	suppressed = /* @__PURE__ */ new Set();
@@ -5355,7 +5372,8 @@ var PointerRouting = class {
 			keyboardNodes: this.keys.size,
 			deliveries: this.deliveries,
 			scrollDrags: this.scrollOwners.size,
-			controlDrags: this.controlOwners.size
+			controlDrags: this.controlOwners.size,
+			virtualDrags: this.targetOwners.size
 		};
 	}
 	setScene(channel, ui) {
@@ -5381,6 +5399,14 @@ var PointerRouting = class {
 		}
 	}
 	emit(gesture, type, info) {
+		if (gesture.target) {
+			const phase = type === PointerDown ? "down" : type === PointerMove ? "move" : type === PointerUp ? "up" : type === PointerCancel ? "cancel" : void 0;
+			if (phase) {
+				this.deliveries++;
+				gesture.target.deliver(phase, info);
+			}
+			return;
+		}
 		if (gesture.channel.disposed || gesture.node?.disposed) return;
 		this.deliveries++;
 		(gesture.node?.events ?? gesture.channel.events).emit(type, info);
@@ -5388,7 +5414,7 @@ var PointerRouting = class {
 	inside(g, data) {
 		return Object.freeze({
 			...data,
-			inside: g.scroll && g.ui ? g.ui.containsNode(g.scroll, data.screen.x / g.ui.scale, data.screen.y / g.ui.scale) : g.node ? g.ui?.hitTest(data.screen.x / g.ui.scale, data.screen.y / g.ui.scale) === g.node : data.inside
+			inside: g.target ? g.target.contains(data) : g.scroll && g.ui ? g.ui.containsNode(g.scroll, data.screen.x / g.ui.scale, data.screen.y / g.ui.scale) : g.node ? g.ui?.hitTest(data.screen.x / g.ui.scale, data.screen.y / g.ui.scale) === g.node : data.inside
 		});
 	}
 	down(data) {
@@ -5398,6 +5424,11 @@ var PointerRouting = class {
 		this.suppressed.delete(data.pointerId);
 		const pick = this.ui?.pick(data.screen.x / this.ui.scale, data.screen.y / this.ui.scale);
 		const node = pick?.node, bar = pick?.bar;
+		const target = !node && data.button === 0 ? this.channel.pickTarget(data) : void 0;
+		if (target && this.targetOwners.has(target)) {
+			this.suppressed.add(data.pointerId);
+			return;
+		}
 		if (bar && data.button === 0 && (!bar.enabled || this.scrollOwners.has(bar.node))) {
 			this.suppressed.add(data.pointerId);
 			return node;
@@ -5406,20 +5437,24 @@ var PointerRouting = class {
 			this.suppressed.add(data.pointerId);
 			return node;
 		}
-		if (!node && !data.inside) return;
+		if (!node && !target && !data.inside) return;
 		const g = {
 			channel: this.channel,
 			last: data,
 			primary: data.button === 0,
 			start: data,
 			scale: this.ui?.scale ?? 1,
-			candidates: this.ui?.scrollTargets(data.screen.x / this.ui.scale, data.screen.y / this.ui.scale) ?? [],
+			candidates: !target ? this.ui?.scrollTargets(data.screen.x / this.ui.scale, data.screen.y / this.ui.scale) ?? [] : [],
 			candidateRevisions: [],
 			vx: 0,
 			vy: 0,
 			...node ? {
 				node,
 				ui: this.ui
+			} : {},
+			...target ? {
+				target,
+				targetRevision: target.revision
 			} : {}
 		};
 		g.candidateRevisions = g.candidates.map((n) => n.scrollRevision);
@@ -5441,6 +5476,17 @@ var PointerRouting = class {
 		if (node?.control) g.controlRevision = node.control.revision;
 		this.gestures.set(data.pointerId, g);
 		if (node) g.off = node.onDispose(() => this.cancel(data.pointerId));
+		if (target) {
+			this.targetOwners.set(target, data.pointerId);
+			const off = target.subscribe(() => {
+				if (!target.available || target.revision !== g.targetRevision) this.cancel(data.pointerId);
+			});
+			const disposed = target.onDispose(() => this.cancel(data.pointerId));
+			g.off = () => {
+				off();
+				disposed();
+			};
+		}
 		cleanupAll([
 			() => {
 				const port = node?.control;
@@ -5498,7 +5544,7 @@ var PointerRouting = class {
 				const dx = Math.abs(data.screen.x - g.start.screen.x), dy = Math.abs(data.screen.y - g.start.screen.y);
 				if (dx >= g.control.style.dragThreshold && dx > dy) g.controlLocked = true;
 			}
-			if (!g.scroll && g.primary && !g.controlLocked) this.claimScroll(g, data);
+			if (!g.target && !g.scroll && g.primary && !g.controlLocked) this.claimScroll(g, data);
 			if (this.gestures.get(data.pointerId) !== g) return;
 			if (g.bar && g.scroll && g.ui) {
 				const bar = canvasScrollbars(g.scroll).find((b) => b.axis === g.bar?.axis);
@@ -5639,6 +5685,7 @@ var PointerRouting = class {
 		g = this.gestures.get(data.pointerId);
 		if (!g) return;
 		this.gestures.delete(data.pointerId);
+		if (g.target) this.targetOwners.delete(g.target);
 		if (g.control) this.controlOwners.delete(g.control);
 		if (g.scroll) {
 			this.scrollOwners.delete(g.scroll);
@@ -5656,7 +5703,7 @@ var PointerRouting = class {
 				if (!g.node || g.node.available) this.emit(g, PointerUp, info);
 			},
 			() => {
-				if (!g.scroll && g.primary && info.inside && (!g.node || g.node.available)) this.emit(g, PointerClick, info);
+				if (!g.target && !g.scroll && g.primary && info.inside && (!g.node || g.node.available)) this.emit(g, PointerClick, info);
 			},
 			() => {
 				if (!g.scroll && g.primary && info.inside && g.node?.available) g.node.activate("pointer");
@@ -5668,6 +5715,7 @@ var PointerRouting = class {
 		const g = this.gestures.get(id);
 		if (!g) return;
 		this.gestures.delete(id);
+		if (g.target) this.targetOwners.delete(g.target);
 		if (g.control) this.controlOwners.delete(g.control);
 		if (g.scroll) {
 			this.scrollOwners.delete(g.scroll);
@@ -5738,6 +5786,10 @@ var PointerRouting = class {
 			...[...this.keys.keys()].map((n) => () => this.releaseKeys(n))
 		], "Pointer release failed");
 	}
+	/** @internal Host focus changes interrupt virtual devices without changing Canvas editing rules. */
+	releaseVirtual() {
+		cleanupAll([...this.gestures].filter(([, g]) => g.target).map(([id]) => () => this.cancel(id)), "Virtual pointer release failed");
+	}
 	dispose() {
 		try {
 			this.reset();
@@ -5753,6 +5805,716 @@ var PointerRouting = class {
 		cleanupAll([...off, () => this.release()], "Pointer routing cleanup failed");
 	}
 };
+// packages/core/src/interaction/virtual-regions.ts
+var VirtualRegions = Object.freeze({
+	/** A shared edge is not an overlap. Use separate rectangles to leave a center gap. */
+	Left: Object.freeze({
+		kind: "rect",
+		x: 0,
+		y: 0,
+		width: .5,
+		height: 1
+	}),
+	Right: Object.freeze({
+		kind: "rect",
+		x: .5,
+		y: 0,
+		width: .5,
+		height: 1
+	})
+});
+/** @internal */
+function virtualFinite(value, field) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new EngineError("INVALID_VIRTUAL_INPUT", `${field} must be finite`);
+	return value;
+}
+/** @internal */
+function virtualBounds(value) {
+	const result = {
+		x: virtualFinite(value.x, "x"),
+		y: virtualFinite(value.y, "y"),
+		width: virtualFinite(value.width, "width"),
+		height: virtualFinite(value.height, "height")
+	};
+	if (result.width < 0 || result.height < 0 || !Number.isFinite(result.x + result.width) || !Number.isFinite(result.y + result.height)) throw new EngineError("INVALID_VIRTUAL_INPUT", "Region extents must be finite and nonnegative");
+	return Object.freeze(result);
+}
+/** @internal */
+function virtualPosition(value, viewport) {
+	const space = value.space ?? "viewport";
+	if (space !== "viewport" && space !== "screen") throw new EngineError("INVALID_VIRTUAL_INPUT", "Unknown virtual coordinate space");
+	const x = virtualFinite(value.x, "position.x"), y = virtualFinite(value.y, "position.y");
+	return Object.freeze(space === "screen" ? {
+		x,
+		y
+	} : {
+		x: virtualFinite(viewport.x + x * viewport.width, "resolved x"),
+		y: virtualFinite(viewport.y + y * viewport.height, "resolved y")
+	});
+}
+/** @internal Copy configuration before retaining it. Predicate functions are deliberately live. */
+function checkedVirtualRegion(region) {
+	if (!region || ![
+		"rect",
+		"circle",
+		"custom"
+	].includes(region.kind)) throw new EngineError("INVALID_VIRTUAL_INPUT", "Unknown activation region");
+	const copy = Object.freeze({ ...region });
+	if (copy.kind === "custom") {
+		if (typeof copy.bounds !== "function" || typeof copy.contains !== "function") throw new EngineError("INVALID_VIRTUAL_INPUT", "Custom regions require bounds and contains");
+	} else resolveVirtualRegion(copy, {
+		x: 0,
+		y: 0,
+		width: 1,
+		height: 1
+	});
+	return copy;
+}
+/** @internal */
+function resolveVirtualRegion(region, viewport) {
+	if (region.kind === "custom") {
+		if (typeof region.bounds !== "function" || typeof region.contains !== "function") throw new EngineError("INVALID_VIRTUAL_INPUT", "Custom regions require bounds and contains functions");
+		return {
+			kind: "custom",
+			bounds: virtualBounds(region.bounds(viewport)),
+			test: region.contains
+		};
+	}
+	const center = virtualPosition(region, viewport);
+	if (region.kind === "rect") {
+		const relative = (region.space ?? "viewport") === "viewport";
+		const width = virtualFinite(region.width, "region.width"), height = virtualFinite(region.height, "region.height");
+		if (width < 0 || height < 0) throw new EngineError("INVALID_VIRTUAL_INPUT", "Region sizes must be nonnegative");
+		return {
+			kind: "rect",
+			bounds: virtualBounds({
+				...center,
+				width: width * (relative ? viewport.width : 1),
+				height: height * (relative ? viewport.height : 1)
+			})
+		};
+	}
+	const radius = virtualFinite(region.radius, "region.radius") * ((region.space ?? "viewport") === "viewport" ? Math.min(viewport.width, viewport.height) : 1);
+	if (radius < 0) throw new EngineError("INVALID_VIRTUAL_INPUT", "Region radius must be nonnegative");
+	return {
+		kind: "circle",
+		center,
+		radius,
+		bounds: virtualBounds({
+			x: center.x - radius,
+			y: center.y - radius,
+			width: radius * 2,
+			height: radius * 2
+		})
+	};
+}
+/** @internal Rectangles are half-open; circles exclude their circumference. */
+function virtualContains(region, point, viewport) {
+	const b = region.bounds;
+	if (point.x < b.x || point.y < b.y || point.x >= b.x + b.width || point.y >= b.y + b.height) return false;
+	if (region.kind === "circle") return Math.hypot(point.x - region.center.x, point.y - region.center.y) < region.radius;
+	if (region.kind === "custom") {
+		const value = region.test(point, viewport);
+		if (typeof value !== "boolean") throw new EngineError("INVALID_VIRTUAL_INPUT", "Custom region predicate must return boolean");
+		return value;
+	}
+	return true;
+}
+/** @internal Exact built-in intersection; custom bounds are conservatively ambiguous. */
+function virtualOverlap(a, b) {
+	const x = a.bounds, y = b.bounds;
+	if (Math.min(x.x + x.width, y.x + y.width) <= Math.max(x.x, y.x) || Math.min(x.y + x.height, y.y + y.height) <= Math.max(x.y, y.y)) return false;
+	if (a.kind === "circle" && b.kind === "circle") return Math.hypot(a.center.x - b.center.x, a.center.y - b.center.y) < a.radius + b.radius;
+	const circle = a.kind === "circle" ? a : b.kind === "circle" ? b : void 0;
+	const rect = a.kind === "circle" ? b : a;
+	if (circle && rect.kind === "rect") {
+		const c = circle.center, r = rect.bounds;
+		return Math.hypot(c.x - Math.max(r.x, Math.min(r.x + r.width, c.x)), c.y - Math.max(r.y, Math.min(r.y + r.height, c.y))) < circle.radius;
+	}
+	return true;
+}
+// packages/core/src/interaction/virtual-control.ts
+var VirtualStickMode = {
+	Fixed: "fixed",
+	Floating: "floating",
+	Follow: "follow"
+};
+var screenPoint$1 = (x, y) => ({
+	space: "screen",
+	x: virtualFinite(x, "screen.x"),
+	y: virtualFinite(y, "screen.y")
+});
+var zero = Object.freeze({
+	x: 0,
+	y: 0
+});
+var Start = defineEvent("VirtualStart");
+var Change = defineEvent("VirtualChange");
+var End = defineEvent("VirtualEnd");
+var Cancel = defineEvent("VirtualCancel");
+var Hold = defineEvent("VirtualHold");
+function flag(value) {
+	if (typeof value !== "boolean") throw new EngineError("INVALID_VIRTUAL_INPUT", "Virtual control flags must be boolean");
+	return value;
+}
+function zone(value) {
+	virtualFinite(value, "deadZone");
+	if (value < 0 || value >= 1) throw new EngineError("INVALID_VIRTUAL_INPUT", "Dead zone must satisfy 0 <= value < 1");
+	return value;
+}
+function mode(value) {
+	if (!Object.values(VirtualStickMode).includes(value)) throw new EngineError("INVALID_VIRTUAL_INPUT", "Unknown virtual stick mode");
+	return value;
+}
+/** @internal Validate before allocating ActionSources or registering a target. */
+function checkVirtualOptions(options) {
+	checkedVirtualRegion(options.region);
+	positive(options.radius ?? 64, "radius");
+	zone(options.deadZone ?? .15);
+	flag(options.enabled ?? true);
+	flag(options.visible ?? true);
+	flag(options.direction ?? false);
+	mode(options.mode ?? VirtualStickMode.Fixed);
+	if (virtualFinite(options.holdDelay ?? .5, "holdDelay") < 0) throw new EngineError("INVALID_VIRTUAL_INPUT", "Hold delay must be nonnegative");
+	if (options.position) {
+		virtualFinite(options.position.x, "position.x");
+		virtualFinite(options.position.y, "position.y");
+		if (options.position.space !== void 0 && options.position.space !== "screen" && options.position.space !== "viewport") throw new EngineError("INVALID_VIRTUAL_INPUT", "Unknown position space");
+	}
+	const color = options.color ?? 6736821;
+	if (!Number.isInteger(color) || color < 0 || color > 16777215) throw new EngineError("INVALID_VIRTUAL_INPUT", "Virtual color must be RGB");
+}
+/** Portable gesture state. Routing, Action composition and rendering retain their existing owners. */
+var VirtualControl = class {
+	kind;
+	host;
+	binding;
+	life = new Lifetime();
+	events = new EventBus();
+	observers = /* @__PURE__ */ new Set();
+	activation;
+	activeFlag;
+	shown;
+	size;
+	deadZoneValue;
+	version = 0;
+	gesture;
+	vector = zero;
+	dragMode;
+	position;
+	holdDelay;
+	color;
+	directional;
+	constructor(kind, options, host, binding) {
+		this.kind = kind;
+		this.host = host;
+		this.binding = binding;
+		checkVirtualOptions(options);
+		this.activation = checkedVirtualRegion(options.region);
+		this.position = options.position ? Object.freeze({ ...options.position }) : void 0;
+		this.activeFlag = options.enabled ?? true;
+		this.shown = options.visible ?? true;
+		this.size = options.radius ?? (kind === "stick" ? 64 : 28);
+		this.deadZoneValue = options.deadZone ?? .15;
+		this.dragMode = mode(options.mode ?? VirtualStickMode.Fixed);
+		this.holdDelay = options.holdDelay ?? .5;
+		this.color = options.color ?? 6736821;
+		this.directional = kind === "stick" || (options.direction ?? false);
+		this.life.onDispose(binding.onDispose(() => this.dispose()));
+	}
+	get disposed() {
+		return this.life.disposed;
+	}
+	get available() {
+		return !this.disposed && this.activeFlag && this.host.available() && this.binding.active();
+	}
+	get revision() {
+		return this.version;
+	}
+	get enabled() {
+		return this.activeFlag;
+	}
+	set enabled(value) {
+		this.alive();
+		const next = flag(value);
+		if (next === this.activeFlag) return;
+		this.activeFlag = next;
+		this.interrupt();
+	}
+	get visible() {
+		return this.shown;
+	}
+	set visible(value) {
+		this.alive();
+		this.shown = flag(value);
+	}
+	get radius() {
+		return this.size;
+	}
+	set radius(value) {
+		this.alive();
+		const next = positive(value, "radius");
+		if (next === this.size) return;
+		this.size = next;
+		this.interrupt();
+	}
+	get deadZone() {
+		return this.deadZoneValue;
+	}
+	set deadZone(value) {
+		this.alive();
+		const next = zone(value);
+		if (next === this.deadZoneValue) return;
+		this.deadZoneValue = next;
+		this.interrupt();
+	}
+	get region() {
+		return this.activation;
+	}
+	set region(value) {
+		this.alive();
+		const next = checkedVirtualRegion(value);
+		this.host.region(this, next);
+		this.activation = next;
+		this.interrupt();
+	}
+	get stickMode() {
+		return this.dragMode;
+	}
+	set stickMode(value) {
+		this.alive();
+		const next = mode(value);
+		if (next === this.dragMode) return;
+		this.dragMode = next;
+		this.interrupt();
+	}
+	get pointerId() {
+		return this.gesture?.last.pointerId;
+	}
+	get pressed() {
+		return this.gesture !== void 0;
+	}
+	get elapsed() {
+		return this.gesture?.elapsed ?? 0;
+	}
+	get direction() {
+		return this.vector;
+	}
+	get center() {
+		const p = this.gesture?.center ?? this.host.center(this);
+		return Object.freeze(screenPoint$1(p.x, p.y));
+	}
+	get knob() {
+		const center = this.center, last = this.gesture?.last.screen;
+		if (!last || !this.directional) return center;
+		const origin = this.kind === "button" ? this.gesture?.origin ?? center : center;
+		const dx = last.x - origin.x, dy = last.y - origin.y, length = Math.hypot(dx, dy);
+		const scale = length > this.size ? this.size / length : 1;
+		return Object.freeze(screenPoint$1(center.x + dx * scale, center.y + dy * scale));
+	}
+	onDispose(callback) {
+		return this.life.onDispose(callback);
+	}
+	/** @internal Geometry/availability invalidation, not a per-frame observer. */
+	subscribe(callback) {
+		this.alive();
+		this.observers.add(callback);
+		return () => {
+			this.observers.delete(callback);
+		};
+	}
+	onStart(callback, owner) {
+		return this.events.on(Start, callback, owner);
+	}
+	onChange(callback, owner) {
+		return this.events.on(Change, callback, owner);
+	}
+	onEnd(callback, owner) {
+		return this.events.on(End, callback, owner);
+	}
+	onCancel(callback, owner) {
+		return this.events.on(Cancel, callback, owner);
+	}
+	onHold(callback, owner) {
+		return this.events.on(Hold, callback, owner);
+	}
+	/** Release/cancel only; the captured physical ID stays suppressed until its release. */
+	cancel() {
+		this.alive();
+		this.interrupt();
+	}
+	/** @internal */
+	invalidate() {
+		this.interrupt();
+	}
+	alive() {
+		if (this.disposed) throw new EngineError("OWNER_DISPOSED", "Virtual control has been disposed");
+	}
+	interrupt() {
+		this.version++;
+		cleanupAll([...[...this.observers], () => {
+			if (this.gesture) this.finish(true);
+			else this.binding.clear();
+		}], "Virtual gesture interruption failed");
+	}
+	contains(data) {
+		return this.host.contains(this, data);
+	}
+	snapshot(g) {
+		return Object.freeze({
+			control: this,
+			pointerId: g.last.pointerId,
+			pointerType: g.last.pointerType,
+			origin: g.origin,
+			position: Object.freeze(screenPoint$1(g.last.screen.x, g.last.screen.y)),
+			center: g.center,
+			direction: this.vector,
+			inside: this.contains(g.last),
+			elapsed: g.elapsed
+		});
+	}
+	update(g) {
+		if (!this.directional) {
+			this.vector = zero;
+			return;
+		}
+		const start = this.kind === "button" ? g.origin : g.center;
+		const dx = g.last.screen.x - start.x, dy = g.last.screen.y - start.y;
+		const length = Math.hypot(dx, dy);
+		if (this.kind === "stick" && this.dragMode === VirtualStickMode.Follow && length > this.size) g.center = Object.freeze(screenPoint$1(g.last.screen.x - dx * this.size / length, g.last.screen.y - dy * this.size / length));
+		const magnitude = Math.min(1, length / this.size);
+		const output = magnitude <= this.deadZoneValue ? 0 : (magnitude - this.deadZoneValue) / (1 - this.deadZoneValue);
+		this.vector = output === 0 ? zero : Object.freeze({
+			x: dx / length * output,
+			y: dy / length * output
+		});
+	}
+	deliver(type, data) {
+		if (type === "cancel") {
+			if (this.gesture?.last.pointerId === data.pointerId) this.finish(true);
+			return;
+		}
+		if (type === "down") {
+			if (!this.available || this.gesture) return;
+			const center = this.kind === "stick" && this.dragMode !== VirtualStickMode.Fixed ? data.screen : this.host.center(this);
+			const g = {
+				last: data,
+				origin: Object.freeze(screenPoint$1(data.screen.x, data.screen.y)),
+				center: Object.freeze(screenPoint$1(center.x, center.y)),
+				elapsed: 0,
+				held: false
+			};
+			this.gesture = g;
+			this.update(g);
+			this.binding.write(this.vector, true);
+			const event = this.snapshot(g);
+			cleanupAll([() => this.events.emit(Start, event), () => {
+				if (this.gesture === g) this.events.emit(Change, event);
+			}], "Virtual start handlers failed");
+			return;
+		}
+		const g = this.gesture;
+		if (!g || g.last.pointerId !== data.pointerId) return;
+		if (!this.available) {
+			this.interrupt();
+			return;
+		}
+		if (data.screen.x !== g.last.screen.x || data.screen.y !== g.last.screen.y) {
+			g.last = data;
+			this.update(g);
+			this.binding.write(this.vector, true);
+			this.events.emit(Change, this.snapshot(g));
+		}
+		if (type === "up" && this.gesture === g) {
+			g.last = data;
+			this.finish(false);
+		}
+	}
+	/** @internal Explicit presentation clock; no browser/OS timer in Core. */
+	advance(seconds) {
+		const g = this.gesture;
+		if (!g) return;
+		if (!this.available) {
+			this.interrupt();
+			return;
+		}
+		g.elapsed += seconds;
+		if (!g.held && g.elapsed >= this.holdDelay) {
+			g.held = true;
+			this.events.emit(Hold, this.snapshot(g));
+		}
+	}
+	finish(cancelled) {
+		const g = this.gesture;
+		if (!g) return;
+		let event;
+		try {
+			event = this.snapshot(g);
+		} finally {
+			this.gesture = void 0;
+			this.vector = zero;
+			this.binding.clear();
+		}
+		this.events.emit(cancelled ? Cancel : End, event);
+	}
+	dispose() {
+		if (this.disposed) return;
+		cleanupAll([
+			() => this.life.dispose(),
+			() => this.interrupt(),
+			() => this.binding.dispose(),
+			() => this.events.dispose(),
+			() => this.observers.clear(),
+			() => this.host.remove(this)
+		], "Virtual control cleanup failed");
+	}
+};
+var VirtualStick = class extends VirtualControl {
+	/** @internal Use VirtualInput.stick. */
+	constructor(options, host, binding) {
+		super("stick", options, host, binding);
+	}
+	get value() {
+		return this.direction;
+	}
+	get mode() {
+		return this.stickMode;
+	}
+	set mode(value) {
+		this.stickMode = value;
+	}
+};
+var VirtualButton = class extends VirtualControl {
+	/** @internal Use VirtualInput.button. */
+	constructor(options, host, binding) {
+		super("button", options, host, binding);
+	}
+	get value() {
+		return this.pressed;
+	}
+	/** Confirmation on normal release, including a drag outside the activation region; never on cancel. */
+	onCommit(callback, owner) {
+		return this.onEnd(callback, owner);
+	}
+};
+// packages/core/src/interaction/virtual-input.ts
+/** Scene-scoped virtual devices; all gameplay values flow through existing ActionSources. */
+var VirtualInput = class {
+	pointer;
+	input;
+	life = new Lifetime();
+	list = Object.freeze([]);
+	regions = /* @__PURE__ */ new Map();
+	anchors = /* @__PURE__ */ new Map();
+	view = Object.freeze({
+		x: 0,
+		y: 0,
+		width: 800,
+		height: 450
+	});
+	active = true;
+	shown = true;
+	dirty = true;
+	host;
+	constructor(pointer, input) {
+		this.pointer = pointer;
+		this.input = input;
+		if (pointer.disposed) throw new EngineError("OWNER_DISPOSED", "Scene pointer has been disposed");
+		this.host = {
+			available: () => !this.disposed && this.active && input.liveInput,
+			center: (control) => this.anchors.get(control) ?? {
+				x: 0,
+				y: 0
+			},
+			contains: (control, data) => {
+				const region = this.regions.get(control);
+				return region ? virtualContains(region, data.screen, this.view) : false;
+			},
+			region: (control, region) => {
+				const regions = this.resolve(this.view, control, region);
+				this.regions = regions;
+				this.anchors = this.centers(regions, this.view);
+				this.dirty = true;
+			},
+			remove: (control) => {
+				this.list = Object.freeze(this.list.filter((c) => c !== control));
+				this.regions.delete(control);
+				this.anchors.delete(control);
+			}
+		};
+		try {
+			this.life.onDispose(pointer.attachTargets(this));
+			this.life.onDispose(input.addAdapter(this));
+			this.life.onDispose(pointer.onDispose(() => this.dispose()));
+		} catch (error) {
+			this.life.dispose();
+			throw error;
+		}
+	}
+	get disposed() {
+		return this.life.disposed;
+	}
+	get controls() {
+		return this.list;
+	}
+	get viewport() {
+		return this.view;
+	}
+	get enabled() {
+		return this.active;
+	}
+	set enabled(value) {
+		this.alive();
+		this.flag(value);
+		if (this.active === value) return;
+		this.active = value;
+		this.reset();
+	}
+	get visible() {
+		return this.shown;
+	}
+	set visible(value) {
+		this.alive();
+		this.flag(value);
+		this.shown = value;
+	}
+	onDispose(callback) {
+		return this.life.onDispose(callback);
+	}
+	flag(value) {
+		if (typeof value !== "boolean") throw new EngineError("INVALID_VIRTUAL_INPUT", "Virtual input flags must be boolean");
+	}
+	alive() {
+		if (this.disposed) throw new EngineError("OWNER_DISPOSED", "Virtual input has been disposed");
+	}
+	validate(controller, action, kind, options) {
+		this.alive();
+		checkVirtualOptions(options);
+		if (!this.input.hasController(controller) || controller.reader(action).scene !== this.pointer.scene || action.kind !== kind) throw new EngineError("INVALID_ACTION", "Virtual input requires a matching Action kind and a controller in its own Scene/InputSystem");
+		const region = resolveVirtualRegion(options.region, this.view);
+		const peers = this.resolve(this.view);
+		for (const control of this.list) {
+			const other = peers.get(control);
+			if (other && control.kind === (kind === "axis2d" ? "stick" : "button") && virtualOverlap(region, other)) throw new EngineError("VIRTUAL_REGION_OVERLAP", "Same-priority virtual activation regions overlap");
+		}
+		if (options.position) virtualPosition(options.position, this.view);
+	}
+	binding(controller, action) {
+		const source = controller.createSource();
+		return {
+			get disposed() {
+				return source.disposed;
+			},
+			onDispose: (callback) => controller.onDispose(callback),
+			clear: () => source.clear(),
+			dispose: () => source.dispose(),
+			active: () => controller.active,
+			write: (direction, pressed) => source.set(action, action.kind === "axis2d" ? direction : pressed)
+		};
+	}
+	stick(controller, action, options) {
+		this.validate(controller, action, "axis2d", options);
+		const binding = this.binding(controller, action);
+		try {
+			return this.add(new VirtualStick(options, this.host, binding));
+		} catch (error) {
+			binding.dispose();
+			throw error;
+		}
+	}
+	button(controller, action, options) {
+		this.validate(controller, action, "button", options);
+		const binding = this.binding(controller, action);
+		try {
+			return this.add(new VirtualButton(options, this.host, binding));
+		} catch (error) {
+			binding.dispose();
+			throw error;
+		}
+	}
+	add(control) {
+		this.list = Object.freeze([...this.list, control]);
+		this.dirty = true;
+		try {
+			this.refresh();
+		} catch (error) {
+			control.dispose();
+			throw error;
+		}
+		return control;
+	}
+	resolve(view, replaced, region) {
+		const result = /* @__PURE__ */ new Map();
+		for (const control of this.list) result.set(control, resolveVirtualRegion(control === replaced && region ? region : control.region, view));
+		for (let i = 0; i < this.list.length; i++) {
+			const a = this.list[i];
+			if (!a) continue;
+			for (let j = i + 1; j < this.list.length; j++) {
+				const b = this.list[j], x = result.get(a), y = b ? result.get(b) : void 0;
+				if (b && x && y && a.kind === b.kind && virtualOverlap(x, y)) throw new EngineError("VIRTUAL_REGION_OVERLAP", "Same-priority virtual activation regions overlap", {
+					first: i,
+					second: j
+				});
+			}
+		}
+		return result;
+	}
+	centers(regions, view) {
+		return new Map([...regions].map(([control, region]) => {
+			const b = region.bounds;
+			return [control, control.position ? virtualPosition(control.position, view) : Object.freeze({
+				x: b.x + b.width / 2,
+				y: b.y + b.height / 2
+			})];
+		}));
+	}
+	/** Resolve after Canvas layout and before routing/rendering. Layout changes cancel active gestures. */
+	refresh(viewport = this.view) {
+		this.alive();
+		const view = virtualBounds(viewport);
+		const resized = Object.keys(view).some((key) => view[key] !== this.view[key]);
+		if (!this.dirty && !resized && !this.list.some((c) => c.region.kind === "custom")) return;
+		const regions = this.resolve(view), centers = this.centers(regions, view);
+		const changed = this.list.filter((c) => resized || JSON.stringify(regions.get(c)) !== JSON.stringify(this.regions.get(c)) || JSON.stringify(centers.get(c)) !== JSON.stringify(this.anchors.get(c)));
+		this.view = view;
+		this.regions = regions;
+		this.anchors = centers;
+		this.dirty = false;
+		cleanupAll(changed.map((c) => () => c.invalidate()), "Virtual layout cancellation failed");
+	}
+	pick(data) {
+		if (this.disposed || !this.active || !this.input.liveInput || data.button !== 0) return;
+		this.refresh();
+		for (const kind of ["button", "stick"]) for (const control of this.list) if (control.kind === kind && control.available && control.contains(data)) return control;
+	}
+	sample() {
+		if (this.disposed) return;
+		this.refresh();
+		cleanupAll(this.list.filter((c) => c.pressed && !c.available).map((c) => () => c.invalidate()), "Virtual availability cancellation failed");
+	}
+	advance(seconds) {
+		this.alive();
+		if (virtualFinite(seconds, "seconds") < 0) throw new EngineError("INVALID_VIRTUAL_INPUT", "Presentation seconds must be nonnegative");
+		cleanupAll(this.list.map((c) => () => {
+			if (!c.disposed) c.advance(seconds);
+		}), "Virtual hold callbacks failed");
+	}
+	reset() {
+		cleanupAll(this.list.map((c) => () => c.invalidate()), "Virtual input reset failed");
+	}
+	dispose() {
+		if (this.disposed) return;
+		cleanupAll([
+			() => this.life.dispose(),
+			...this.list.map((c) => () => c.dispose()),
+			() => {
+				this.regions.clear();
+				this.anchors.clear();
+				this.list = Object.freeze([]);
+			}
+		], "Virtual input cleanup failed");
+	}
+};
 // packages/core/src/runtime/engine.ts
 var Engine = class {
 	input = new InputSystem();
@@ -6320,7 +7082,7 @@ var ReplayPlayer = class {
 		this.engine = engine;
 		this.data = parseReplayData(data);
 		this.bound = bindings(engine, options.controllers);
-		if (this.data.engineVersion !== "0.1.4" || engine.random.seed !== this.data.random.seed) throw new EngineError("REPLAY_INCOMPATIBLE", "Engine version or initial seed does not match Replay");
+		if (this.data.engineVersion !== "0.1.5" || engine.random.seed !== this.data.random.seed) throw new EngineError("REPLAY_INCOMPATIBLE", "Engine version or initial seed does not match Replay");
 		if (!compatible(this.bound.map(([id, c]) => ({
 			id,
 			actions: c.schema()
@@ -8218,6 +8980,6 @@ var CanvasUI = class {
 		], "Canvas UI cleanup failed");
 	}
 };
-export { Action, ActionController, ActionMovement, ActionSource, Actor, ActorState, Aspect, BodyType, Camera, CameraFollow, Cancellation, CanvasButton, CanvasCheckbox, CanvasCheckboxNode, CanvasColumn, CanvasHoldButton, CanvasInputNode, CanvasLabel, CanvasNode, CanvasNumberInput, CanvasNumberInputNode, CanvasPanel, CanvasRow, CanvasScroll, CanvasSelect, CanvasSelectNode, CanvasSlider, CanvasSliderNode, CanvasTextEditorNode, CanvasTextInput, CanvasTextInputNode, CanvasUI, Character, CharacterActor, Collider, CollisionBody, CollisionResponse, CollisionShape, CollisionWorld, Component, ComponentPhase, ContactEnter, ContactExit, ContactStay, DEFAULT_RANDOM_STREAM, ENGINE_VERSION, Easing, Engine, EngineError, EventBus, FixedStepRunner, GeometryTilemap, GeometryTilemapLayer, Grid, HexOrientation, InputSystem, KeyCode, KeyboardBindings, KeyboardSource, Lifetime, Motion, PointerCancel, PointerClick, PointerDown, PointerEnter, PointerLeave, PointerMove, PointerRouting, PointerUp, RANDOM_ALGORITHM, RandomManager, RandomStream, Renderable, ReplayPlayer, ReplayRecorder, Scene, ScenePointer, SceneState, Shape, SpriteAnimation, SpriteAnimationState, SpriteFit, SpriteSheet, TileContactEnter, TileContactExit, TileContactStay, TileGeometry, Tilemap, TilemapLayer, Transform, Tween, TweenBinding, TweenPlayback, TweenScheduler, actorTween, canvasControlText, canvasHoverHighlight, canvasNumericRange, canvasNumericValue, canvasOpacity, canvasScrollbars, canvasSliderGeometry, canvasTween, cleanupAll, containsScreenPoint, containsUI, createViewTransform, defaultCanvasStyle, defineActions, defineComponent, defineEvent, deriveStreamSeed, imageSize, intersectUI, isKeyCode, layoutCanvas, nativeSession, parseKeyCode, parseReplayData, positive, screenPoint, screenToPhysical, screenToWorld, scrollbarContains, sliderTween, spriteFrame, spriteFrameBounds, tweenFinite, worldPoint, worldToScreen, wrapCanvasText };
+export { Action, ActionController, ActionMovement, ActionSource, Actor, ActorState, Aspect, BodyType, Camera, CameraFollow, Cancellation, CanvasButton, CanvasCheckbox, CanvasCheckboxNode, CanvasColumn, CanvasHoldButton, CanvasInputNode, CanvasLabel, CanvasNode, CanvasNumberInput, CanvasNumberInputNode, CanvasPanel, CanvasRow, CanvasScroll, CanvasSelect, CanvasSelectNode, CanvasSlider, CanvasSliderNode, CanvasTextEditorNode, CanvasTextInput, CanvasTextInputNode, CanvasUI, Character, CharacterActor, Collider, CollisionBody, CollisionResponse, CollisionShape, CollisionWorld, Component, ComponentPhase, ContactEnter, ContactExit, ContactStay, DEFAULT_RANDOM_STREAM, ENGINE_VERSION, Easing, Engine, EngineError, EventBus, FixedStepRunner, GeometryTilemap, GeometryTilemapLayer, Grid, HexOrientation, InputSystem, KeyCode, KeyboardBindings, KeyboardSource, Lifetime, Motion, PointerCancel, PointerClick, PointerDown, PointerEnter, PointerLeave, PointerMove, PointerRouting, PointerUp, RANDOM_ALGORITHM, RandomManager, RandomStream, Renderable, ReplayPlayer, ReplayRecorder, Scene, ScenePointer, SceneState, Shape, SpriteAnimation, SpriteAnimationState, SpriteFit, SpriteSheet, TileContactEnter, TileContactExit, TileContactStay, TileGeometry, Tilemap, TilemapLayer, Transform, Tween, TweenBinding, TweenPlayback, TweenScheduler, VirtualButton, VirtualControl, VirtualInput, VirtualRegions, VirtualStick, VirtualStickMode, actorTween, canvasControlText, canvasHoverHighlight, canvasNumericRange, canvasNumericValue, canvasOpacity, canvasScrollbars, canvasSliderGeometry, canvasTween, cleanupAll, containsScreenPoint, containsUI, createViewTransform, defaultCanvasStyle, defineActions, defineComponent, defineEvent, deriveStreamSeed, imageSize, intersectUI, isKeyCode, layoutCanvas, nativeSession, parseKeyCode, parseReplayData, positive, screenPoint, screenToPhysical, screenToWorld, scrollbarContains, sliderTween, spriteFrame, spriteFrameBounds, tweenFinite, worldPoint, worldToScreen, wrapCanvasText };
 
 //# sourceMappingURL=index.js.map