DOMPurify is not installed or sanitization failed.
`; + } + } + + /** + * Split Micron source into blocks for WASM conversion, keeping MeshChat partial-include lines on the JS path. + */ + static splitMicronMarkupWasmSegments(markup) { + if (markup == null) { + return []; + } + const lines = String(markup).split("\n"); + const segments = []; + let buf = []; + for (const line of lines) { + const trimmed = line.trim(); + if (MicronParser.PARTIAL_LINE_REGEX.test(trimmed)) { + if (buf.length) { + segments.push({ type: "mu", text: buf.join("\n") }); + buf = []; + } + segments.push({ type: "partial", line }); + } else { + buf.push(line); + } + } + if (buf.length) { + segments.push({ type: "mu", text: buf.join("\n") }); + } + return segments; + } + injectMonospaceStyles() { if (document.getElementById("micron-monospace-styles")) { return; @@ -156,10 +209,23 @@ export default class MicronParser extends BaseMicronParser { document.head.appendChild(styleEl); } - convertMicronToHtml(markup, partialContents = {}) { - if (markup == null) return ""; - if (typeof markup !== "string") markup = String(markup); + convertMicronToHtmlWasmHybrid(markup, partialContents = {}) { + const mc = globalThis.micronConvert; + const segments = MicronParser.splitMicronMarkupWasmSegments(markup); + let html = ""; + for (const seg of segments) { + if (seg.type === "mu") { + html += MicronParser.sanitizeRenderedMicronHtml( + mc(seg.text, this.darkTheme, this.enableForceMonospace) + ); + } else { + html += this._convertMicronToHtmlJs(seg.line + "\n", partialContents); + } + } + return html; + } + _convertMicronToHtmlJs(markup, partialContents = {}) { const build = () => { let html = ""; @@ -230,24 +296,7 @@ export default class MicronParser extends BaseMicronParser { } } - try { - const sanitized = DOMPurify.sanitize(html, { - USE_PROFILES: { html: true }, - ALLOWED_URI_REGEXP, - }); - try { - return MicronParser.stripOverlayStyles(sanitized); - } catch (e) { - console.warn("MicronParser: stripOverlayStyles failed", e); - return sanitized; - } - } catch (error) { - console.warn( - "DOMPurify is not installed or sanitization failed. Include dompurify or check the build.", - error - ); - return `DOMPurify is not installed or sanitization failed.
`; - } + return MicronParser.sanitizeRenderedMicronHtml(html); }; try { @@ -269,6 +318,22 @@ export default class MicronParser extends BaseMicronParser { } } + convertMicronToHtml(markup, partialContents = {}, options = {}) { + if (markup == null) return ""; + if (typeof markup !== "string") markup = String(markup); + + const wantWasm = options.useWasm === true && typeof globalThis.micronConvert === "function"; + if (wantWasm) { + try { + return this.convertMicronToHtmlWasmHybrid(markup, partialContents); + } catch (e) { + console.warn("MicronParser: WASM Micron conversion failed, using JS parser", e); + } + } + + return this._convertMicronToHtmlJs(markup, partialContents); + } + convertMicronToFragment(markup) { if (markup == null) { return document.createDocumentFragment(); diff --git a/meshchatx/src/frontend/js/MicronWasmLoader.js b/meshchatx/src/frontend/js/MicronWasmLoader.js new file mode 100644 index 0000000..627722f --- /dev/null +++ b/meshchatx/src/frontend/js/MicronWasmLoader.js @@ -0,0 +1,94 @@ +/** + * Lazy-load micron-parser-go WASM (see https://github.com/Quad4-Software/Micron-Parser-Go ). + * Requires wasm_exec.js from Go and micron-parser-go.wasm under /vendor/micron-parser-go/. + * Files are fetched at production build time (scripts/fetch-micron-wasm.mjs); omitted builds set VITE_MICRON_WASM_BUNDLED=false. + */ + +let resolvedPromise = null; + +/** True when WASM artifacts were present at Vite build time (not runtime probing). */ +export function isMicronWasmBundled() { + if (typeof globalThis !== "undefined" && typeof globalThis.__MESHCHATX_TEST_MICRON_WASM_BUNDLED__ === "boolean") { + return globalThis.__MESHCHATX_TEST_MICRON_WASM_BUNDLED__; + } + return import.meta.env.VITE_MICRON_WASM_BUNDLED === "true"; +} + +function baseUrl() { + const root = import.meta.env.BASE_URL || "/"; + return `${root.replace(/\/?$/, "/")}vendor/micron-parser-go`; +} + +function injectScript(src) { + const id = "meshchatx-micron-wasm-exec"; + if (document.getElementById(id)) { + return Promise.resolve(); + } + return new Promise((resolve, reject) => { + const s = document.createElement("script"); + s.id = id; + s.async = true; + s.src = src; + s.onload = () => resolve(); + s.onerror = () => reject(new Error(`Micron WASM: failed to load script ${src}`)); + document.head.appendChild(s); + }); +} + +async function instantiateOnce() { + if (typeof WebAssembly === "undefined") { + throw new Error("Micron WASM: WebAssembly is not available"); + } + const root = baseUrl(); + await injectScript(`${root}/wasm_exec.js`); + if (typeof globalThis.Go === "undefined") { + throw new Error("Micron WASM: Go runtime missing after wasm_exec.js load"); + } + const wasmUrl = `${root}/micron-parser-go.wasm`; + const go = new globalThis.Go(); + let result; + try { + result = await WebAssembly.instantiateStreaming(fetch(wasmUrl), go.importObject); + } catch { + const buf = await fetch(wasmUrl).then((r) => { + if (!r.ok) { + throw new Error(`Micron WASM: fetch failed (${r.status})`); + } + return r.arrayBuffer(); + }); + result = await WebAssembly.instantiate(buf, go.importObject); + } + go.run(result.instance); + if (typeof globalThis.micronConvert !== "function") { + throw new Error("Micron WASM: micronConvert was not registered"); + } +} + +export function invalidateNomadMicronWasmPreload() { + resolvedPromise = null; +} + +/** + * Ensures micron-parser-go WASM is initialized; resolves true when micronConvert is callable. + */ +export function preloadNomadMicronWasm() { + if (!isMicronWasmBundled()) { + return Promise.resolve(false); + } + if (typeof globalThis.micronConvert === "function") { + return Promise.resolve(true); + } + if (resolvedPromise === null) { + resolvedPromise = (async () => { + try { + await instantiateOnce(); + return typeof globalThis.micronConvert === "function"; + } catch (e) { + console.warn(e); + resolvedPromise = null; + return false; + } + })(); + } + return resolvedPromise; +} diff --git a/meshchatx/src/frontend/js/NomadPageRenderer.js b/meshchatx/src/frontend/js/NomadPageRenderer.js index 8c282e0..11d8f36 100644 --- a/meshchatx/src/frontend/js/NomadPageRenderer.js +++ b/meshchatx/src/frontend/js/NomadPageRenderer.js @@ -286,10 +286,13 @@ export function renderNomadPageByPath( const renderPlaintext = renderOptions.renderPlaintext !== false; const nomadDestinationHash = renderOptions.nomadDestinationHash || null; const linkOpts = { destinationHash: nomadDestinationHash }; + const micronOpts = { + useWasm: renderOptions.nomad_micron_wasm_use === true && typeof globalThis.micronConvert === "function", + }; const p = (pagePathWithoutData || "").toLowerCase(); if (p.endsWith(".mu")) { const muParser = new MicronParserClass(); - let out = muParser.convertMicronToHtml(content, pagePartials); + let out = muParser.convertMicronToHtml(content, pagePartials, micronOpts); if (nomadDestinationHash) { out = isolateNomadLinksInHtml(out, nomadDestinationHash); } diff --git a/package.json b/package.json index f68a09b..b5e42fa 100644 --- a/package.json +++ b/package.json @@ -11,6 +11,7 @@ "scripts": { "dev": "vite dev", "watch": "pnpm run build-frontend -- --watch", + "prebuild-frontend": "node scripts/fetch-micron-wasm.mjs", "build-frontend": "vite build", "build-backend": "node scripts/build-backend.js", "build-docs": "python3 scripts/build/fetch_reticulum_manual.py", diff --git a/scripts/fetch-micron-wasm.mjs b/scripts/fetch-micron-wasm.mjs new file mode 100644 index 0000000..48978da --- /dev/null +++ b/scripts/fetch-micron-wasm.mjs @@ -0,0 +1,72 @@ +#!/usr/bin/env node +/** + * Downloads micron-parser-go WASM release assets and matching wasm_exec.js for Vite public/. + * Safe to run offline: exits 0 without files when MICRON_WASM_SKIP=1 or network fails. + * + * Override URLs: + * MICRON_PARSER_GO_WASM_URL + * MICRON_GO_WASM_EXEC_URL + */ +import fs from "fs"; +import path from "path"; +import { MICRON_PARSER_GO_RELEASE_TAG } from "./micron-parser-go-version.mjs"; +import { micronWasmVendorPaths, micronWasmRepoRoot } from "./micron-wasm-resolve-bundled.mjs"; + +const DEFAULT_WASM_URL = `https://github.com/Quad4-Software/Micron-Parser-Go/releases/download/${MICRON_PARSER_GO_RELEASE_TAG}/micron-parser-go.wasm`; +const DEFAULT_WASM_EXEC_URL = "https://raw.githubusercontent.com/golang/go/go1.26.2/lib/wasm/wasm_exec.js"; + +const TIMEOUT_MS = Number(process.env.MICRON_WASM_FETCH_TIMEOUT_MS || 120000); + +function rmQuiet(p) { + try { + fs.rmSync(p, { force: true }); + } catch { + /* ignore */ + } +} + +async function fetchBinary(url, destFile) { + const ctrl = new AbortController(); + const t = setTimeout(() => ctrl.abort(), TIMEOUT_MS); + try { + const res = await fetch(url, { signal: ctrl.signal }); + if (!res.ok) { + throw new Error(`HTTP ${res.status}`); + } + const buf = Buffer.from(await res.arrayBuffer()); + fs.mkdirSync(path.dirname(destFile), { recursive: true }); + fs.writeFileSync(destFile, buf); + return buf.length; + } finally { + clearTimeout(t); + } +} + +async function main() { + if (process.env.MICRON_WASM_SKIP === "1") { + console.log("fetch-micron-wasm: MICRON_WASM_SKIP=1, skipping."); + process.exit(0); + } + + const root = micronWasmRepoRoot(); + const { dir, wasm, wasmExec } = micronWasmVendorPaths(root); + const wasmUrl = process.env.MICRON_PARSER_GO_WASM_URL || DEFAULT_WASM_URL; + const execUrl = process.env.MICRON_GO_WASM_EXEC_URL || DEFAULT_WASM_EXEC_URL; + + fs.mkdirSync(dir, { recursive: true }); + + try { + console.log("fetch-micron-wasm: downloading wasm_exec.js..."); + await fetchBinary(execUrl, wasmExec); + console.log("fetch-micron-wasm: downloading micron-parser-go.wasm..."); + const n = await fetchBinary(wasmUrl, wasm); + console.log(`fetch-micron-wasm: OK (${n} bytes WASM)`); + } catch (e) { + console.warn("fetch-micron-wasm: failed:", e?.message || e); + rmQuiet(wasm); + rmQuiet(wasmExec); + process.exit(0); + } +} + +main(); diff --git a/scripts/micron-parser-go-version.mjs b/scripts/micron-parser-go-version.mjs new file mode 100644 index 0000000..2043fe9 --- /dev/null +++ b/scripts/micron-parser-go-version.mjs @@ -0,0 +1,5 @@ +/** + * Micron-Parser-Go release tag for default WASM URL (scripts/fetch-micron-wasm.mjs) + * and build-time tooltip copy (VITE_MICRON_PARSER_GO_RELEASE). + */ +export const MICRON_PARSER_GO_RELEASE_TAG = "v1.0.2"; diff --git a/scripts/micron-wasm-resolve-bundled.mjs b/scripts/micron-wasm-resolve-bundled.mjs new file mode 100644 index 0000000..31dc06f --- /dev/null +++ b/scripts/micron-wasm-resolve-bundled.mjs @@ -0,0 +1,39 @@ +/** + * Resolve paths and detect whether micron-parser-go WASM artifacts are present for Vite/Vitest. + */ +import fs from "fs"; +import path from "path"; +import { fileURLToPath } from "url"; + +const __dirname = path.dirname(fileURLToPath(import.meta.url)); + +/** Repository root (parent of scripts/). */ +export function micronWasmRepoRoot() { + return path.join(__dirname, ".."); +} + +export function micronWasmVendorPaths(repoRoot = micronWasmRepoRoot()) { + const dir = path.join(repoRoot, "meshchatx", "src", "frontend", "public", "vendor", "micron-parser-go"); + return { + dir, + wasm: path.join(dir, "micron-parser-go.wasm"), + wasmExec: path.join(dir, "wasm_exec.js"), + }; +} + +/** + * True when both wasm_exec.js and a minimally-sized WASM binary exist (build-time fetch succeeded). + */ +export function isMicronWasmBundled(repoRoot = micronWasmRepoRoot()) { + const { wasm, wasmExec } = micronWasmVendorPaths(repoRoot); + try { + if (!fs.existsSync(wasm) || !fs.existsSync(wasmExec)) { + return false; + } + const wasmStat = fs.statSync(wasm); + const execStat = fs.statSync(wasmExec); + return wasmStat.size >= 8192 && execStat.size >= 1024; + } catch { + return false; + } +} diff --git a/tests/frontend/MicronParser.test.js b/tests/frontend/MicronParser.test.js index 2dd6460..4bcb0d0 100644 --- a/tests/frontend/MicronParser.test.js +++ b/tests/frontend/MicronParser.test.js @@ -707,4 +707,43 @@ describe("MicronParser.js", () => { expect(frag.childNodes.length).toBeGreaterThan(0); }); }); + + describe("micron-parser-go WASM integration helpers", () => { + afterEach(() => { + delete globalThis.micronConvert; + }); + + it("splitMicronMarkupWasmSegments isolates MeshChat partial lines", () => { + const dest = "a".repeat(32); + const partialLine = `\`{${dest}:/page/partial.mu}`; + const segments = MicronParser.splitMicronMarkupWasmSegments(`> hello\nworld\n${partialLine}\ntrailer`); + expect(segments).toEqual([ + { type: "mu", text: "> hello\nworld" }, + { type: "partial", line: partialLine }, + { type: "mu", text: "trailer" }, + ]); + }); + + it("convertMicronToHtml falls back to JS when WASM throws", () => { + globalThis.micronConvert = vi.fn(() => { + throw new Error("forced wasm failure"); + }); + const p = new MicronParser(true, false); + const html = p.convertMicronToHtml("`!ok`!", {}, { useWasm: true }); + expect(html.length).toBeGreaterThan(0); + expect(html.toLowerCase()).toContain("ok"); + }); + + it("convertMicronToHtml stitches WASM segments with JS partial lines", () => { + globalThis.micronConvert = vi.fn(() => 'wasm-body
'); + const dest = "b".repeat(32); + const partialLine = `\`{${dest}:/page/inc.mu}`; + const p = new MicronParser(true, false); + const html = p.convertMicronToHtml(`intro line\n${partialLine}`, {}, { useWasm: true }); + expect(globalThis.micronConvert).toHaveBeenCalled(); + expect(html).toContain("wasm-body"); + expect(html).toContain("mu-partial"); + expect(html).toContain("data-dest"); + }); + }); }); diff --git a/tests/frontend/MicronWasmLoader.test.js b/tests/frontend/MicronWasmLoader.test.js new file mode 100644 index 0000000..001ccb4 --- /dev/null +++ b/tests/frontend/MicronWasmLoader.test.js @@ -0,0 +1,167 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; +import { + invalidateNomadMicronWasmPreload, + isMicronWasmBundled, + preloadNomadMicronWasm, +} from "../../meshchatx/src/frontend/js/MicronWasmLoader.js"; + +describe("MicronWasmLoader.js", () => { + let origBundledFlag; + + beforeEach(() => { + origBundledFlag = globalThis.__MESHCHATX_TEST_MICRON_WASM_BUNDLED__; + invalidateNomadMicronWasmPreload(); + delete globalThis.micronConvert; + delete globalThis.Go; + document.getElementById("meshchatx-micron-wasm-exec")?.remove(); + }); + + afterEach(() => { + invalidateNomadMicronWasmPreload(); + delete globalThis.micronConvert; + delete globalThis.Go; + document.getElementById("meshchatx-micron-wasm-exec")?.remove(); + vi.restoreAllMocks(); + vi.unstubAllGlobals(); + if (origBundledFlag === undefined) { + delete globalThis.__MESHCHATX_TEST_MICRON_WASM_BUNDLED__; + } else { + globalThis.__MESHCHATX_TEST_MICRON_WASM_BUNDLED__ = origBundledFlag; + } + }); + + it("isMicronWasmBundled honors __MESHCHATX_TEST_MICRON_WASM_BUNDLED__", () => { + globalThis.__MESHCHATX_TEST_MICRON_WASM_BUNDLED__ = true; + expect(isMicronWasmBundled()).toBe(true); + globalThis.__MESHCHATX_TEST_MICRON_WASM_BUNDLED__ = false; + expect(isMicronWasmBundled()).toBe(false); + }); + + it("preloadNomadMicronWasm resolves false without bundling and does not fetch", async () => { + globalThis.__MESHCHATX_TEST_MICRON_WASM_BUNDLED__ = false; + const fetchSpy = vi.spyOn(globalThis, "fetch").mockResolvedValue(new Response()); + const ok = await preloadNomadMicronWasm(); + expect(ok).toBe(false); + expect(fetchSpy).not.toHaveBeenCalled(); + }); + + it("preloadNomadMicronWasm resolves false when WebAssembly is unavailable", async () => { + globalThis.__MESHCHATX_TEST_MICRON_WASM_BUNDLED__ = true; + vi.stubGlobal("WebAssembly", undefined); + const ok = await preloadNomadMicronWasm(); + expect(ok).toBe(false); + }); + + it("preloadNomadMicronWasm resolves false when wasm_exec script fails to load", async () => { + globalThis.__MESHCHATX_TEST_MICRON_WASM_BUNDLED__ = true; + const appendSpy = vi.spyOn(document.head, "appendChild").mockImplementation((node) => { + if (node?.tagName === "SCRIPT" && typeof node.onerror === "function") { + queueMicrotask(() => node.onerror()); + } + return node; + }); + try { + const ok = await preloadNomadMicronWasm(); + expect(ok).toBe(false); + } finally { + appendSpy.mockRestore(); + } + }); + + it("preloadNomadMicronWasm resolves false when wasm_exec loads but Go is missing", async () => { + globalThis.__MESHCHATX_TEST_MICRON_WASM_BUNDLED__ = true; + const appendSpy = vi.spyOn(document.head, "appendChild").mockImplementation((node) => { + if (node?.tagName === "SCRIPT" && typeof node.onload === "function") { + queueMicrotask(() => node.onload()); + } + return node; + }); + try { + const ok = await preloadNomadMicronWasm(); + expect(ok).toBe(false); + } finally { + appendSpy.mockRestore(); + } + }); + + it("preloadNomadMicronWasm resolves false when WASM instantiation fails", async () => { + globalThis.__MESHCHATX_TEST_MICRON_WASM_BUNDLED__ = true; + globalThis.Go = class { + constructor() { + this.importObject = {}; + this.run = vi.fn(); + } + }; + + const appendSpy = vi.spyOn(document.head, "appendChild").mockImplementation((node) => { + if (node?.tagName === "SCRIPT" && typeof node.onload === "function") { + queueMicrotask(() => node.onload()); + } + return node; + }); + + vi.spyOn(globalThis, "fetch").mockResolvedValue({ + ok: true, + arrayBuffer: async () => new ArrayBuffer(16), + headers: new Headers({ "content-type": "application/wasm" }), + }); + + const streaming = vi + .spyOn(WebAssembly, "instantiateStreaming") + .mockRejectedValue(new Error("streaming failed")); + const instantiate = vi.spyOn(WebAssembly, "instantiate").mockRejectedValue(new Error("bad wasm")); + + try { + const ok = await preloadNomadMicronWasm(); + expect(ok).toBe(false); + expect(streaming).toHaveBeenCalled(); + expect(instantiate).toHaveBeenCalled(); + } finally { + appendSpy.mockRestore(); + } + }); + + it("preloadNomadMicronWasm can retry after invalidateNomadMicronWasmPreload", async () => { + globalThis.__MESHCHATX_TEST_MICRON_WASM_BUNDLED__ = true; + globalThis.Go = class { + constructor() { + this.importObject = {}; + this.run = vi.fn(); + } + }; + + const appendSpy = vi.spyOn(document.head, "appendChild").mockImplementation((node) => { + if (node?.tagName === "SCRIPT" && typeof node.onload === "function") { + queueMicrotask(() => node.onload()); + } + return node; + }); + + vi.spyOn(globalThis, "fetch").mockResolvedValue({ + ok: true, + arrayBuffer: async () => new ArrayBuffer(16), + headers: new Headers({ "content-type": "application/wasm" }), + }); + + vi.spyOn(WebAssembly, "instantiateStreaming").mockRejectedValue(new Error("streaming failed")); + const instantiate = vi + .spyOn(WebAssembly, "instantiate") + .mockRejectedValueOnce(new Error("first")) + .mockRejectedValueOnce(new Error("second")); + + try { + expect(await preloadNomadMicronWasm()).toBe(false); + invalidateNomadMicronWasmPreload(); + expect(await preloadNomadMicronWasm()).toBe(false); + expect(instantiate).toHaveBeenCalledTimes(2); + } finally { + appendSpy.mockRestore(); + } + }); + + it("preloadNomadMicronWasm resolves true when micronConvert is already defined", async () => { + globalThis.__MESHCHATX_TEST_MICRON_WASM_BUNDLED__ = true; + globalThis.micronConvert = vi.fn(() => ""); + expect(await preloadNomadMicronWasm()).toBe(true); + }); +}); diff --git a/tests/frontend/fixtures/settingsPageTestApi.js b/tests/frontend/fixtures/settingsPageTestApi.js index 0e7f66a..a3167b0 100644 --- a/tests/frontend/fixtures/settingsPageTestApi.js +++ b/tests/frontend/fixtures/settingsPageTestApi.js @@ -123,6 +123,7 @@ export function buildFullServerConfig(overrides = {}) { nomad_render_markdown_enabled: true, nomad_render_html_enabled: true, nomad_render_plaintext_enabled: true, + nomad_micron_wasm_enabled: true, nomad_default_page_path: "/page/index.mu", gitea_base_url: "https://git.quad4.io", ...overrides, diff --git a/vite.config.js b/vite.config.js index 20309ab..ceab4aa 100644 --- a/vite.config.js +++ b/vite.config.js @@ -1,6 +1,7 @@ import path from "path"; import fs from "fs"; import { defineConfig } from "vite"; +import { MICRON_PARSER_GO_RELEASE_TAG } from "./scripts/micron-parser-go-version.mjs"; import tailwindcss from "@tailwindcss/vite"; import vue from "@vitejs/plugin-vue"; import vuetify from "vite-plugin-vuetify"; @@ -34,9 +35,27 @@ const e2eBackendWs = `ws://127.0.0.1:${e2eBackendPort}`; const appBuildTimeIso = new Date().toISOString(); +function isMicronWasmBundledResolved() { + const wasmDir = path.join(__dirname, "meshchatx", "src", "frontend", "public", "vendor", "micron-parser-go"); + const wasmFile = path.join(wasmDir, "micron-parser-go.wasm"); + const execFile = path.join(wasmDir, "wasm_exec.js"); + try { + if (!fs.existsSync(wasmFile) || !fs.existsSync(execFile)) { + return false; + } + return fs.statSync(wasmFile).size >= 8192 && fs.statSync(execFile).size >= 1024; + } catch { + return false; + } +} + +const micronWasmBundled = isMicronWasmBundledResolved(); + export default defineConfig({ define: { __APP_BUILD_TIME__: JSON.stringify(appBuildTimeIso), + "import.meta.env.VITE_MICRON_WASM_BUNDLED": JSON.stringify(micronWasmBundled ? "true" : "false"), + "import.meta.env.VITE_MICRON_PARSER_GO_RELEASE": JSON.stringify(MICRON_PARSER_GO_RELEASE_TAG), }, plugins: [ tailwindcss(), diff --git a/vitest.config.js b/vitest.config.js index b7591d0..973f6d5 100644 --- a/vitest.config.js +++ b/vitest.config.js @@ -1,12 +1,32 @@ import { defineConfig } from "vitest/config"; import vue from "@vitejs/plugin-vue"; import path from "path"; +import fs from "fs"; +import { MICRON_PARSER_GO_RELEASE_TAG } from "./scripts/micron-parser-go-version.mjs"; + +function isMicronWasmBundledResolved(repoRoot) { + const wasmDir = path.join(repoRoot, "meshchatx", "src", "frontend", "public", "vendor", "micron-parser-go"); + const wasmFile = path.join(wasmDir, "micron-parser-go.wasm"); + const execFile = path.join(wasmDir, "wasm_exec.js"); + try { + if (!fs.existsSync(wasmFile) || !fs.existsSync(execFile)) { + return false; + } + return fs.statSync(wasmFile).size >= 8192 && fs.statSync(execFile).size >= 1024; + } catch { + return false; + } +} + +const micronWasmBundled = isMicronWasmBundledResolved(__dirname); const appBuildTimeIso = new Date().toISOString(); export default defineConfig({ define: { __APP_BUILD_TIME__: JSON.stringify(appBuildTimeIso), + "import.meta.env.VITE_MICRON_WASM_BUNDLED": JSON.stringify(micronWasmBundled ? "true" : "false"), + "import.meta.env.VITE_MICRON_PARSER_GO_RELEASE": JSON.stringify(MICRON_PARSER_GO_RELEASE_TAG), }, plugins: [ vue({