@needle-tools/engine 5.1.0-alpha → 5.1.0-canary.30cc545

package/plugins/dts-generator/dts.scan.js

@@ -0,0 +1,71 @@
+// @ts-check
+/**
+ * Scans GLB/glTF files and returns structured binding data.
+ *
+ * Combines file discovery, JSON reading, component extraction, and manifest
+ * type resolution into the `BindingEntry[]` array consumed by codegen.
+ */
+
+import { resolveEntrypointGlbs, collectSceneFiles } from './glb.discovery.js';
+import { readGlbJsonChunk, readGltfJsonFile, readRemoteGlbJsonChunk } from './glb.reader.js';
+import { extractComponentBindings, inferTsType } from './glb.extractor.js';
+import { componentsManifest } from './manifest.types.js';
+
+/**
+ * @typedef {Object} BindingEntry
+ * @property {string} nodeName
+ * @property {string} nodePath  Full hierarchy path e.g. "Scene/Cube/Child_Of_Cube"
+ * @property {string} componentName
+ * @property {Record<string, string>} fieldTypes  field name → TS type string
+ * @property {boolean} isEngineComponent  true if the component exists in components.needle.json
+ * @property {string} nodeThreeType  Three.js type of the parent node (e.g. `import("three").Mesh`)
+ */
+
+/**
+ * Scan GLB/glTF files and return structured binding data.
+ * Uses entrypoint GLBs (from index.html or gen.js) when available,
+ * otherwise falls back to scanning all GLBs in assetsDir.
+ *
+ * @param {string} assetsDir   Absolute path to the assets directory
+ * @param {string} [projectRoot]  Absolute path to the project root (enables entrypoint detection)
+ * @param {string} [codegenDir]   Absolute path to the codegen directory
+ * @returns {Promise<BindingEntry[]>}
+ */
+export async function scanBindings(assetsDir, projectRoot, codegenDir) {
+    /** @type {Array<{path: string, type: "glb"|"gltf", remote?: boolean}>} */
+    const files = /** @type {any} */ ((projectRoot ? resolveEntrypointGlbs(projectRoot, assetsDir, codegenDir) : null)
+        ?? collectSceneFiles(assetsDir));
+
+    /** @type {BindingEntry[]} */
+    const entries = [];
+
+    for (const file of files) {
+        const json = file.remote
+            ? await readRemoteGlbJsonChunk(file.path)
+            : file.type === "glb"
+                ? readGlbJsonChunk(file.path)
+                : readGltfJsonFile(file.path);
+        if (!json) continue;
+
+        for (const { nodeName, nodePath, componentName, fields, nodeThreeType } of extractComponentBindings(json)) {
+            /** @type {Record<string, string>} */
+            const fieldTypes = {};
+            if (componentName) {
+                const manifestFields = componentsManifest.get(componentName);
+                if (manifestFields) {
+                    for (const [k, tsType] of manifestFields) {
+                        fieldTypes[k] = tsType;
+                    }
+                } else {
+                    for (const [k, v] of Object.entries(fields)) {
+                        fieldTypes[k] = inferTsType(v);
+                    }
+                }
+            }
+            const isEngineComponent = componentName ? componentsManifest.has(componentName) : false;
+            entries.push({ nodeName, nodePath, componentName, fieldTypes, isEngineComponent, nodeThreeType });
+        }
+    }
+
+    return entries;
+}

package/plugins/dts-generator/dts.writer.js

@@ -0,0 +1,59 @@
+// @ts-check
+/**
+ * File writer — the only module that performs I/O writes.
+ *
+ * Orchestrates scanning, codegen, and writes the output files.
+ * Returns false if content was already up-to-date (no write performed).
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { scanBindings } from './dts.scan.js';
+import { generateDts, generateHtmlCustomData } from './dts.codegen.js';
+
+/**
+ * Scan assets and write `needle-bindings.d.ts` and `needle-html-data.json`
+ * to the output directory.
+ * Returns the number of bindings written, or `false` if content was already up-to-date.
+ *
+ * @param {object} opts
+ * @param {string} opts.assetsDir      Absolute path to assets directory
+ * @param {string} opts.outputPath     Absolute path to write needle-bindings.d.ts
+ * @param {string} [opts.projectRoot]  Project root — enables entrypoint GLB detection
+ * @param {string} [opts.codegenDir]   Codegen directory — used to find gen.js
+ * @returns {Promise<number | false>}
+ */
+export async function generateBindingsDts({ assetsDir, outputPath, projectRoot, codegenDir }) {
+    const entries = await scanBindings(assetsDir, projectRoot, codegenDir);
+    const content = generateDts(entries);
+    const htmlContent = generateHtmlCustomData(entries);
+
+    mkdirSync(dirname(outputPath), { recursive: true });
+
+    let dtsChanged = false;
+    try {
+        const existing = existsSync(outputPath) ? readFileSync(outputPath, "utf8") : "";
+        if (existing !== content) {
+            writeFileSync(outputPath, content, "utf8");
+            dtsChanged = true;
+        }
+    } catch (_e) {
+        writeFileSync(outputPath, content, "utf8");
+        dtsChanged = true;
+    }
+
+    const htmlDataPath = join(dirname(outputPath), "needle-html-data.json");
+    try {
+        const existingHtml = existsSync(htmlDataPath) ? readFileSync(htmlDataPath, "utf8") : "";
+        if (existingHtml !== htmlContent) {
+            writeFileSync(htmlDataPath, htmlContent, "utf8");
+        }
+    } catch (_e) {
+        writeFileSync(htmlDataPath, htmlContent, "utf8");
+    }
+
+    if (!dtsChanged) return false;
+    const nodeCount = new Set(entries.map(e => e.nodeName)).size;
+    const bindingCount = new Set(entries.filter(e => e.componentName).map(e => `${e.nodeName}/${e.componentName}`)).size;
+    return bindingCount > 0 ? bindingCount : nodeCount;
+}

package/plugins/dts-generator/glb.discovery.js

@@ -0,0 +1,162 @@
+// @ts-check
+/**
+ * GLB / glTF file discovery.
+ *
+ * Resolves which scene files to process — either from the project's entrypoints
+ * (index.html `<needle-engine src>` or gen.js push calls) or by recursively
+ * walking the assets directory.
+ */
+
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join, resolve } from 'path';
+
+/**
+ * Parse `<needle-engine src="...">` from HTML.
+ * Handles both single strings and JSON arrays.
+ * @param {string} html
+ * @returns {string[]}
+ */
+function parseSrcAttribute(html) {
+    const re = /<needle-engine[^>]*\ssrc=["']([^"']+)["']/gi;
+    /** @type {string[]} */
+    const out = [];
+    let m;
+    while ((m = re.exec(html)) !== null) {
+        const val = m[1].trim();
+        if (val.startsWith("[")) {
+            try {
+                const arr = JSON.parse(val);
+                if (Array.isArray(arr)) out.push(...arr.filter(v => typeof v === "string"));
+            } catch (_e) { /* malformed JSON, skip */ }
+        } else {
+            out.push(val);
+        }
+    }
+    return out;
+}
+
+/**
+ * Parse `needle_exported_files.push("path/to/file.glb")` lines from gen.js.
+ * @param {string} src
+ * @returns {string[]}
+ */
+function parseGenJs(src) {
+    const re = /needle_exported_files\.push\(["']([^"']+\.(?:glb|gltf))["']\)/gi;
+    /** @type {string[]} */
+    const out = [];
+    let m;
+    while ((m = re.exec(src)) !== null) {
+        out.push(m[1]);
+    }
+    return out;
+}
+
+/**
+ * Resolve a list of (possibly relative) GLB path strings to absolute paths.
+ * Remote URLs (http/https) are passed through as-is.
+ *
+ * @param {string[]} paths
+ * @param {string} projectRoot
+ * @param {string} assetsDir
+ * @returns {Array<{path: string, type: "glb"|"gltf", remote?: boolean}>}
+ */
+function resolveGlbPaths(paths, projectRoot, assetsDir) {
+    /** @type {Array<{path: string, type: "glb"|"gltf", remote?: boolean}>} */
+    const out = [];
+    for (const p of paths) {
+        if (p.startsWith("http://") || p.startsWith("https://")) {
+            const type = p.toLowerCase().endsWith(".gltf") ? "gltf" : "glb";
+            out.push({ path: p, type, remote: true });
+            continue;
+        }
+        const clean = p.replace(/^\.\//, "").replace(/^\//, "");
+        const candidates = [
+            join(projectRoot, clean),
+            join(assetsDir, clean.replace(/^assets\//, "")),
+        ];
+        for (const candidate of candidates) {
+            if (existsSync(candidate)) {
+                const type = candidate.toLowerCase().endsWith(".gltf") ? "gltf" : "glb";
+                out.push({ path: candidate, type });
+                break;
+            }
+        }
+    }
+    return out;
+}
+
+/**
+ * Resolve the entrypoint GLB file paths for a project.
+ *
+ * Priority:
+ *  1. `<needle-engine src="...">` attribute in `index.html`
+ *  2. `needle_exported_files.push("...")` lines in `{codegenDir}/gen.js`
+ *  3. Returns `null` — caller should fall back to `collectSceneFiles`.
+ *
+ * @param {string} projectRoot  Absolute path to the project root
+ * @param {string} assetsDir    Absolute path to the assets directory
+ * @param {string} [codegenDir] Absolute path to the codegen directory
+ * @returns {Array<{path: string, type: "glb"|"gltf", remote?: boolean}> | null}
+ */
+export function resolveEntrypointGlbs(projectRoot, assetsDir, codegenDir) {
+    const htmlPath = join(projectRoot, "index.html");
+    if (existsSync(htmlPath)) {
+        try {
+            const srcPaths = parseSrcAttribute(readFileSync(htmlPath, "utf8"));
+            if (srcPaths.length > 0) {
+                const resolved = resolveGlbPaths(srcPaths, projectRoot, assetsDir);
+                if (resolved.length > 0) return resolved;
+            }
+        } catch (_e) { /* ignore */ }
+    }
+
+    const genDir = codegenDir ?? join(projectRoot, "src", "generated");
+    const genPath = join(genDir, "gen.js");
+    if (existsSync(genPath)) {
+        try {
+            const genPaths = parseGenJs(readFileSync(genPath, "utf8"));
+            if (genPaths.length > 0) {
+                const resolved = resolveGlbPaths(genPaths, projectRoot, assetsDir);
+                if (resolved.length > 0) return resolved;
+            }
+        } catch (_e) { /* ignore */ }
+    }
+
+    return null;
+}
+
+/**
+ * Recursively collect all scene GLB/glTF files in a directory.
+ * Skips LOD and image sub-glbs that aren't scene roots.
+ *
+ * @param {string} assetsDir
+ * @returns {Array<{path: string, type: "glb"|"gltf"}>}
+ */
+export function collectSceneFiles(assetsDir) {
+    if (!existsSync(assetsDir)) return [];
+
+    /** @type {Array<{path: string, type: "glb"|"gltf"}>} */
+    const out = [];
+
+    /** @param {string} dir */
+    function walk(dir) {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(fullPath);
+                continue;
+            }
+            if (/^image_\d+_.*\.glb$/i.test(entry.name)) continue;
+            if (/^mesh_lod_\d+_.*\.glb$/i.test(entry.name)) continue;
+
+            if (/\.glb$/i.test(entry.name)) {
+                out.push({ path: fullPath, type: "glb" });
+            } else if (/\.gltf$/i.test(entry.name)) {
+                out.push({ path: fullPath, type: "gltf" });
+            }
+        }
+    }
+
+    walk(assetsDir);
+    return out;
+}

package/plugins/dts-generator/glb.extractor.js

@@ -0,0 +1,175 @@
+// @ts-check
+/**
+ * glTF node tree walker and NEEDLE_components extractor.
+ *
+ * Walks the parsed glTF JSON, sanitizes node names to match Three.js runtime
+ * behaviour, and extracts component data from the NEEDLE_components extension.
+ */
+
+const NEEDLE_COMPONENTS_EXTENSION = "NEEDLE_components";
+
+/**
+ * Replicate Three.js GLTFLoader's sanitizeNodeName + createUniqueName logic.
+ * - Whitespace → `_`
+ * - Reserved chars `[ ] . : /` → removed
+ * - Duplicate names get `_1`, `_2`, … suffix
+ *
+ * @param {string} rawName
+ * @param {Record<string, number>} namesUsed  Mutated in-place — pass the same object for all nodes in a GLB
+ * @returns {string}
+ */
+export function sanitizeNodeName(rawName, namesUsed) {
+    const sanitized = rawName.replace(/\s/g, "_").replace(/[\[\].:\/]/g, "");
+    if (sanitized in namesUsed) {
+        return sanitized + "_" + (++namesUsed[sanitized]);
+    }
+    namesUsed[sanitized] = 0;
+    return sanitized;
+}
+
+/**
+ * Infer the Three.js runtime type of a glTF node from its JSON properties.
+ * - `mesh` present        → `import("three").Mesh`
+ * - `camera` present      → `import("three").Camera`
+ * - KHR_lights_punctual   → `import("three").Light`
+ * - otherwise             → `import("three").Object3D`
+ *
+ * @param {Record<string, unknown>} node
+ * @returns {string}
+ */
+export function inferNodeThreeType(node) {
+    if ("mesh" in node) return `import("three").Mesh`;
+    if ("camera" in node) return `import("three").Camera`;
+    if (node.extensions && /** @type {any} */ (node.extensions)["KHR_lights_punctual"] != null) return `import("three").Light`;
+    return `import("three").Object3D`;
+}
+
+/**
+ * Infer a TypeScript type string from a raw JSON value.
+ * Only primitives are typed precisely; everything else → `unknown`.
+ *
+ * @param {unknown} value
+ * @returns {string}
+ */
+export function inferTsType(value) {
+    if (value === null || value === undefined) return "unknown";
+    switch (typeof value) {
+        case "number": return "number";
+        case "string": return "string";
+        case "boolean": return "boolean";
+        default: return "unknown";
+    }
+}
+
+/**
+ * Build a map of nodeIndex → sanitized name and nodeIndex → parent index
+ * from the glTF node tree, then compute the full path for each node.
+ *
+ * @param {Array<Record<string, unknown>>} nodes  Raw glTF nodes array
+ * @param {Record<string, number>} namesUsed  Already-used name registry (shared with extraction pass)
+ * @returns {{ nameMap: Map<number, string>, pathMap: Map<number, string> }}
+ */
+function buildNodePaths(nodes, namesUsed) {
+    /** @type {Map<number, string>} nodeIndex → sanitized name */
+    const nameMap = new Map();
+    /** @type {Map<number, number>} nodeIndex → parent nodeIndex */
+    const parentMap = new Map();
+
+    // First pass: sanitize all names
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        if (!node || typeof node !== "object") continue;
+        const rawName = typeof node.name === "string" ? node.name : "";
+        if (!rawName) continue;
+        nameMap.set(i, sanitizeNodeName(rawName, namesUsed));
+    }
+
+    // Second pass: build parent map from children arrays
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        if (!node || typeof node !== "object") continue;
+        const children = Array.isArray(node.children) ? node.children : [];
+        for (const childIdx of children) {
+            parentMap.set(childIdx, i);
+        }
+    }
+
+    // Third pass: compute full path per node by walking up the parent chain
+    /** @type {Map<number, string>} nodeIndex → full path string */
+    const pathMap = new Map();
+    for (const [idx] of nameMap) {
+        const parts = [];
+        /** @type {number | undefined} */
+        let cur = idx;
+        while (cur !== undefined && nameMap.has(cur)) {
+            parts.unshift(/** @type {string} */ (nameMap.get(cur)));
+            cur = parentMap.get(cur);
+        }
+        pathMap.set(idx, parts.join("/"));
+    }
+
+    return { nameMap, pathMap };
+}
+
+/**
+ * Walk the glTF JSON and collect every node name + any NEEDLE_components extension blocks.
+ * Node names are sanitized and de-duplicated to match Three.js GLTFLoader behaviour.
+ *
+ * Nodes without NEEDLE_components are returned with an empty componentName so that
+ * callers can decide whether to emit them.
+ *
+ * @param {Record<string, unknown>} json  Parsed glTF JSON
+ * @returns {Array<{nodeName: string, nodePath: string, componentName: string, fields: Record<string, unknown>, nodeThreeType: string}>}
+ */
+export function extractComponentBindings(json) {
+    const nodes = /** @type {Array<Record<string, unknown>>} */ (Array.isArray(json.nodes) ? json.nodes : []);
+    /** @type {Array<{nodeName: string, nodePath: string, componentName: string, fields: Record<string, unknown>, nodeThreeType: string}>} */
+    const results = [];
+    /** @type {Record<string, number>} */
+    const namesUsed = {};
+
+    const { nameMap, pathMap } = buildNodePaths(nodes, namesUsed);
+
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        if (!node || typeof node !== "object") continue;
+
+        const nodeName = nameMap.get(i);
+        if (!nodeName) continue;
+
+        const nodePath = pathMap.get(i) ?? nodeName;
+        const nodeThreeType = inferNodeThreeType(/** @type {Record<string, unknown>} */ (node));
+        const ext = node.extensions?.[NEEDLE_COMPONENTS_EXTENSION];
+
+        if (!ext || typeof ext !== "object") {
+            results.push({ nodeName, nodePath, componentName: "", fields: {}, nodeThreeType });
+            continue;
+        }
+
+        const lists = [
+            ...(Array.isArray(ext.components) ? ext.components : []),
+            ...(Array.isArray(ext.builtin_components) ? ext.builtin_components : []),
+        ];
+
+        const internalKeys = new Set([
+            "name", "type", "guid", "gameObject", "enabled",
+            "didAwake", "didStart", "transformHandle", "destroyCancellationToken",
+        ]);
+
+        for (const comp of lists) {
+            if (!comp || typeof comp !== "object") continue;
+            const componentName = typeof comp.name === "string" ? comp.name.trim() : "";
+            if (!componentName) continue;
+
+            /** @type {Record<string, unknown>} */
+            const fields = {};
+            for (const [k, v] of Object.entries(comp)) {
+                if (!internalKeys.has(k)) fields[k] = v;
+            }
+
+            results.push({ nodeName, nodePath, componentName, fields, nodeThreeType });
+        }
+    }
+
+    return results;
+}

package/plugins/dts-generator/glb.reader.js

@@ -0,0 +1,114 @@
+// @ts-check
+/**
+ * GLB / glTF JSON chunk readers — local files and remote URLs.
+ *
+ * All functions return the parsed glTF JSON object or null on failure.
+ * Remote fetches use HTTP Range requests and cache by Last-Modified header.
+ */
+
+import { openSync, readSync, closeSync, readFileSync } from 'fs';
+
+/** @type {Map<string, { lastModified: string, json: Record<string, unknown> }>} */
+const _remoteGlbCache = new Map();
+
+/**
+ * Read the JSON chunk from a binary GLB file without loading the binary blob.
+ * @param {string} filePath
+ * @returns {Record<string, unknown> | null}
+ */
+export function readGlbJsonChunk(filePath) {
+    const fd = openSync(filePath, "r");
+    try {
+        const header = Buffer.allocUnsafe(20);
+        const bytesRead = readSync(fd, header, 0, header.length, 0);
+        if (bytesRead < 20) return null;
+
+        const magic = header.readUInt32LE(0);
+        const version = header.readUInt32LE(4);
+        const chunkLength = header.readUInt32LE(12);
+        const chunkType = header.readUInt32LE(16);
+
+        if (magic !== 0x46546c67 || version !== 2) return null;
+        if (chunkType !== 0x4E4F534A) return null; // not JSON chunk
+
+        const jsonBuffer = Buffer.allocUnsafe(chunkLength);
+        const jsonBytesRead = readSync(fd, jsonBuffer, 0, chunkLength, 20);
+        if (jsonBytesRead < chunkLength) return null;
+
+        return JSON.parse(jsonBuffer.toString("utf8").replace(/\u0000+$/g, ""));
+    } catch (_e) {
+        return null;
+    } finally {
+        closeSync(fd);
+    }
+}
+
+/**
+ * @param {string} filePath
+ * @returns {Record<string, unknown> | null}
+ */
+export function readGltfJsonFile(filePath) {
+    try {
+        return JSON.parse(readFileSync(filePath, "utf8"));
+    } catch (_e) {
+        return null;
+    }
+}
+
+/**
+ * Fetch only the JSON chunk of a remote GLB using two HTTP Range requests.
+ * Uses `Last-Modified` header for caching — avoids re-parsing if unchanged.
+ * Returns `null` on any network/parse error or if Range is not supported.
+ *
+ * @param {string} url
+ * @returns {Promise<Record<string, unknown> | null>}
+ */
+export async function readRemoteGlbJsonChunk(url) {
+    try {
+        const cached = _remoteGlbCache.get(url);
+
+        const headerRes = await fetch(url, { headers: { Range: "bytes=0-19" } });
+        if (!headerRes.ok) {
+            console.warn(`[needle:dts-generator] Remote GLB fetch failed (${headerRes.status}): ${url}`);
+            return null;
+        }
+
+        const lastModified = headerRes.headers.get("Last-Modified") ?? "";
+        if (cached && lastModified && cached.lastModified === lastModified) {
+            return cached.json;
+        }
+
+        const rangeSupported = headerRes.status === 206;
+        const headerBytes = Buffer.from(await headerRes.arrayBuffer());
+        if (headerBytes.length < 20) return null;
+
+        const magic = headerBytes.readUInt32LE(0);
+        const version = headerBytes.readUInt32LE(4);
+        const chunkLength = headerBytes.readUInt32LE(12);
+        const chunkType = headerBytes.readUInt32LE(16);
+
+        if (magic !== 0x46546c67 || version !== 2) return null; // not a GLB
+        if (chunkType !== 0x4E4F534A) return null;              // chunk0 not JSON
+
+        if (!rangeSupported) {
+            console.warn(`[needle:dts-generator] Remote GLB server does not support Range requests, skipping: ${url}`);
+            return null;
+        }
+
+        const jsonEnd = 20 + chunkLength - 1;
+        const jsonRes = await fetch(url, { headers: { Range: `bytes=20-${jsonEnd}` } });
+        if (!jsonRes.ok) {
+            console.warn(`[needle:dts-generator] Remote GLB JSON chunk fetch failed (${jsonRes.status}): ${url}`);
+            return null;
+        }
+
+        const json = /** @type {Record<string, unknown>} */ (
+            JSON.parse(Buffer.from(await jsonRes.arrayBuffer()).toString("utf8").replace(/\u0000+$/g, ""))
+        );
+        _remoteGlbCache.set(url, { lastModified, json });
+        return json;
+    } catch (e) {
+        console.warn(`[needle:dts-generator] Failed to fetch remote GLB: ${url} —`, /** @type {any} */ (e)?.message ?? e);
+        return null;
+    }
+}

package/plugins/dts-generator/index.js

@@ -0,0 +1,36 @@
+// @ts-check
+/**
+ * Needle Engine — HTML binding DTS generator
+ *
+ * Scans all GLB/glTF files in the project's assets directory, extracts
+ * NEEDLE_components data, and emits a `needle-bindings.d.ts` virtual-module
+ * declaration so that TypeScript can type-check HTML ↔ 3D component bindings.
+ *
+ * Typical generated output:
+ *
+ *   declare module "needle:bindings" {
+ *     interface SceneData {
+ *       Sphere: {
+ *         MyBall: { speed: number; label: string; };
+ *       };
+ *     }
+ *   }
+ *
+ * How component field types are resolved:
+ *   - For built-in Needle Engine components, types are read from
+ *     `components.needle.json` which lists only @serializable fields with
+ *     their proper TypeScript types.
+ *   - For user-defined components (not in the manifest), types are inferred
+ *     from the JSON value in the GLB (number/string/boolean → typed, else → unknown).
+ *   - Known Three.js types (Color, Vector3, Object3D, …) are emitted as
+ *     `import("three").TypeName` and known Needle types (RGBAColor, AssetReference, …)
+ *     as `import("@needle-tools/engine").TypeName`.
+ *   - Truly unknown types fall back to `unknown`.
+ */
+
+export { resolveEntrypointGlbs, collectSceneFiles } from './glb.discovery.js';
+export { readGlbJsonChunk, readGltfJsonFile, readRemoteGlbJsonChunk } from './glb.reader.js';
+export { extractComponentBindings, sanitizeNodeName, inferNodeThreeType, inferTsType } from './glb.extractor.js';
+export { scanBindings } from './dts.scan.js';
+export { generateDts, generateHtmlCustomData } from './dts.codegen.js';
+export { generateBindingsDts } from './dts.writer.js';