@godot-scene-web/vue 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tomás Fox
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,216 @@
+import { GodotHtmlModel, GodotHtmlRenderOptions } from "@godot-scene-web/html";
+import { GodotHtmlRuntimeOptions } from "@godot-scene-web/html/runtime";
+import { GodotLayoutOptions } from "@godot-scene-web/layout";
+import { GodotResourceStatus, SceneGraph, SceneStructureOptions } from "@godot-scene-web/scene-graph";
+import { ComputedRef, PropType, VNodeChild } from "vue";
+import { GodotNode, GodotResourceRefValue, GodotSceneState, GodotVariant } from "@godot-scene-web/core";
+
+//#region src/index.d.ts
+type GodotSceneViewOptions = SceneStructureOptions & GodotLayoutOptions & GodotHtmlRenderOptions & GodotHtmlRuntimeOptions & {
+  /**
+   * Layout pipeline. `"browser"` (default): the browser CSS engine resolves
+   * layout (containers flex/grid, anchored Controls via CSS insets, text sizes
+   * itself) straight from the structural `SceneGraph`, never running the rect
+   * cascade. `"computed"`: gsw's rect cascade produces absolute px — opt in for
+   * the layout-diff/parity oracle or pixel-exact needs.
+   */
+  layoutMode?: "browser" | "computed";
+};
+interface GodotSubscribableResourceSource {
+  subscribe: (listener: () => void) => () => void;
+  /**
+   * Monotonic settle counters from the backing resolver (see the gsw fetch
+   * resolver's `generations()`). When present, `useGodotSceneModel` memoizes the
+   * scene-graph derivation on (input identities + the `scenes` counter): graph
+   * derivation reads scene documents but never `.tres`/font/texture content, so
+   * resource-only settle notifications skip the derive and rebuild only the HTML
+   * model. Absent ⇒ derive runs on every recompute (always correct).
+   */
+  generations?: () => {
+    scenes: number;
+    resources: number;
+  };
+}
+interface GodotSceneModelSource {
+  scene?: GodotSceneState;
+  model?: GodotHtmlModel;
+  options?: GodotSceneViewOptions;
+  resolveResource?: (ref: GodotResourceRefValue, node: GodotNode) => unknown;
+  resolveResourcePath?: (path: string, node: GodotNode) => unknown;
+  overrideNodeProps?: (node: GodotNode, path: string) => Record<string, GodotVariant> | undefined;
+  overrideNodeType?: (node: GodotNode, path: string) => string | undefined;
+  nodeOverrides?: GodotNodePropertyOverrideMap;
+  nodeNameOverrides?: GodotNodePropertyOverrideMap;
+  mountExternalScene?: (ref: GodotResourceRefValue, node: GodotNode) => GodotSceneState | undefined;
+  resourceSource?: GodotSubscribableResourceSource;
+}
+type GodotNodePropertyOverrideMap = Record<string, Record<string, GodotVariant>>;
+type GodotNodePropertyOverrideResolver = (node: GodotNode, path: string) => Record<string, GodotVariant> | undefined;
+declare const GodotNodeView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  path: {
+    type: StringConstructor;
+    required: true;
+  };
+}>, () => VNodeChild, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  path: {
+    type: StringConstructor;
+    required: true;
+  };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const GodotSceneView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  scene: {
+    type: PropType<GodotSceneState>;
+    required: false;
+    default: undefined;
+  };
+  model: {
+    type: PropType<GodotHtmlModel>;
+    required: false;
+    default: undefined;
+  };
+  options: {
+    type: PropType<GodotSceneViewOptions>;
+    required: false;
+    default: () => {};
+  };
+  resolveResource: {
+    type: PropType<(ref: GodotResourceRefValue, node: GodotNode) => unknown>;
+    required: false;
+    default: undefined;
+  };
+  resolveResourcePath: {
+    type: PropType<(path: string, node: GodotNode) => unknown>;
+    required: false;
+    default: undefined;
+  };
+  overrideNodeProps: {
+    type: PropType<(node: GodotNode, path: string) => Record<string, GodotVariant> | undefined>;
+    required: false;
+    default: undefined;
+  };
+  overrideNodeType: {
+    type: PropType<(node: GodotNode, path: string) => string | undefined>;
+    required: false;
+    default: undefined;
+  };
+  nodeOverrides: {
+    type: PropType<GodotNodePropertyOverrideMap>;
+    required: false;
+    default: () => {};
+  };
+  nodeNameOverrides: {
+    type: PropType<GodotNodePropertyOverrideMap>;
+    required: false;
+    default: () => {};
+  };
+  mountExternalScene: {
+    type: PropType<(ref: GodotResourceRefValue, node: GodotNode) => GodotSceneState | undefined>;
+    required: false;
+    default: undefined;
+  };
+  resourceSource: {
+    type: PropType<GodotSubscribableResourceSource>;
+    required: false;
+    default: undefined;
+  };
+  debug: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  componentTree: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+}>, () => VNodeChild[] | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  scene: {
+    type: PropType<GodotSceneState>;
+    required: false;
+    default: undefined;
+  };
+  model: {
+    type: PropType<GodotHtmlModel>;
+    required: false;
+    default: undefined;
+  };
+  options: {
+    type: PropType<GodotSceneViewOptions>;
+    required: false;
+    default: () => {};
+  };
+  resolveResource: {
+    type: PropType<(ref: GodotResourceRefValue, node: GodotNode) => unknown>;
+    required: false;
+    default: undefined;
+  };
+  resolveResourcePath: {
+    type: PropType<(path: string, node: GodotNode) => unknown>;
+    required: false;
+    default: undefined;
+  };
+  overrideNodeProps: {
+    type: PropType<(node: GodotNode, path: string) => Record<string, GodotVariant> | undefined>;
+    required: false;
+    default: undefined;
+  };
+  overrideNodeType: {
+    type: PropType<(node: GodotNode, path: string) => string | undefined>;
+    required: false;
+    default: undefined;
+  };
+  nodeOverrides: {
+    type: PropType<GodotNodePropertyOverrideMap>;
+    required: false;
+    default: () => {};
+  };
+  nodeNameOverrides: {
+    type: PropType<GodotNodePropertyOverrideMap>;
+    required: false;
+    default: () => {};
+  };
+  mountExternalScene: {
+    type: PropType<(ref: GodotResourceRefValue, node: GodotNode) => GodotSceneState | undefined>;
+    required: false;
+    default: undefined;
+  };
+  resourceSource: {
+    type: PropType<GodotSubscribableResourceSource>;
+    required: false;
+    default: undefined;
+  };
+  debug: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+  componentTree: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+}>> & Readonly<{}>, {
+  scene: GodotSceneState;
+  model: GodotHtmlModel;
+  options: GodotSceneViewOptions;
+  resolveResource: (ref: GodotResourceRefValue, node: GodotNode) => unknown;
+  resolveResourcePath: (path: string, node: GodotNode) => unknown;
+  overrideNodeProps: (node: GodotNode, path: string) => Record<string, GodotVariant> | undefined;
+  overrideNodeType: (node: GodotNode, path: string) => string | undefined;
+  nodeOverrides: GodotNodePropertyOverrideMap;
+  nodeNameOverrides: GodotNodePropertyOverrideMap;
+  mountExternalScene: (ref: GodotResourceRefValue, node: GodotNode) => GodotSceneState | undefined;
+  resourceSource: GodotSubscribableResourceSource;
+  debug: boolean;
+  componentTree: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare function useGodotSceneModel(source: GodotSceneModelSource): {
+  model: ComputedRef<GodotHtmlModel | null>;
+  graph: ComputedRef<SceneGraph | null>;
+  tintFilterIdPrefix: string;
+  revision: ComputedRef<number>;
+  pendingResources: ComputedRef<GodotResourceStatus[]>;
+  failedResources: ComputedRef<GodotResourceStatus[]>;
+};
+declare function overrideGodotNodePropsByPath(overrides: GodotNodePropertyOverrideMap): GodotNodePropertyOverrideResolver;
+declare function overrideGodotNodePropsByName(overrides: GodotNodePropertyOverrideMap): GodotNodePropertyOverrideResolver;
+declare function mergeGodotNodePropOverrides(...resolvers: Array<GodotNodePropertyOverrideResolver | undefined>): GodotNodePropertyOverrideResolver;
+//#endregion
+export { GodotNodePropertyOverrideMap, GodotNodePropertyOverrideResolver, GodotNodeView, GodotSceneModelSource, GodotSceneView, GodotSceneViewOptions, GodotSubscribableResourceSource, mergeGodotNodePropOverrides, overrideGodotNodePropsByName, overrideGodotNodePropsByPath, useGodotSceneModel };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;KA2EY,qBAAA,GAAwB,qBAAA,GAClC,kBAAA,GACA,sBAAA,GACA,uBAAA;;AAHF;;;;;;EAWI,UAAA;AAAA;AAAA,UAgBa,+BAAA;EACf,SAAA,GAAY,QAAA;EA3BZ;;;;;AAUY;AAgBd;;EAUE,WAAA;IAAsB,MAAA;IAAgB,SAAA;EAAA;AAAA;AAAA,UAGvB,qBAAA;EACf,KAAA,GAAQ,eAAA;EACR,KAAA,GAAQ,cAAA;EACR,OAAA,GAAU,qBAAA;EACV,eAAA,IAAmB,GAAA,EAAK,qBAAA,EAAuB,IAAA,EAAM,SAAA;EACrD,mBAAA,IAAuB,IAAA,UAAc,IAAA,EAAM,SAAA;EAC3C,iBAAA,IACE,IAAA,EAAM,SAAA,EACN,IAAA,aACG,MAAA,SAAe,YAAA;EACpB,gBAAA,IAAoB,IAAA,EAAM,SAAA,EAAW,IAAA;EACrC,aAAA,GAAgB,4BAAA;EAChB,iBAAA,GAAoB,4BAAA;EACpB,kBAAA,IACE,GAAA,EAAK,qBAAA,EACL,IAAA,EAAM,SAAA,KACH,eAAA;EACL,cAAA,GAAiB,+BAAA;AAAA;AAAA,KAGP,4BAAA,GAA+B,MAAA,SAEzC,MAAA,SAAe,YAAA;AAAA,KAEL,iCAAA,IACV,IAAA,EAAM,SAAA,EACN,IAAA,aACG,MAAA,SAAe,YAAA;AAAA,cA8CP,aAAA,gBAAa,eAAA,eAAA,gBAAA;;;;;;;;;;;cA+Qb,cAAA,gBAAc,eAAA,eAAA,gBAAA;;UAIL,QAAA,CAAS,eAAA;;;;;UAKT,QAAA,CAAS,cAAA;;;;;UAKT,QAAA,CAAS,qBAAA;;;;;UAKP,QAAA,EACf,GAAA,EAAK,qBAAA,EAAuB,IAAA,EAAM,SAAA;;;;;UAMnB,QAAA,EAAU,IAAA,UAAc,IAAA,EAAM,SAAA;;;;;UAK9B,QAAA,EAEd,IAAA,EAAM,SAAA,EACN,IAAA,aACG,MAAA,SAAe,YAAA;;;;;UAMJ,QAAA,EACf,IAAA,EAAM,SAAA,EAAW,IAAA;;;;;UAMJ,QAAA,CAAS,4BAAA;;;;;UAKT,QAAA,CAAS,4BAAA;;;;;UAKP,QAAA,EAEd,GAAA,EAAK,qBAAA,EACL,IAAA,EAAM,SAAA,KACH,eAAA;;;;;UAMS,QAAA,CAAS,+BAAA;;;;;;;;;;;;;;UAhET,QAAA,CAAS,eAAA;;;;;UAKT,QAAA,CAAS,cAAA;;;;;UAKT,QAAA,CAAS,qBAAA;;;;;UAKP,QAAA,EACf,GAAA,EAAK,qBAAA,EAAuB,IAAA,EAAM,SAAA;;;;;UAMnB,QAAA,EAAU,IAAA,UAAc,IAAA,EAAM,SAAA;;;;;UAK9B,QAAA,EAEd,IAAA,EAAM,SAAA,EACN,IAAA,aACG,MAAA,SAAe,YAAA;;;;;UAMJ,QAAA,EACf,IAAA,EAAM,SAAA,EAAW,IAAA;;;;;UAMJ,QAAA,CAAS,4BAAA;;;;;UAKT,QAAA,CAAS,4BAAA;;;;;UAKP,QAAA,EAEd,GAAA,EAAK,qBAAA,EACL,IAAA,EAAM,SAAA,KACH,eAAA;;;;;UAMS,QAAA,CAAS,+BAAA;;;;;;;;;;;;;;;;yBAhDjB,qBAAA,EAAqB,IAAA,EAAQ,SAAA;sCAMG,IAAA,EAAQ,SAAA;4BAOtC,SAAA,EAAS,IAAA,aAEZ,MAAA,SAAe,YAAA;2BAOb,SAAA,EAAS,IAAA;;;4BAkBT,qBAAA,EAAqB,IAAA,EACpB,SAAA,KACH,eAAA;;;;;iBAmMG,kBAAA,CAAmB,MAAA,EAAQ,qBAAA;EACzC,KAAA,EAAO,WAAA,CAAY,cAAA;EAInB,KAAA,EAAO,WAAA,CAAY,UAAA;EAEnB,kBAAA;EAIA,QAAA,EAAU,WAAA;EACV,gBAAA,EAAkB,WAAA,CAAY,mBAAA;EAC9B,eAAA,EAAiB,WAAA,CAAY,mBAAA;AAAA;AAAA,iBAmLf,4BAAA,CACd,SAAA,EAAW,4BAAA,GACV,iCAAiC;AAAA,iBAIpB,4BAAA,CACd,SAAA,EAAW,4BAAA,GACV,iCAAiC;AAAA,iBAIpB,2BAAA,CAAA,GACX,SAAA,EAAW,KAAA,CAAM,iCAAA,gBACnB,iCAAA"}

package/dist/index.js

@@ -0,0 +1,467 @@
+import { DEFAULT_BROWSER_VIEWPORT, FRAME_CLASS, ROOT_PARENT_CONTEXT, STAGE_CLASS, buildGraphNodeHtml, buildHiddenGraphNode, buildNodePresentation, buildSceneFragment, buildSceneStructure, buildStyleElement, buildTintDefsElement, contentScaleStageStyle, observeContentScale, renderSceneGraphToHtmlModel, renderSceneToHtmlModel, resolveContentScale, stabilizeRenderElements, uniqueFontFaces } from "@godot-scene-web/html";
+import { createHtmlEffectsHost } from "@godot-scene-web/html/runtime";
+import { resolveGodotSceneTree } from "@godot-scene-web/layout";
+import { createSceneGraphNodeMemo, deriveSceneGraph } from "@godot-scene-web/scene-graph";
+import { computed, createCommentVNode, defineComponent, h, inject, onBeforeUnmount, onMounted, provide, ref, watch } from "vue";
+//#region src/index.ts
+let tintFilterViewSeq = 0;
+function nextTintFilterIdPrefix() {
+	tintFilterViewSeq += 1;
+	return `godot-tint-v${tintFilterViewSeq}-`;
+}
+const COMPONENT_MODEL_KEY = Symbol("godot-component-model");
+const EMPTY_SLOTS = {};
+const NO_CHILD_SLOTS = {
+	behind: [],
+	normal: []
+};
+const GodotNodeView = defineComponent({
+	name: "GodotNodeView",
+	props: { path: {
+		type: String,
+		required: true
+	} },
+	setup(props) {
+		const model = inject(COMPONENT_MODEL_KEY, null);
+		const node = computed(() => model?.value?.nodesByPath.get(props.path) ?? null);
+		const slots = computed(() => model?.value?.childrenByPath.get(props.path) ?? NO_CHILD_SLOTS);
+		return () => {
+			const current = node.value;
+			if (!current) return null;
+			return renderComponentNode(current, slots.value);
+		};
+	}
+});
+function renderComponentNode(node, slots) {
+	const shell = buildNodePresentation(node);
+	if (shell.kind === "comment") return createCommentVNode(shell.text ?? "");
+	const self = shell.children?.[0];
+	const childComponent = (path) => h(GodotNodeView, {
+		key: path,
+		path
+	});
+	return h(shell.tag, {
+		key: shell.key,
+		class: shell.className,
+		style: shell.style,
+		...shell.attributes
+	}, [
+		...slots.behind.map(childComponent),
+		...self ? [renderElement(self, EMPTY_SLOTS)] : [],
+		...slots.normal.map(childComponent)
+	]);
+}
+function renderComponentTree(model, frameRef, stageRef, debug) {
+	const out = [];
+	const style = buildStyleElement(model, { includeBaseCss: false });
+	if (style) out.push(renderElement(style, EMPTY_SLOTS));
+	const tintDefs = buildTintDefsElement(model);
+	if (tintDefs) out.push(renderElement(tintDefs, EMPTY_SLOTS));
+	const stageStyle = model.contentScale ? { ...contentScaleStageStyle(model.contentScale) } : {
+		width: `${model.viewport.width}px`,
+		height: `${model.viewport.height}px`
+	};
+	const stage = h("div", {
+		class: debug ? `${STAGE_CLASS} godot-scene-debug` : STAGE_CLASS,
+		"data-godot-stage": "true",
+		ref: stageRef,
+		style: stageStyle
+	}, model.rootPaths.map((path) => h(GodotNodeView, {
+		key: path,
+		path
+	})));
+	if (!model.contentScale) {
+		out.push(stage);
+		return out;
+	}
+	const background = model.contentScale.background;
+	out.push(h("div", {
+		class: FRAME_CLASS,
+		ref: frameRef,
+		style: background ? { background } : {}
+	}, [stage]));
+	return out;
+}
+function parentContextKey(ctx) {
+	return `${ctx.parentType ?? ""}|${ctx.parentHorizontal ? 1 : 0}`;
+}
+function childSlotsKey(slots) {
+	return `${slots.behind.join("\n")}\u0000${slots.normal.join("\n")}`;
+}
+function buildComponentSceneModel(graph, options, viewport, contentScale, nodeCache, childCache, tintFilters) {
+	const structure = buildSceneStructure(graph);
+	const nodesByPath = /* @__PURE__ */ new Map();
+	const fontFaces = [];
+	const resourceStatuses = [...graph.resourceStatuses ?? []];
+	const builtPaths = /* @__PURE__ */ new Set();
+	const walk = (path, parentLayout, parentPath, parentContext) => {
+		const graphNode = structure.nodesByPath.get(path);
+		if (!graphNode) return;
+		builtPaths.add(path);
+		if (!graphNode.visible) {
+			nodesByPath.set(path, buildHiddenGraphNode(graphNode, parentPath));
+			return;
+		}
+		const ctxKey = parentContextKey(parentContext);
+		let entry = nodeCache.get(path);
+		const hadPendingResource = entry?.result.resourceStatuses.some((status) => status.status === "pending") ?? false;
+		if (!entry || entry.graphNode !== graphNode || entry.ctxKey !== ctxKey || hadPendingResource) {
+			entry = {
+				graphNode,
+				ctxKey,
+				result: buildGraphNodeHtml(graphNode, parentLayout, parentPath, parentContext, options, tintFilters, viewport, contentScale)
+			};
+			nodeCache.set(path, entry);
+		}
+		nodesByPath.set(path, entry.result.node);
+		fontFaces.push(...entry.result.fontFaces);
+		resourceStatuses.push(...entry.result.resourceStatuses);
+		const slots = structure.childrenByPath.get(path);
+		if (slots) {
+			for (const childPath of slots.behind) walk(childPath, entry.result.layout, path, entry.result.childContext);
+			for (const childPath of slots.normal) walk(childPath, entry.result.layout, path, entry.result.childContext);
+		}
+	};
+	for (const rootPath of structure.rootPaths) walk(rootPath, void 0, null, ROOT_PARENT_CONTEXT);
+	for (const key of [...nodeCache.keys()]) if (!builtPaths.has(key)) nodeCache.delete(key);
+	const childrenByPath = /* @__PURE__ */ new Map();
+	for (const [path, slots] of structure.childrenByPath) {
+		if (!builtPaths.has(path) || !structure.nodesByPath.get(path)?.visible) continue;
+		const key = childSlotsKey(slots);
+		const cached = childCache.get(path);
+		if (cached && cached.key === key) childrenByPath.set(path, cached.slots);
+		else {
+			childCache.set(path, {
+				key,
+				slots
+			});
+			childrenByPath.set(path, slots);
+		}
+	}
+	for (const key of [...childCache.keys()]) if (!childrenByPath.has(key)) childCache.delete(key);
+	return {
+		rootPaths: structure.rootPaths,
+		nodesByPath,
+		childrenByPath,
+		fontFaces: uniqueFontFaces(fontFaces),
+		tintFilters: [...tintFilters].map(([markup, id]) => ({
+			id,
+			markup
+		})),
+		resourceStatuses,
+		viewport,
+		contentScale,
+		css: ""
+	};
+}
+const GodotSceneView = defineComponent({
+	name: "GodotSceneView",
+	props: {
+		scene: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		model: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		options: {
+			type: Object,
+			required: false,
+			default: () => ({})
+		},
+		resolveResource: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		resolveResourcePath: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		overrideNodeProps: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		overrideNodeType: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		nodeOverrides: {
+			type: Object,
+			required: false,
+			default: () => ({})
+		},
+		nodeNameOverrides: {
+			type: Object,
+			required: false,
+			default: () => ({})
+		},
+		mountExternalScene: {
+			type: Function,
+			required: false,
+			default: void 0
+		},
+		resourceSource: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		debug: {
+			type: Boolean,
+			default: false
+		},
+		componentTree: {
+			type: Boolean,
+			default: false
+		}
+	},
+	setup(props, { slots }) {
+		const sceneModel = useGodotSceneModel(props);
+		const fragmentModel = sceneModel.model;
+		const nodeCache = /* @__PURE__ */ new Map();
+		const childCache = /* @__PURE__ */ new Map();
+		const componentTintFilters = /* @__PURE__ */ new Map();
+		const componentModel = computed(() => {
+			if (!props.componentTree) return null;
+			sceneModel.revision.value;
+			const graph = sceneModel.graph.value;
+			if (!graph) return null;
+			const options = props.options ?? {};
+			const htmlOptions = resolveHtmlOptions(props, sceneModel.tintFilterIdPrefix);
+			const viewport = {
+				width: options.viewport?.width ?? DEFAULT_BROWSER_VIEWPORT.width,
+				height: options.viewport?.height ?? DEFAULT_BROWSER_VIEWPORT.height
+			};
+			return buildComponentSceneModel(graph, htmlOptions, viewport, resolveContentScale(options.contentScale, viewport), nodeCache, childCache, componentTintFilters);
+		});
+		provide(COMPONENT_MODEL_KEY, componentModel);
+		const activeModel = computed(() => props.componentTree ? componentModel.value : fragmentModel.value);
+		const frame = ref(null);
+		const stage = ref(null);
+		let disposeScale = null;
+		const syncScale = () => {
+			disposeScale?.();
+			disposeScale = null;
+			const contentScale = activeModel.value?.contentScale;
+			if (contentScale && contentScale.technique === "transform" && frame.value) disposeScale = observeContentScale(frame.value, contentScale.base);
+		};
+		onMounted(syncScale);
+		watch([activeModel, frame], syncScale, { flush: "post" });
+		onBeforeUnmount(() => {
+			disposeScale?.();
+			disposeScale = null;
+		});
+		let effectsHost = null;
+		let runtimeRoot = null;
+		const disposeRuntimes = () => {
+			effectsHost?.dispose();
+			effectsHost = null;
+			runtimeRoot = null;
+		};
+		const syncRuntimes = () => {
+			const el = stage.value;
+			if (!el) {
+				disposeRuntimes();
+				return;
+			}
+			const options = resolveHtmlOptions(props, sceneModel.tintFilterIdPrefix);
+			if (runtimeRoot !== el) {
+				disposeRuntimes();
+				runtimeRoot = el;
+				effectsHost = createHtmlEffectsHost(el, options);
+			} else effectsHost?.updateOptions(options);
+			effectsHost?.reconcile();
+		};
+		onMounted(syncRuntimes);
+		watch([activeModel, stage], syncRuntimes, { flush: "post" });
+		onBeforeUnmount(() => {
+			disposeRuntimes();
+		});
+		let previousFragment;
+		const vnodeCache = /* @__PURE__ */ new WeakMap();
+		return () => {
+			if (props.componentTree) {
+				previousFragment = void 0;
+				const current = componentModel.value;
+				if (!current) return null;
+				return renderComponentTree(current, frame, stage, props.debug);
+			}
+			const current = fragmentModel.value;
+			if (!current) {
+				previousFragment = void 0;
+				return null;
+			}
+			let fragment = buildSceneFragment(current, {
+				debug: props.debug,
+				includeStyle: true,
+				includeBaseCss: false
+			});
+			if (slots.node) {
+				previousFragment = void 0;
+				return fragment.map((element) => renderElement(element, slots, frame, void 0, stage));
+			}
+			fragment = stabilizeRenderElements(previousFragment, fragment);
+			previousFragment = fragment;
+			return fragment.map((element) => renderElement(element, slots, frame, vnodeCache, stage));
+		};
+	}
+});
+function useGodotSceneModel(source) {
+	const revision = ref(0);
+	const tintFilterIdPrefix = nextTintFilterIdPrefix();
+	let unsubscribe = null;
+	const resubscribe = (resourceSource) => {
+		unsubscribe?.();
+		unsubscribe = resourceSource ? resourceSource.subscribe(() => {
+			revision.value += 1;
+		}) : null;
+	};
+	watch(() => source.resourceSource, resubscribe, { immediate: true });
+	onBeforeUnmount(() => {
+		unsubscribe?.();
+		unsubscribe = null;
+	});
+	const deriveMemo = { entry: null };
+	const nodeMemo = createSceneGraphNodeMemo();
+	const graph = computed(() => {
+		revision.value;
+		if (source.model) return null;
+		return resolveSceneGraph(source, deriveMemo, nodeMemo);
+	});
+	const model = computed(() => {
+		if (source.model) return source.model;
+		const resolved = graph.value;
+		if (!resolved) return null;
+		const options = source.options ?? {};
+		const htmlOptions = resolveHtmlOptions(source, tintFilterIdPrefix);
+		if (options.layoutMode === "computed") return renderSceneToHtmlModel(resolveGodotSceneTree(resolved, resolveStructureOptions(source)), htmlOptions);
+		return renderSceneGraphToHtmlModel(resolved, {
+			...htmlOptions,
+			viewport: options.viewport
+		});
+	});
+	const pendingResources = computed(() => (model.value?.resourceStatuses ?? []).filter((resource) => resource.status === "pending"));
+	const failedResources = computed(() => (model.value?.resourceStatuses ?? []).filter((resource) => resource.status === "error"));
+	return {
+		model,
+		graph,
+		tintFilterIdPrefix,
+		revision: computed(() => revision.value),
+		pendingResources,
+		failedResources
+	};
+}
+function deriveMemoKeys(source) {
+	return [
+		source.scene,
+		source.options,
+		source.resolveResource,
+		source.resolveResourcePath,
+		source.overrideNodeProps,
+		source.overrideNodeType,
+		source.nodeOverrides,
+		source.nodeNameOverrides,
+		source.mountExternalScene
+	];
+}
+function resolveStructureOptions(source) {
+	const options = source.options ?? {};
+	const resolveResource = source.resolveResource ?? options.resolveResource;
+	return {
+		...options,
+		resolveResource,
+		overrideNodeProps: resolveVueNodePropsOverride(options.overrideNodeProps, source.overrideNodeProps, source.nodeNameOverrides ?? {}, source.nodeOverrides ?? {}),
+		overrideNodeType: source.overrideNodeType ?? options.overrideNodeType,
+		mountExternalScene: source.mountExternalScene ?? options.mountExternalScene
+	};
+}
+function resolveHtmlOptions(source, tintFilterIdPrefix) {
+	const options = source.options ?? {};
+	return {
+		...options,
+		resolveResource: source.resolveResource ?? options.resolveResource,
+		resolveResourcePath: source.resolveResourcePath ?? options.resolveResourcePath,
+		tintFilterIdPrefix: options.tintFilterIdPrefix ?? tintFilterIdPrefix
+	};
+}
+function resolveSceneGraph(source, deriveMemo, nodeMemo) {
+	if (!source.scene) return null;
+	const structureOptions = resolveStructureOptions(source);
+	const scenesGeneration = source.resourceSource?.generations?.().scenes;
+	const memoKeys = deriveMemoKeys(source);
+	const memoEntry = deriveMemo?.entry;
+	if (memoEntry && scenesGeneration !== void 0 && memoEntry.scenesGeneration === scenesGeneration && memoEntry.keys.length === memoKeys.length && memoEntry.keys.every((key, index) => key === memoKeys[index])) return memoEntry.graph;
+	const graph = deriveSceneGraph(source.scene, structureOptions, nodeMemo);
+	if (deriveMemo && scenesGeneration !== void 0) deriveMemo.entry = {
+		keys: memoKeys,
+		scenesGeneration,
+		graph
+	};
+	return graph;
+}
+function overrideGodotNodePropsByPath(overrides) {
+	return (_node, path) => overrides[path];
+}
+function overrideGodotNodePropsByName(overrides) {
+	return (node) => overrides[node.name];
+}
+function mergeGodotNodePropOverrides(...resolvers) {
+	return (node, path) => {
+		const merged = {};
+		for (const resolver of resolvers) Object.assign(merged, resolver?.(node, path));
+		return Object.keys(merged).length > 0 ? merged : void 0;
+	};
+}
+function resolveVueNodePropsOverride(optionsOverride, propOverride, nameOverrides, pathOverrides) {
+	return mergeGodotNodePropOverrides(optionsOverride, propOverride, overrideGodotNodePropsByName(nameOverrides), overrideGodotNodePropsByPath(pathOverrides));
+}
+function renderElement(element, slots, frameRef, cache, stageRef) {
+	const cached = cache?.get(element);
+	if (cached !== void 0) return cached;
+	if (element.kind === "comment") {
+		const comment = createCommentVNode(element.text ?? "");
+		cache?.set(element, comment);
+		return comment;
+	}
+	const data = {};
+	if (element.key !== void 0) data.key = element.key;
+	if (element.className !== void 0) data.class = element.className;
+	if (element.style !== void 0) data.style = element.style;
+	if (element.attributes) Object.assign(data, element.attributes);
+	if (frameRef && element.className === FRAME_CLASS) data.ref = frameRef;
+	if (stageRef && element.attributes?.["data-godot-stage"] === "true") data.ref = stageRef;
+	if (element.sourceNode && slots.node) {
+		const node = element.sourceNode;
+		const renderedByPath = /* @__PURE__ */ new Map();
+		const defaultChildren = (element.children ?? []).map((child) => {
+			const vnode = renderElement(child, slots, frameRef, void 0, stageRef);
+			if (child.sourceNode) renderedByPath.set(child.sourceNode.path, vnode);
+			return vnode;
+		});
+		const childNodeVnodes = node.children.map((path) => renderedByPath.get(path)).filter((vnode) => vnode !== void 0);
+		const slotResult = slots.node({
+			node,
+			children: childNodeVnodes
+		});
+		return h(element.tag, data, slotResult ?? defaultChildren);
+	}
+	let vnode;
+	if (element.rawHtml !== void 0) vnode = h(element.tag, {
+		...data,
+		innerHTML: element.rawHtml
+	});
+	else if (element.text !== void 0) vnode = h(element.tag, data, [element.text]);
+	else vnode = h(element.tag, data, (element.children ?? []).map((child) => renderElement(child, slots, frameRef, cache, stageRef)));
+	cache?.set(element, vnode);
+	return vnode;
+}
+//#endregion
+export { GodotNodeView, GodotSceneView, mergeGodotNodePropOverrides, overrideGodotNodePropsByName, overrideGodotNodePropsByPath, useGodotSceneModel };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type {\n  GodotNode,\n  GodotResourceRefValue,\n  GodotSceneState,\n  GodotVariant,\n} from \"@godot-scene-web/core\";\nimport {\n  type BrowserNativeParentContext,\n  buildGraphNodeHtml,\n  buildHiddenGraphNode,\n  buildNodePresentation,\n  buildSceneFragment,\n  buildSceneStructure,\n  buildStyleElement,\n  buildTintDefsElement,\n  contentScaleStageStyle,\n  DEFAULT_BROWSER_VIEWPORT,\n  FRAME_CLASS,\n  type GodotHtmlFontFace,\n  type GodotHtmlModel,\n  type GodotHtmlNode,\n  type GodotHtmlRenderOptions,\n  type GraphNodeBuildResult,\n  observeContentScale,\n  type RenderElement,\n  type ResolvedContentScale,\n  ROOT_PARENT_CONTEXT,\n  renderSceneGraphToHtmlModel,\n  renderSceneToHtmlModel,\n  resolveContentScale,\n  STAGE_CLASS,\n  stabilizeRenderElements,\n  uniqueFontFaces,\n} from \"@godot-scene-web/html\";\nimport {\n  createHtmlEffectsHost,\n  type GodotHtmlMountOptions,\n  type GodotHtmlRuntimeOptions,\n  type HtmlEffectsHost,\n} from \"@godot-scene-web/html/runtime\";\nimport type { GodotSceneTreeNode } from \"@godot-scene-web/layout\";\nimport {\n  type GodotLayoutOptions,\n  resolveGodotSceneTree,\n} from \"@godot-scene-web/layout\";\nimport type {\n  GodotResourceStatus,\n  SceneGraph,\n  SceneGraphNode,\n  SceneStructureOptions,\n} from \"@godot-scene-web/scene-graph\";\nimport {\n  createSceneGraphNodeMemo,\n  deriveSceneGraph,\n  type SceneGraphNodeMemo,\n} from \"@godot-scene-web/scene-graph\";\nimport {\n  type ComputedRef,\n  computed,\n  createCommentVNode,\n  defineComponent,\n  h,\n  type InjectionKey,\n  inject,\n  onBeforeUnmount,\n  onMounted,\n  type PropType,\n  provide,\n  type Ref,\n  ref,\n  type Slots,\n  type VNodeChild,\n  watch,\n} from \"vue\";\n\nexport type GodotSceneViewOptions = SceneStructureOptions &\n  GodotLayoutOptions &\n  GodotHtmlRenderOptions &\n  GodotHtmlRuntimeOptions & {\n    /**\n     * Layout pipeline. `\"browser\"` (default): the browser CSS engine resolves\n     * layout (containers flex/grid, anchored Controls via CSS insets, text sizes\n     * itself) straight from the structural `SceneGraph`, never running the rect\n     * cascade. `\"computed\"`: gsw's rect cascade produces absolute px — opt in for\n     * the layout-diff/parity oracle or pixel-exact needs.\n     */\n    layoutMode?: \"browser\" | \"computed\";\n  };\n\n// Per-mounted-view counter feeding a distinct tint-filter id prefix. The\n// `filter: url(#id)` references and their `<svg><defs>` share the document, so\n// two live views (couch-coop's per-player renders) — or a dev harness showing a\n// live view beside a static one — would otherwise collide on `godot-tint-N` and\n// resolve each other's filters. Each `useGodotSceneModel` call (one per view)\n// takes the next prefix; the static renderers keep the unprefixed default, so\n// their goldens are unchanged.\nlet tintFilterViewSeq = 0;\nfunction nextTintFilterIdPrefix(): string {\n  tintFilterViewSeq += 1;\n  return `godot-tint-v${tintFilterViewSeq}-`;\n}\n\nexport interface GodotSubscribableResourceSource {\n  subscribe: (listener: () => void) => () => void;\n  /**\n   * Monotonic settle counters from the backing resolver (see the gsw fetch\n   * resolver's `generations()`). When present, `useGodotSceneModel` memoizes the\n   * scene-graph derivation on (input identities + the `scenes` counter): graph\n   * derivation reads scene documents but never `.tres`/font/texture content, so\n   * resource-only settle notifications skip the derive and rebuild only the HTML\n   * model. Absent ⇒ derive runs on every recompute (always correct).\n   */\n  generations?: () => { scenes: number; resources: number };\n}\n\nexport interface GodotSceneModelSource {\n  scene?: GodotSceneState;\n  model?: GodotHtmlModel;\n  options?: GodotSceneViewOptions;\n  resolveResource?: (ref: GodotResourceRefValue, node: GodotNode) => unknown;\n  resolveResourcePath?: (path: string, node: GodotNode) => unknown;\n  overrideNodeProps?: (\n    node: GodotNode,\n    path: string,\n  ) => Record<string, GodotVariant> | undefined;\n  overrideNodeType?: (node: GodotNode, path: string) => string | undefined;\n  nodeOverrides?: GodotNodePropertyOverrideMap;\n  nodeNameOverrides?: GodotNodePropertyOverrideMap;\n  mountExternalScene?: (\n    ref: GodotResourceRefValue,\n    node: GodotNode,\n  ) => GodotSceneState | undefined;\n  resourceSource?: GodotSubscribableResourceSource;\n}\n\nexport type GodotNodePropertyOverrideMap = Record<\n  string,\n  Record<string, GodotVariant>\n>;\nexport type GodotNodePropertyOverrideResolver = (\n  node: GodotNode,\n  path: string,\n) => Record<string, GodotVariant> | undefined;\n\n// The model the COMPONENT renderer consumes: per-node browser-native html\n// (identity-stable for unchanged nodes), the behind/normal child slots (stabilized\n// so a parent's child list keeps identity across leaf-only changes), and the shared\n// font/tint/resource accumulators. Built incrementally by `buildComponentSceneModel`\n// (per-node memo over the post-3.1 identity-stable scene graph), then PROVIDED so\n// each `GodotNodeView` pulls only its own node — a leaf change re-renders just it.\ninterface ComponentSceneModel {\n  rootPaths: string[];\n  nodesByPath: Map<string, GodotHtmlNode>;\n  childrenByPath: Map<string, { behind: string[]; normal: string[] }>;\n  fontFaces: GodotHtmlFontFace[];\n  tintFilters: Array<{ id: string; markup: string }>;\n  resourceStatuses: GodotResourceStatus[];\n  viewport: { width: number; height: number };\n  contentScale: ResolvedContentScale | null;\n  // Only read with `includeBaseCss` (component mode never does); kept so the model\n  // satisfies `buildStyleElement`'s input.\n  css: string;\n}\n\n// The provided component model. A `ComputedRef` (not the value) so each node\n// component subscribes once and re-pulls its own entry when the model rebuilds —\n// `null` outside component mode.\nconst COMPONENT_MODEL_KEY: InjectionKey<\n  ComputedRef<ComponentSceneModel | null>\n> = Symbol(\"godot-component-model\");\n\n// Scaffolding (font `<style>`, tint `<defs>`) carries no node children, so the\n// shared `renderElement` emits it identically with no slots needed.\nconst EMPTY_SLOTS: Slots = {};\n\n// A leaf (or hidden/missing) node's slots — a shared constant so a leaf's `slots`\n// pull stays `===` across rebuilds and never forces a re-render.\nconst NO_CHILD_SLOTS: { behind: string[]; normal: string[] } = {\n  behind: [],\n  normal: [],\n};\n\n// One scene node, rendered as its OWN Vue component. It PULLS its built html node\n// and child slots from the injected component model (keyed by `path`) rather than\n// receiving them as pushed props — so when the model rebuilds, only the components\n// whose own node/slots changed VALUE re-render (Vue's computed value-equality skips\n// the rest), while a parent never re-renders just because a descendant changed.\n// Vue devtools shows one component per scene node.\nexport const GodotNodeView = defineComponent({\n  name: \"GodotNodeView\",\n  props: {\n    path: {\n      type: String,\n      required: true,\n    },\n  },\n  setup(props) {\n    const model = inject(COMPONENT_MODEL_KEY, null);\n    const node = computed<GodotHtmlNode | null>(\n      () => model?.value?.nodesByPath.get(props.path) ?? null,\n    );\n    const slots = computed(\n      () => model?.value?.childrenByPath.get(props.path) ?? NO_CHILD_SLOTS,\n    );\n    return () => {\n      const current = node.value;\n      if (!current) {\n        return null;\n      }\n      return renderComponentNode(current, slots.value);\n    };\n  },\n});\n\n// Emit one built node as Vue vnodes — the SAME shape as `buildNodeElement`: the\n// outer element (carrying `data-godot-path` etc.) wraps `[behind children,\n// self-layer, normal children]` in Godot's around-the-node paint order; the\n// self-layer carries the node's paint/text. Children are nested `GodotNodeView`s\n// addressed by path (they pull their own data).\nfunction renderComponentNode(\n  node: GodotHtmlNode,\n  slots: { behind: string[]; normal: string[] },\n): VNodeChild {\n  const shell = buildNodePresentation(node);\n  if (shell.kind === \"comment\") return createCommentVNode(shell.text ?? \"\");\n  const self = shell.children?.[0];\n  const childComponent = (path: string): VNodeChild =>\n    h(GodotNodeView, { key: path, path });\n  return h(\n    shell.tag,\n    {\n      key: shell.key,\n      class: shell.className,\n      style: shell.style,\n      ...shell.attributes,\n    },\n    [\n      ...slots.behind.map(childComponent),\n      ...(self ? [renderElement(self, EMPTY_SLOTS)] : []),\n      ...slots.normal.map(childComponent),\n    ],\n  );\n}\n\n// The scene as a component tree: the shared scaffolding (font `<style>`, tint\n// `<defs>`) emitted from the model's accumulators exactly as the fragment path,\n// then the stage (+ content-scale frame) whose ROOT nodes are `GodotNodeView`\n// components addressed by path. The component model itself is provided in\n// `GodotSceneView` setup; this only emits the shell.\nfunction renderComponentTree(\n  model: ComponentSceneModel,\n  frameRef: Ref<HTMLElement | null>,\n  stageRef: Ref<HTMLElement | null>,\n  debug: boolean,\n): VNodeChild[] {\n  const out: VNodeChild[] = [];\n  const style = buildStyleElement(model, { includeBaseCss: false });\n  if (style) {\n    out.push(renderElement(style, EMPTY_SLOTS));\n  }\n  const tintDefs = buildTintDefsElement(model);\n  if (tintDefs) {\n    out.push(renderElement(tintDefs, EMPTY_SLOTS));\n  }\n  const stageStyle: Record<string, string> = model.contentScale\n    ? { ...contentScaleStageStyle(model.contentScale) }\n    : {\n        width: `${model.viewport.width}px`,\n        height: `${model.viewport.height}px`,\n      };\n  const stage = h(\n    \"div\",\n    {\n      class: debug ? `${STAGE_CLASS} godot-scene-debug` : STAGE_CLASS,\n      \"data-godot-stage\": \"true\",\n      ref: stageRef,\n      style: stageStyle,\n    },\n    model.rootPaths.map((path) => h(GodotNodeView, { key: path, path })),\n  );\n  if (!model.contentScale) {\n    out.push(stage);\n    return out;\n  }\n  const background = model.contentScale.background;\n  out.push(\n    h(\n      \"div\",\n      {\n        class: FRAME_CLASS,\n        ref: frameRef,\n        style: background ? { background } : {},\n      },\n      [stage],\n    ),\n  );\n  return out;\n}\n\n// Per-view caches threaded across rebuilds (held in `GodotSceneView` setup): a\n// node entry is reused when its (identity-stable) SceneGraphNode AND parent context\n// are unchanged; a child-slots entry when its children's identities are unchanged.\ninterface ComponentNodeCacheEntry {\n  graphNode: SceneGraphNode;\n  ctxKey: string;\n  result: GraphNodeBuildResult;\n}\ninterface ComponentChildCacheEntry {\n  key: string;\n  slots: { behind: string[]; normal: string[] };\n}\n\nfunction parentContextKey(ctx: BrowserNativeParentContext): string {\n  return `${ctx.parentType ?? \"\"}|${ctx.parentHorizontal ? 1 : 0}`;\n}\n\n// Identity key for a parent's child slots: ONLY the child PATHS + their behind/\n// normal split (newline-joined; paths never contain a newline). A child's PROP\n// change does NOT change this — so the parent's `children` pull stays `===` and the\n// parent never re-renders just because a descendant changed; only a structural\n// change (child added/removed/reordered, or a behind/draw-order shift) does.\nfunction childSlotsKey(slots: { behind: string[]; normal: string[] }): string {\n  return `${slots.behind.join(\"\\n\")}\\u0000${slots.normal.join(\"\\n\")}`;\n}\n\n// Build the component model from a `SceneGraph`, reusing per-node html for every\n// node whose SceneGraphNode identity + parent context are unchanged. Because the\n// post-3.1 graph keeps unchanged nodes `===`, a leaf change rebuilds only the\n// changed node(s); every other entry (and every stabilized child-slot object)\n// keeps identity, so the downstream pulls compare equal and skip re-rendering.\n// `tintFilters` is the view's lifetime-stable filter table (append-only: a markup\n// keeps its id), so a reused node's baked `filter: url(#id)` stays valid.\nfunction buildComponentSceneModel(\n  graph: SceneGraph,\n  options: GodotHtmlRenderOptions,\n  viewport: { width: number; height: number },\n  contentScale: ResolvedContentScale | null,\n  nodeCache: Map<string, ComponentNodeCacheEntry>,\n  childCache: Map<string, ComponentChildCacheEntry>,\n  tintFilters: Map<string, string>,\n): ComponentSceneModel {\n  const structure = buildSceneStructure(graph);\n  const nodesByPath = new Map<string, GodotHtmlNode>();\n  const fontFaces: GodotHtmlFontFace[] = [];\n  const resourceStatuses: GodotResourceStatus[] = [\n    ...(graph.resourceStatuses ?? []),\n  ];\n  const builtPaths = new Set<string>();\n\n  const walk = (\n    path: string,\n    parentLayout: GodotSceneTreeNode | undefined,\n    parentPath: string | null,\n    parentContext: BrowserNativeParentContext,\n  ): void => {\n    const graphNode = structure.nodesByPath.get(path);\n    if (!graphNode) {\n      return;\n    }\n    builtPaths.add(path);\n    if (!graphNode.visible) {\n      // Hidden: comment placeholder in its slot; prune the subtree (descendants\n      // dropped, fonts/tints unregistered) — matching the batch model.\n      nodesByPath.set(path, buildHiddenGraphNode(graphNode, parentPath));\n      return;\n    }\n    const ctxKey = parentContextKey(parentContext);\n    let entry = nodeCache.get(path);\n    // Force re-derive a node whose previous build still had PENDING resources. The graph node\n    // identity is stable across a resource-only settle (the graph is memoized on the SCENES\n    // generation), so without this the cached entry pins the node's pending placeholder (e.g. an\n    // atlas sprite showing its raw `.tres` doc url) even after the doc loads and the resolver can\n    // return the cropped image. Load-time-bounded: once every resource is ready the node has no\n    // pending status, so steady state never re-derives.\n    const hadPendingResource =\n      entry?.result.resourceStatuses.some(\n        (status) => status.status === \"pending\",\n      ) ?? false;\n    if (\n      !entry ||\n      entry.graphNode !== graphNode ||\n      entry.ctxKey !== ctxKey ||\n      hadPendingResource\n    ) {\n      const result = buildGraphNodeHtml(\n        graphNode,\n        parentLayout,\n        parentPath,\n        parentContext,\n        options,\n        tintFilters,\n        viewport,\n        contentScale,\n      );\n      entry = { graphNode, ctxKey, result };\n      nodeCache.set(path, entry);\n    }\n    nodesByPath.set(path, entry.result.node);\n    fontFaces.push(...entry.result.fontFaces);\n    resourceStatuses.push(...entry.result.resourceStatuses);\n    const slots = structure.childrenByPath.get(path);\n    if (slots) {\n      for (const childPath of slots.behind) {\n        walk(childPath, entry.result.layout, path, entry.result.childContext);\n      }\n      for (const childPath of slots.normal) {\n        walk(childPath, entry.result.layout, path, entry.result.childContext);\n      }\n    }\n  };\n  for (const rootPath of structure.rootPaths) {\n    walk(rootPath, undefined, null, ROOT_PARENT_CONTEXT);\n  }\n  // Evict cache entries for nodes that vanished (e.g. a mount removed).\n  for (const key of [...nodeCache.keys()]) {\n    if (!builtPaths.has(key)) {\n      nodeCache.delete(key);\n    }\n  }\n\n  // Stabilize behind/normal child slots: reuse the previous object when the child\n  // PATHS are unchanged, so a parent's `children` pull stays `===` across leaf-only\n  // changes (no parent re-render) — only a structural change yields a new object.\n  const childrenByPath = new Map<\n    string,\n    { behind: string[]; normal: string[] }\n  >();\n  for (const [path, slots] of structure.childrenByPath) {\n    if (!builtPaths.has(path) || !structure.nodesByPath.get(path)?.visible) {\n      continue;\n    }\n    const key = childSlotsKey(slots);\n    const cached = childCache.get(path);\n    if (cached && cached.key === key) {\n      childrenByPath.set(path, cached.slots);\n    } else {\n      childCache.set(path, { key, slots });\n      childrenByPath.set(path, slots);\n    }\n  }\n  for (const key of [...childCache.keys()]) {\n    if (!childrenByPath.has(key)) {\n      childCache.delete(key);\n    }\n  }\n\n  return {\n    rootPaths: structure.rootPaths,\n    nodesByPath,\n    childrenByPath,\n    fontFaces: uniqueFontFaces(fontFaces),\n    tintFilters: [...tintFilters].map(([markup, id]) => ({ id, markup })),\n    resourceStatuses,\n    viewport,\n    contentScale,\n    css: \"\",\n  };\n}\n\nexport const GodotSceneView = defineComponent({\n  name: \"GodotSceneView\",\n  props: {\n    scene: {\n      type: Object as PropType<GodotSceneState>,\n      required: false,\n      default: undefined,\n    },\n    model: {\n      type: Object as PropType<GodotHtmlModel>,\n      required: false,\n      default: undefined,\n    },\n    options: {\n      type: Object as PropType<GodotSceneViewOptions>,\n      required: false,\n      default: () => ({}),\n    },\n    resolveResource: {\n      type: Function as PropType<\n        (ref: GodotResourceRefValue, node: GodotNode) => unknown\n      >,\n      required: false,\n      default: undefined,\n    },\n    resolveResourcePath: {\n      type: Function as PropType<(path: string, node: GodotNode) => unknown>,\n      required: false,\n      default: undefined,\n    },\n    overrideNodeProps: {\n      type: Function as PropType<\n        (\n          node: GodotNode,\n          path: string,\n        ) => Record<string, GodotVariant> | undefined\n      >,\n      required: false,\n      default: undefined,\n    },\n    overrideNodeType: {\n      type: Function as PropType<\n        (node: GodotNode, path: string) => string | undefined\n      >,\n      required: false,\n      default: undefined,\n    },\n    nodeOverrides: {\n      type: Object as PropType<GodotNodePropertyOverrideMap>,\n      required: false,\n      default: () => ({}),\n    },\n    nodeNameOverrides: {\n      type: Object as PropType<GodotNodePropertyOverrideMap>,\n      required: false,\n      default: () => ({}),\n    },\n    mountExternalScene: {\n      type: Function as PropType<\n        (\n          ref: GodotResourceRefValue,\n          node: GodotNode,\n        ) => GodotSceneState | undefined\n      >,\n      required: false,\n      default: undefined,\n    },\n    resourceSource: {\n      type: Object as PropType<GodotSubscribableResourceSource>,\n      required: false,\n      default: undefined,\n    },\n    debug: {\n      type: Boolean,\n      default: false,\n    },\n    // Render the scene as a recursive `GodotNodeView` COMPONENT tree (one component\n    // per node) instead of the flat single-vnode fragment. Same DOM + same model\n    // inputs; opt-in while the component path is validated (structural parity) and\n    // grown toward fine-grained per-node reactivity. The `#node` slot and the\n    // stabilize/vnode-cache fast path are fragment-mode only.\n    componentTree: {\n      type: Boolean,\n      default: false,\n    },\n  },\n  setup(props, { slots }) {\n    const sceneModel = useGodotSceneModel(props);\n    const fragmentModel = sceneModel.model;\n\n    // Component-tree mode: build an incremental, per-node-memoized model from the\n    // (identity-stable, post-3.1) scene graph and PROVIDE it as a `ComputedRef` so\n    // each `GodotNodeView` pulls only its own node. Caches + the lifetime-stable\n    // tint table live here, threaded across rebuilds. `null` outside component mode\n    // (the graph is never read, so nothing derives).\n    const nodeCache = new Map<string, ComponentNodeCacheEntry>();\n    const childCache = new Map<string, ComponentChildCacheEntry>();\n    const componentTintFilters = new Map<string, string>();\n    const componentModel = computed<ComponentSceneModel | null>(() => {\n      if (!props.componentTree) {\n        return null;\n      }\n      // Rebuild on EVERY resolver settle, not only when the graph identity changes. A resource-only\n      // settle (a `.tres`/font/texture doc finishing load) keeps the memoized graph `===` (it's keyed\n      // on the SCENES generation), so depending on `graph.value` alone would never rebuild and a node\n      // that resolved to a PENDING placeholder (an atlas sprite showing its raw `.tres` url) would be\n      // pinned forever. `buildComponentSceneModel` re-derives only the nodes whose resources were\n      // pending; everything else keeps its cached entry, so steady state stays cheap.\n      sceneModel.revision.value;\n      const graph = sceneModel.graph.value;\n      if (!graph) {\n        return null;\n      }\n      const options = props.options ?? {};\n      const htmlOptions = resolveHtmlOptions(\n        props,\n        sceneModel.tintFilterIdPrefix,\n      );\n      const viewport = {\n        width: options.viewport?.width ?? DEFAULT_BROWSER_VIEWPORT.width,\n        height: options.viewport?.height ?? DEFAULT_BROWSER_VIEWPORT.height,\n      };\n      const contentScale = resolveContentScale(options.contentScale, viewport);\n      return buildComponentSceneModel(\n        graph,\n        htmlOptions,\n        viewport,\n        contentScale,\n        nodeCache,\n        childCache,\n        componentTintFilters,\n      );\n    });\n    provide(COMPONENT_MODEL_KEY, componentModel);\n\n    // The model the render actually consumes (so the scale observer never forces\n    // the inactive renderer to build).\n    const activeModel = computed<GodotHtmlModel | ComponentSceneModel | null>(\n      () => (props.componentTree ? componentModel.value : fragmentModel.value),\n    );\n\n    // Transform-technique content-scale needs the live frame size; drive\n    // `--godot-scale` from a ResizeObserver. The container technique is CSS-only\n    // and needs none of this.\n    const frame = ref<HTMLElement | null>(null);\n    // The live runtimes (WebGL shaders + particles) attach to the mounted stage.\n    const stage = ref<HTMLElement | null>(null);\n    let disposeScale: (() => void) | null = null;\n    const syncScale = (): void => {\n      disposeScale?.();\n      disposeScale = null;\n      const contentScale = activeModel.value?.contentScale;\n      if (\n        contentScale &&\n        contentScale.technique === \"transform\" &&\n        frame.value\n      ) {\n        disposeScale = observeContentScale(frame.value, contentScale.base);\n      }\n    };\n    onMounted(syncScale);\n    watch([activeModel, frame], syncScale, { flush: \"post\" });\n    onBeforeUnmount(() => {\n      disposeScale?.();\n      disposeScale = null;\n    });\n\n    // Live runtime ownership, mirroring the content-scale observer above. Runs\n    // post-DOM-update so `stage.value` is the freshly mounted element; reconciles on\n    // model changes (the DOM nodes + their `data-godot-particle-specs` may have changed).\n    // Both runtimes are no-ops unless their option is set / WebGL2 is available.\n    // `externalRuntimes` hosts own persistent runtimes over this DOM — attaching here\n    // too would double-bind every node (two stacked canvases per shader node).\n    let effectsHost: HtmlEffectsHost | null = null;\n    let runtimeRoot: HTMLElement | null = null;\n    const disposeRuntimes = (): void => {\n      effectsHost?.dispose();\n      effectsHost = null;\n      runtimeRoot = null;\n    };\n    const syncRuntimes = (): void => {\n      const el = stage.value;\n      if (!el) {\n        disposeRuntimes();\n        return;\n      }\n      const options = resolveHtmlOptions(props, sceneModel.tintFilterIdPrefix);\n      if (runtimeRoot !== el) {\n        disposeRuntimes();\n        runtimeRoot = el;\n        effectsHost = createHtmlEffectsHost(el, options);\n      } else {\n        effectsHost?.updateOptions(options);\n      }\n      effectsHost?.reconcile();\n    };\n    onMounted(syncRuntimes);\n    watch([activeModel, stage], syncRuntimes, { flush: \"post\" });\n    onBeforeUnmount(() => {\n      disposeRuntimes();\n    });\n\n    // Incremental re-render (fragment path): each model rebuild hands us an all-new\n    // element tree, so without help every cycle re-creates every vnode and Vue\n    // re-diffs every prop. `stabilizeRenderElements` restores object identity for\n    // unchanged subtrees against the previous fragment; the WeakMap then reuses their\n    // vnodes wholesale — Vue's normalization clones a reused vnode but keeps its props\n    // and children REFERENCES, so per-prop diffing collapses to identity checks. The\n    // `#node` slot disables this (slot output can depend on state the element\n    // comparison can't see, and it reads `sourceNode`, which stabilization ignores).\n    // The component path replaces all of this with per-node component reactivity.\n    let previousFragment: RenderElement[] | undefined;\n    const vnodeCache = new WeakMap<RenderElement, VNodeChild>();\n\n    return () => {\n      // Component-tree mode: render each node as its own `GodotNodeView` component\n      // pulling from the provided model (Vue-native per-node reactivity + devtools),\n      // emitting the same scaffolding + DOM as the fragment path.\n      if (props.componentTree) {\n        previousFragment = undefined;\n        const current = componentModel.value;\n        if (!current) {\n          return null;\n        }\n        return renderComponentTree(current, frame, stage, props.debug);\n      }\n      const current = fragmentModel.value;\n      if (!current) {\n        previousFragment = undefined;\n        return null;\n      }\n      // Emit the SAME structural fragment the DOM and HTML-string renderers build\n      // (`<style>` @font-face, tint-filter defs, stage/frame). The Vue view is now a\n      // thin emitter over the shared tree, so it can't drift from the others. Fonts\n      // are self-injected (as the live view always has); base CSS stays a host\n      // concern, matching the prior behavior. The frame element (when content-\n      // scaled) takes the `frame` ref so the ResizeObserver can drive `--godot-scale`.\n      let fragment = buildSceneFragment(current, {\n        debug: props.debug,\n        includeStyle: true,\n        includeBaseCss: false,\n      });\n      if (slots.node) {\n        previousFragment = undefined;\n        return fragment.map((element) =>\n          renderElement(element, slots, frame, undefined, stage),\n        );\n      }\n      fragment = stabilizeRenderElements(previousFragment, fragment);\n      previousFragment = fragment;\n      return fragment.map((element) =>\n        renderElement(element, slots, frame, vnodeCache, stage),\n      );\n    };\n  },\n});\n\nexport function useGodotSceneModel(source: GodotSceneModelSource): {\n  model: ComputedRef<GodotHtmlModel | null>;\n  // The identity-stable scene graph (post-3.1 node memo). Exposed so the component\n  // renderer can build its model from the SAME derivation; `null` in direct-`model`\n  // mode (no scene to derive).\n  graph: ComputedRef<SceneGraph | null>;\n  // The per-view tint-filter id prefix (lifetime-stable) the component build reuses.\n  tintFilterIdPrefix: string;\n  // Bumps on every resolver settle (scene/resource/font doc finishing load). The component\n  // model depends on it so it rebuilds when a resource transitions PENDING → ready even though\n  // the memoized scene graph keeps identity (the fragment `model` reads it for the same reason).\n  revision: ComputedRef<number>;\n  pendingResources: ComputedRef<GodotResourceStatus[]>;\n  failedResources: ComputedRef<GodotResourceStatus[]>;\n} {\n  const revision = ref(0);\n  // Stable for this view's lifetime (re-renders reuse it, so filter ids don't churn).\n  const tintFilterIdPrefix = nextTintFilterIdPrefix();\n  let unsubscribe: (() => void) | null = null;\n  const resubscribe = (\n    resourceSource: GodotSubscribableResourceSource | undefined,\n  ): void => {\n    unsubscribe?.();\n    unsubscribe = resourceSource\n      ? resourceSource.subscribe(() => {\n          revision.value += 1;\n        })\n      : null;\n  };\n  watch(() => source.resourceSource, resubscribe, { immediate: true });\n  onBeforeUnmount(() => {\n    unsubscribe?.();\n    unsubscribe = null;\n  });\n  const deriveMemo: DeriveMemo = { entry: null };\n  // Per-view cross-render node cache: when the one-entry graph memo misses (any\n  // override changed), this lets `deriveSceneGraph` reuse the SceneGraphNode object of\n  // every node whose render fields are unchanged, so a host attack re-derives only the\n  // changed nodes (and the html/component builds downstream bail out on the reused\n  // identity).\n  const nodeMemo = createSceneGraphNodeMemo();\n  // The graph is the single shared producer; both the fragment html model and the\n  // component model read `graph.value` (so derivation runs at most once per change).\n  const graph = computed<SceneGraph | null>(() => {\n    revision.value;\n    if (source.model) {\n      return null;\n    }\n    return resolveSceneGraph(source, deriveMemo, nodeMemo);\n  });\n  const model = computed<GodotHtmlModel | null>(() => {\n    if (source.model) {\n      return source.model;\n    }\n    const resolved = graph.value;\n    if (!resolved) {\n      return null;\n    }\n    const options = source.options ?? {};\n    const htmlOptions = resolveHtmlOptions(source, tintFilterIdPrefix);\n    // Computed mode (opt-in): run the rect cascade and render absolute px.\n    if (options.layoutMode === \"computed\") {\n      const tree = resolveGodotSceneTree(\n        resolved,\n        resolveStructureOptions(source),\n      );\n      return renderSceneToHtmlModel(tree, htmlOptions);\n    }\n    // Browser-native (default): the CSS engine resolves geometry from the graph.\n    return renderSceneGraphToHtmlModel(resolved, {\n      ...htmlOptions,\n      viewport: options.viewport,\n    });\n  });\n  const pendingResources = computed(() =>\n    (model.value?.resourceStatuses ?? []).filter(\n      (resource) => resource.status === \"pending\",\n    ),\n  );\n  const failedResources = computed(() =>\n    (model.value?.resourceStatuses ?? []).filter(\n      (resource) => resource.status === \"error\",\n    ),\n  );\n  return {\n    model,\n    graph,\n    tintFilterIdPrefix,\n    revision: computed(() => revision.value),\n    pendingResources,\n    failedResources,\n  };\n}\n\n// One-entry derive memo, per view. The scene graph is a pure function of the\n// scene document tree and the structural option hooks: it mounts external\n// SCENES but never reads `.tres`/font/texture content. So a cached graph stays\n// valid while (a) every structural input keeps object identity and (b) the\n// resolver's SCENE cache is unchanged — the `scenes` settle counter from\n// `GodotSubscribableResourceSource.generations`. Resource-only settles (the\n// majority of a load's notifications) then skip straight to the HTML rebuild.\ninterface DeriveMemo {\n  entry: {\n    keys: readonly unknown[];\n    scenesGeneration: number;\n    graph: SceneGraph;\n  } | null;\n}\n\nfunction deriveMemoKeys(source: GodotSceneModelSource): readonly unknown[] {\n  return [\n    source.scene,\n    source.options,\n    source.resolveResource,\n    source.resolveResourcePath,\n    source.overrideNodeProps,\n    source.overrideNodeType,\n    source.nodeOverrides,\n    source.nodeNameOverrides,\n    source.mountExternalScene,\n  ];\n}\n\n// Structural options drive the single shared producer (`deriveSceneGraph`), which\n// both render modes consume. Merges the resolver/override/mount hooks from `options`\n// and the dedicated props.\nfunction resolveStructureOptions(source: GodotSceneModelSource) {\n  const options = source.options ?? {};\n  const resolveResource = source.resolveResource ?? options.resolveResource;\n  return {\n    ...options,\n    resolveResource,\n    overrideNodeProps: resolveVueNodePropsOverride(\n      options.overrideNodeProps,\n      source.overrideNodeProps,\n      source.nodeNameOverrides ?? {},\n      source.nodeOverrides ?? {},\n    ),\n    overrideNodeType: source.overrideNodeType ?? options.overrideNodeType,\n    mountExternalScene: source.mountExternalScene ?? options.mountExternalScene,\n  };\n}\n\n// The per-node html options (paint/text resolvers + tint id prefix), shared by the\n// fragment html model and the component build.\nfunction resolveHtmlOptions(\n  source: GodotSceneModelSource,\n  tintFilterIdPrefix?: string,\n): GodotHtmlMountOptions {\n  const options = source.options ?? {};\n  return {\n    ...options,\n    resolveResource: source.resolveResource ?? options.resolveResource,\n    resolveResourcePath:\n      source.resolveResourcePath ?? options.resolveResourcePath,\n    // A caller-supplied prefix (via `options`) wins; otherwise the per-view prefix\n    // keeps each mounted view's `<filter>` ids from colliding.\n    tintFilterIdPrefix: options.tintFilterIdPrefix ?? tintFilterIdPrefix,\n  };\n}\n\n// Derive (or reuse via the one-entry memo) the structural scene graph. The node\n// memo inside `deriveSceneGraph` keeps unchanged nodes identity-stable across\n// derives even when this one-entry memo misses.\nfunction resolveSceneGraph(\n  source: GodotSceneModelSource,\n  deriveMemo?: DeriveMemo,\n  nodeMemo?: SceneGraphNodeMemo,\n): SceneGraph | null {\n  if (!source.scene) {\n    return null;\n  }\n  const structureOptions = resolveStructureOptions(source);\n  const scenesGeneration = source.resourceSource?.generations?.().scenes;\n  const memoKeys = deriveMemoKeys(source);\n  const memoEntry = deriveMemo?.entry;\n  if (\n    memoEntry &&\n    scenesGeneration !== undefined &&\n    memoEntry.scenesGeneration === scenesGeneration &&\n    memoEntry.keys.length === memoKeys.length &&\n    memoEntry.keys.every((key, index) => key === memoKeys[index])\n  ) {\n    return memoEntry.graph;\n  }\n  const graph = deriveSceneGraph(source.scene, structureOptions, nodeMemo);\n  if (deriveMemo && scenesGeneration !== undefined) {\n    deriveMemo.entry = { keys: memoKeys, scenesGeneration, graph };\n  }\n  return graph;\n}\n\nexport function overrideGodotNodePropsByPath(\n  overrides: GodotNodePropertyOverrideMap,\n): GodotNodePropertyOverrideResolver {\n  return (_node, path) => overrides[path];\n}\n\nexport function overrideGodotNodePropsByName(\n  overrides: GodotNodePropertyOverrideMap,\n): GodotNodePropertyOverrideResolver {\n  return (node) => overrides[node.name];\n}\n\nexport function mergeGodotNodePropOverrides(\n  ...resolvers: Array<GodotNodePropertyOverrideResolver | undefined>\n): GodotNodePropertyOverrideResolver {\n  return (node, path) => {\n    const merged: Record<string, GodotVariant> = {};\n    for (const resolver of resolvers) {\n      Object.assign(merged, resolver?.(node, path));\n    }\n    return Object.keys(merged).length > 0 ? merged : undefined;\n  };\n}\n\nfunction resolveVueNodePropsOverride(\n  optionsOverride: GodotNodePropertyOverrideResolver | undefined,\n  propOverride: GodotNodePropertyOverrideResolver | undefined,\n  nameOverrides: GodotNodePropertyOverrideMap,\n  pathOverrides: GodotNodePropertyOverrideMap,\n): GodotNodePropertyOverrideResolver {\n  return mergeGodotNodePropOverrides(\n    optionsOverride,\n    propOverride,\n    overrideGodotNodePropsByName(nameOverrides),\n    overrideGodotNodePropsByPath(pathOverrides),\n  );\n}\n\n// Emit a shared `RenderElement` tree as Vue vnodes. The structure (node element,\n// self-layer, behind/self/normal order, rich-text innerHTML, scaffolding) comes\n// from the shared builder; this function only translates it to `h()` calls and\n// layers on the Vue-specific concerns: per-node `key`, the `#node` full-replace\n// slot, and the content-scale frame `ref`.\n//\n// With a `cache` (stabilized fragments only — see GodotSceneView), an element\n// whose object identity survived stabilization returns its previous vnode\n// untouched. Reusing a mounted vnode at the same position is the static-hoist\n// pattern: Vue clones it during child normalization, and the clone's shared\n// props/children references short-circuit the patch. Never combined with the\n// `#node` slot (the caller guarantees `slots.node` is absent when caching).\nfunction renderElement(\n  element: RenderElement,\n  slots: Slots,\n  frameRef?: Ref<HTMLElement | null>,\n  cache?: WeakMap<RenderElement, VNodeChild>,\n  stageRef?: Ref<HTMLElement | null>,\n): VNodeChild {\n  const cached = cache?.get(element);\n  if (cached !== undefined) {\n    return cached;\n  }\n  if (element.kind === \"comment\") {\n    // Hidden-placeholder node: emit the same comment anchor Vue produces for\n    // `v-if: false`. Carries no `sourceNode`, so the `#node` slot never sees it.\n    const comment = createCommentVNode(element.text ?? \"\");\n    cache?.set(element, comment);\n    return comment;\n  }\n  const data: Record<string, unknown> = {};\n  if (element.key !== undefined) {\n    data.key = element.key;\n  }\n  if (element.className !== undefined) {\n    data.class = element.className;\n  }\n  if (element.style !== undefined) {\n    data.style = element.style;\n  }\n  if (element.attributes) {\n    Object.assign(data, element.attributes);\n  }\n  if (frameRef && element.className === FRAME_CLASS) {\n    data.ref = frameRef;\n  }\n  // The live runtimes (WebGL shaders, particles) attach to the mounted stage element.\n  if (stageRef && element.attributes?.[\"data-godot-stage\"] === \"true\") {\n    data.ref = stageRef;\n  }\n\n  // Per-node element: expose the `#node` full-replace slot (`slot ?? default`).\n  // The slot receives the model node and its rendered CHILD-NODE vnodes in source\n  // order (excluding the self-layer), preserving the prior public contract.\n  if (element.sourceNode && slots.node) {\n    const node = element.sourceNode;\n    const renderedByPath = new Map<string, VNodeChild>();\n    const defaultChildren = (element.children ?? []).map((child) => {\n      const vnode = renderElement(child, slots, frameRef, undefined, stageRef);\n      if (child.sourceNode) {\n        renderedByPath.set(child.sourceNode.path, vnode);\n      }\n      return vnode;\n    });\n    const childNodeVnodes = node.children\n      .map((path) => renderedByPath.get(path))\n      .filter((vnode): vnode is VNodeChild => vnode !== undefined);\n    const slotResult = slots.node({ node, children: childNodeVnodes });\n    return h(element.tag, data, slotResult ?? defaultChildren);\n  }\n\n  let vnode: VNodeChild;\n  if (element.rawHtml !== undefined) {\n    vnode = h(element.tag, { ...data, innerHTML: element.rawHtml });\n  } else if (element.text !== undefined) {\n    vnode = h(element.tag, data, [element.text]);\n  } else {\n    vnode = h(\n      element.tag,\n      data,\n      (element.children ?? []).map((child) =>\n        renderElement(child, slots, frameRef, cache, stageRef),\n      ),\n    );\n  }\n  cache?.set(element, vnode);\n  return vnode;\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@godot-scene-web/vue",
+  "version": "0.1.0",
+  "license": "MIT",
+  "type": "module",
+  "description": "Vue 3 components for godot-scene-web HTML scenes.",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tfoxy/godot-scene-web.git"
+  },
+  "homepage": "https://github.com/tfoxy/godot-scene-web#readme",
+  "bugs": {
+    "url": "https://github.com/tfoxy/godot-scene-web/issues"
+  },
+  "exports": {
+    ".": {
+      "development": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@godot-scene-web/core": "0.1.0",
+    "@godot-scene-web/scene-graph": "0.1.0",
+    "@godot-scene-web/html": "0.1.0",
+    "@godot-scene-web/layout": "0.1.0"
+  },
+  "peerDependencies": {
+    "vue": "^3.5.0"
+  },
+  "devDependencies": {
+    "vue": "^3.5.34"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "cd ../.. && vitest run --config vitest.config.ts packages/vue/test"
+  }
+}