noteconnection 1.6.8 → 1.8.0

package/dist/src/reader_renderer.js

@@ -1,6 +1,7 @@
 "use strict";
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeMermaidDefinition = normalizeMermaidDefinition;
 exports.renderMathSvg = renderMathSvg;
 exports.renderMermaidSvg = renderMermaidSvg;
 exports.collectMermaidRenderStageSnapshots = collectMermaidRenderStageSnapshots;
@@ -90,6 +91,403 @@ const MERMAID_GLOBAL_BINDING_KEYS = [
     'Node',
     'getComputedStyle',
 ];
+function normalizeMermaidLineBreaks(source) {
+    return String(source || '')
+        .replace(/\r\n?/g, '\n')
+        .replace(/<br\s*>/gi, '<br/>');
+}
+function stripWrappingDoubleQuotes(text) {
+    const trimmed = String(text || '').trim();
+    if (trimmed.length >= 2 && trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function normalizeMermaidQuotedNodeLabels(source) {
+    return String(source || "")
+        .split("\n")
+        .map((line) => {
+        const text = String(line || "");
+        const startPattern = /([A-Za-z_][A-Za-z0-9_]*)\["/g;
+        let result = "";
+        let cursor = 0;
+        let match;
+        while ((match = startPattern.exec(text)) !== null) {
+            const labelStart = match.index + match[0].length;
+            let labelEnd = -1;
+            for (let index = labelStart; index < text.length - 1; index += 1) {
+                if (text.charAt(index) === "\"" && text.charAt(index - 1) !== "\\" && text.charAt(index + 1) === "]") {
+                    labelEnd = index;
+                    break;
+                }
+            }
+            if (labelEnd < 0) {
+                continue;
+            }
+            result += text.slice(cursor, labelStart);
+            result += escapeMermaidQuotedNodeLabel(text.slice(labelStart, labelEnd));
+            result += "\"]";
+            cursor = labelEnd + 2;
+            startPattern.lastIndex = cursor;
+        }
+        return result + text.slice(cursor);
+    })
+        .join("\n");
+}
+function splitMermaidTopLevelStatements(source) {
+    const text = normalizeMermaidQuotedNodeLabels(normalizeMermaidLineBreaks(source))
+        .split('\n')
+        .map((line) => rewriteQuotedLabelAfterSemicolonLine(line) || line)
+        .join('\n');
+    let result = '';
+    let quote = false;
+    let squareDepth = 0;
+    let roundDepth = 0;
+    let curlyDepth = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text.charAt(index);
+        if (char === '"' && text.charAt(index - 1) !== '\\') {
+            quote = !quote;
+            result += char;
+            continue;
+        }
+        if (!quote) {
+            if (char === '[')
+                squareDepth += 1;
+            else if (char === ']')
+                squareDepth = Math.max(0, squareDepth - 1);
+            else if (char === '(')
+                roundDepth += 1;
+            else if (char === ')')
+                roundDepth = Math.max(0, roundDepth - 1);
+            else if (char === '{')
+                curlyDepth += 1;
+            else if (char === '}')
+                curlyDepth = Math.max(0, curlyDepth - 1);
+            if (char === ';' && squareDepth === 0 && roundDepth === 0 && curlyDepth === 0) {
+                result += '\n';
+                continue;
+            }
+        }
+        result += char;
+    }
+    return result;
+}
+function rewriteQuotedLabelAfterSemicolonLine(line) {
+    if (!line.includes('-->')) {
+        return null;
+    }
+    const match = line.match(/^(.*?)\s*(-->)\s*(.*?);\s*"([^"\n]+)"\s*$/);
+    if (!match) {
+        return null;
+    }
+    const source = String(match[1] || '').trim();
+    const arrow = String(match[2] || '').trim();
+    const target = String(match[3] || '').trim();
+    const label = String(match[4] || '').trim();
+    if (!source || !target || !label) {
+        return null;
+    }
+    return `${source} -- "${label}" ${arrow} ${target};`;
+}
+function rewriteSingleDoubleDashLabelLine(line) {
+    const match = line.match(/^(.*?)\s*(?<!-)--(?!>|-)\s*"([^"\n]+)"\s*(?<!-)--(?!>|-)\s*(.+?)\s*;?\s*$/);
+    if (!match) {
+        return null;
+    }
+    const start = String(match[1] || '').trim();
+    const label = String(match[2] || '').trim();
+    const end = String(match[3] || '').trim();
+    if (!start || !label || !end || /^"/.test(end)) {
+        return null;
+    }
+    return `${start} -- "${label}" --> ${end};`;
+}
+function mergeDoubleArrowLabelLine(line) {
+    const match = line.match(/^(.*?)\s*--\s*"([^"\n]+)"\s*--\s*"([^"\n]+)"\s*(-->|---)\s*(.*)$/);
+    if (!match) {
+        return null;
+    }
+    const start = String(match[1] || '').trim();
+    const labelLeft = String(match[2] || '').trim();
+    const labelRight = String(match[3] || '').trim();
+    const arrow = String(match[4] || '').trim();
+    const end = String(match[5] || '').trim();
+    if (!start || !labelLeft || !labelRight || !end) {
+        return null;
+    }
+    return `${start} -- "${labelLeft}<br/>${labelRight}" ${arrow} ${end}`;
+}
+function quoteUnquotedEdgeLabelLine(line) {
+    const match = line.match(/^(.*?)\s*--\s*([^"\n][^>\n]*?)\s*-->\s*(.*)$/);
+    if (!match) {
+        return null;
+    }
+    const start = String(match[1] || '').trim();
+    const label = String(match[2] || '').trim();
+    const end = String(match[3] || '').trim();
+    if (!start || !label || !end) {
+        return null;
+    }
+    if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(label)
+        || /^[A-Za-z_][A-Za-z0-9_]*\s*[\[\(\{].*$/.test(label)
+        || /^["[{(]/.test(label)) {
+        return null;
+    }
+    return `${start} -- "${label}" --> ${end}`;
+}
+function normalizeSubgraphLine(line) {
+    const match = /^(\s*subgraph\s+)(.+)$/i.exec(line);
+    if (!match) {
+        return { next: line, changed: false };
+    }
+    const prefix = match[1];
+    const rawTitle = match[2].trim();
+    if (!rawTitle || rawTitle.startsWith('"') || rawTitle.startsWith("'")) {
+        return { next: line, changed: false };
+    }
+    if (/[\s()[\]{}:;,-]/.test(rawTitle)) {
+        return {
+            next: `${prefix}"${rawTitle.replace(/"/g, '\\"')}"`,
+            changed: true,
+        };
+    }
+    return { next: line, changed: false };
+}
+function splitIntermediateNodeLine(line) {
+    const match = line.match(/^(.*?)\s*(-->|---)\s*([A-Za-z_][A-Za-z0-9_]*)\s*(\[[^\]]+\]|\([^)]+\)|\{[^}]+\})\s*(-->|---)\s*(.*)$/);
+    if (!match) {
+        return null;
+    }
+    const start = String(match[1] || '').trim();
+    const leftArrow = String(match[2] || '').trim();
+    const nodeId = String(match[3] || '').trim();
+    const nodeShape = String(match[4] || '').trim();
+    const rightArrow = String(match[5] || '').trim();
+    const end = String(match[6] || '').trim();
+    if (!start || !nodeId || !nodeShape || !end) {
+        return null;
+    }
+    return [
+        `${start} ${leftArrow} ${nodeId}${nodeShape}`,
+        `${nodeId} ${rightArrow} ${end}`,
+    ];
+}
+function normalizeMermaidPipes(content) {
+    return String(content || '')
+        .replace(/\|""\|"/g, '')
+        .replace(/"\[\]"/g, '');
+}
+function fixExcessiveBrackets(content) {
+    return String(content || '')
+        .replace(/\]{3,}/g, ']')
+        .replace(/\[""\]/g, '')
+        .replace(/\["\]/g, ']')
+        .replace(/\[\/\["/g, '["')
+        .replace(/\["\/\]/g, '"]');
+}
+function normalizeMermaidComments(content) {
+    return String(content || '')
+        .split('\n')
+        .map((line) => {
+        const hashCommentMatch = line.match(/^(\s*[A-Za-z0-9_()[\]{}"'\s.-]+?)\s*-->\s*([A-Za-z0-9_()[\]{}"'\s.-]+?)\s*;\s*#(.*)$/);
+        if (hashCommentMatch) {
+            return `${hashCommentMatch[1].trim()} -- "${hashCommentMatch[3].trim()}" --> ${hashCommentMatch[2].trim()};`;
+        }
+        const percentCommentMatch = line.match(/^(\s*[A-Za-z0-9_()[\]{}"'\s.-]+?)\s*-->\s*([A-Za-z0-9_()[\]{}"'\s.-]+?)\s*;\s*%(.*)$/);
+        if (percentCommentMatch) {
+            return `${percentCommentMatch[1].trim()} -- "${percentCommentMatch[3].trim()}" --> ${percentCommentMatch[2].trim()};`;
+        }
+        const slashCommentMatch = line.match(/^(\s*[A-Za-z0-9_()[\]{}"'\s.-]+?)\s*-->\s*([A-Za-z0-9_()[\]{}"'\s.-]+?)\s*;\s*\/\/(.*)$/);
+        if (slashCommentMatch) {
+            return `${slashCommentMatch[1].trim()} -- "${slashCommentMatch[3].trim()}" --> ${slashCommentMatch[2].trim()};`;
+        }
+        return line;
+    })
+        .join('\n');
+}
+function fixDanglingBracketedNodeLabelLine(line) {
+    const match = line.match(/^(\s*[A-Za-z_][A-Za-z0-9_]*)\["([^"\n]*)\["\s*;?\s*$/);
+    if (!match) {
+        return null;
+    }
+    const nodeId = String(match[1] || '').trim();
+    const label = String(match[2] || '').trim();
+    if (!nodeId || !label) {
+        return null;
+    }
+    return `${nodeId}["${escapeMermaidLabel(label)}"]`;
+}
+function sanitizeMermaidIdentifier(rawValue, fallbackPrefix, counter) {
+    const raw = String(rawValue || '').trim();
+    const prefixedMatch = raw.match(/^([A-Za-z][A-Za-z0-9_]*)/);
+    if (prefixedMatch && prefixedMatch[1]) {
+        return prefixedMatch[1];
+    }
+    return `${fallbackPrefix}${counter}`;
+}
+function escapeMermaidLabel(rawValue) {
+    return String(rawValue || '')
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .trim();
+}
+function escapeMermaidQuotedNodeLabel(rawValue) {
+    return String(rawValue || "")
+        .replace(/\\/g, "\\\\")
+        .replace(/"/g, "#quot;")
+        .trim();
+}
+function isMermaidControlLine(line) {
+    return /^\s*(?:graph|flowchart|subgraph|end|classDef|class|style|linkStyle|click|%%)\b/i.test(line);
+}
+function convertNoteLine(line, state) {
+    const directionalMatch = line.match(/^\s*note\s+(?:right|left|top|bottom)\s+of\s+([A-Za-z0-9_]+)\s*:\s*(.+)$/i);
+    if (directionalMatch) {
+        state.syntheticCounter += 1;
+        const noteId = `AutoNote${state.syntheticCounter}`;
+        const noteText = escapeMermaidLabel(stripWrappingDoubleQuotes(directionalMatch[2]));
+        return [
+            `${noteId}["${noteText}"]`,
+            `${directionalMatch[1]} -.- ${noteId}`,
+        ];
+    }
+    const targetedMatch = line.match(/^\s*note\s+([A-Za-z0-9_]+)\s+"(.+)"\s*$/i);
+    if (targetedMatch) {
+        state.syntheticCounter += 1;
+        const noteId = `AutoNote${state.syntheticCounter}`;
+        const noteText = escapeMermaidLabel(stripWrappingDoubleQuotes(targetedMatch[2]));
+        return [
+            `${noteId}["${noteText}"]`,
+            `${targetedMatch[1]} -.- ${noteId}`,
+        ];
+    }
+    return null;
+}
+function normalizeMermaidEdgeLabels(line) {
+    return String(line || '')
+        .replace(/--\s*"([^"\n]+)"\s*-->/g, '-->|$1|')
+        .replace(/--\s*"([^"\n]+)"\s*--\s*/g, ' -->|$1| ');
+}
+function normalizeMermaidHtmlLineBreakLabels(line) {
+    const text = String(line || '');
+    const arrowMatch = text.match(/^(.*?(?:-->|---|-\.->|\-.-))\s*([A-Za-z_][A-Za-z0-9_]*)\s+(.+?)\s*;?\s*$/);
+    if (!arrowMatch) {
+        return text;
+    }
+    const prefix = String(arrowMatch[1] || '');
+    const nodeId = String(arrowMatch[2] || '').trim();
+    const label = String(arrowMatch[3] || '').trim();
+    if (!nodeId || !label || !label.includes('<br/>')) {
+        return text;
+    }
+    if (/^[\[\(\{"]/.test(label)) {
+        return text;
+    }
+    if (/(?:-->|---|-\.->|\-.-)/.test(label)) {
+        return text;
+    }
+    return `${prefix} ${nodeId}["${escapeMermaidLabel(stripWrappingDoubleQuotes(label))}"]`;
+}
+function fixMalformedMermaidArrows(line) {
+    return String(line || '')
+        .replace(/--\|>/g, '-->')
+        .replace(/<--/g, '-->')
+        .replace(/-- >/g, '-->')
+        .replace(/--\s*"([^"\n]+)"\s*--\s*([A-Za-z_][A-Za-z0-9_]*)\s*;/g, '-- "$1" --> $2;');
+}
+function isMermaidErrorSvgMarkup(markup) {
+    const text = String(markup || '').toLowerCase();
+    if (!text) {
+        return false;
+    }
+    return (text.includes('syntax error in text') ||
+        text.includes('lexical error on line') ||
+        text.includes('parse error on line') ||
+        text.includes('mermaid version') ||
+        text.includes('class="error-icon"') ||
+        text.includes('id="error-icon"'));
+}
+function normalizeMermaidEndpoint(rawValue, state) {
+    const raw = String(rawValue || '').trim();
+    if (!raw)
+        return raw;
+    if (/^(?:\[|\{|\(|")/.test(raw))
+        return raw;
+    if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(raw))
+        return raw;
+    if (/^[A-Za-z_][A-Za-z0-9_]*\s*[\[\(\{].*$/.test(raw))
+        return raw;
+    let nodeId = state.labelToId.get(raw);
+    if (!nodeId) {
+        state.syntheticCounter += 1;
+        nodeId = sanitizeMermaidIdentifier(raw, 'AutoNode', state.syntheticCounter);
+        state.labelToId.set(raw, nodeId);
+    }
+    return `${nodeId}["${escapeMermaidLabel(raw)}"]`;
+}
+function normalizeMermaidEdgeLine(line, state) {
+    const next = normalizeMermaidEdgeLabels(line);
+    const match = /(.*?)(--(?:>|o|x)(?:\|[^|]*\|)?\s*)(.+)$/.exec(next);
+    if (!match) {
+        return next;
+    }
+    const left = String(match[1] || '');
+    const connector = String(match[2] || '');
+    const right = String(match[3] || '').trim();
+    if (!right) {
+        return next;
+    }
+    return `${left}${connector}${normalizeMermaidEndpoint(right, state)}`;
+}
+function applyLegacyMermaidRepairs(line, state) {
+    const subgraphNormalized = normalizeSubgraphLine(line);
+    let next = String(subgraphNormalized.next || '');
+    next = normalizeMermaidComments(next);
+    next = fixExcessiveBrackets(normalizeMermaidPipes(next));
+    const noteLines = convertNoteLine(next, state);
+    if (noteLines) {
+        return noteLines;
+    }
+    next = fixMalformedMermaidArrows(next);
+    next = rewriteQuotedLabelAfterSemicolonLine(next) || next;
+    next = mergeDoubleArrowLabelLine(next) || next;
+    next = rewriteSingleDoubleDashLabelLine(next) || next;
+    next = quoteUnquotedEdgeLabelLine(next) || next;
+    next = normalizeMermaidHtmlLineBreakLabels(next);
+    next = fixDanglingBracketedNodeLabelLine(next) || next;
+    const splitIntermediate = splitIntermediateNodeLine(next);
+    if (splitIntermediate) {
+        return splitIntermediate;
+    }
+    return [next];
+}
+function normalizeMermaidDefinition(source) {
+    const split = splitMermaidTopLevelStatements(source);
+    const state = {
+        labelToId: new Map(),
+        syntheticCounter: 0,
+    };
+    return split
+        .split('\n')
+        .reduce((lines, rawLine) => {
+        const repairedLines = applyLegacyMermaidRepairs(rawLine, state);
+        repairedLines.forEach((line) => {
+            if (!String(line || '').trim()) {
+                return;
+            }
+            if (isMermaidControlLine(line)) {
+                lines.push(line.trimEnd());
+                return;
+            }
+            lines.push(normalizeMermaidEdgeLine(line, state).trimEnd());
+        });
+        return lines;
+    }, [])
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
 async function renderMathSvg(source, options = {}) {
     const trimmedSource = source.trim();
     if (!trimmedSource) {
@@ -143,6 +541,9 @@ async function buildMermaidRenderArtifacts(trimmedSource, options) {
     const host = environment.host;
     host.innerHTML = '';
     const result = await withMermaidDomGlobals(environment.window, async () => environment.mermaid.render(renderId, trimmedSource, host));
+    if (result && typeof result.svg === 'string' && isMermaidErrorSvgMarkup(result.svg)) {
+        throw new Error('Mermaid renderer produced an error SVG instead of a diagram.');
+    }
     const svgMarkup = sanitizeSvgMarkup(result.svg);
     const svgDom = new jsdom_1.JSDOM(svgMarkup, { contentType: 'image/svg+xml' });
     installSvgMeasurementPolyfills(svgDom.window);
@@ -180,7 +581,7 @@ async function buildMermaidRenderArtifacts(trimmedSource, options) {
     };
 }
 async function renderMermaidSvg(source, options = {}) {
-    const trimmedSource = source.trim();
+    const trimmedSource = normalizeMermaidDefinition(source);
     if (!trimmedSource) {
         throw new Error('Cannot render an empty Mermaid definition.');
     }
@@ -190,7 +591,7 @@ async function renderMermaidSvg(source, options = {}) {
     });
 }
 async function collectMermaidRenderStageSnapshots(source, options = {}) {
-    const trimmedSource = source.trim();
+    const trimmedSource = normalizeMermaidDefinition(source);
     if (!trimmedSource) {
         throw new Error('Cannot render an empty Mermaid definition.');
     }
@@ -374,7 +775,7 @@ function getMermaidConfig(theme) {
         securityLevel: 'loose',
         theme,
         fontFamily: MERMAID_FONT_FAMILY,
-        // Keep Mermaid output in pure SVG text so Godot's SVG loader can render it reliably.
+        // Keep Mermaid output free of HTML label nodes so rasterization stays deterministic.
         htmlLabels: false,
         markdownAutoWrap: true,
         maxTextSize: 200000,

package/dist/src/reader_renderer.test.js

@@ -129,6 +129,93 @@ describe('reader_renderer', () => {
         expect(svg).toContain('Start');
         expect(svg).toContain('Segoe UI');
     });
+    it('normalizes semicolon-chained Mermaid statements and quoted edge labels before rendering', () => {
+        const svg = runRenderer('renderMermaidSvg', [
+            'graph TD;',
+            'P["入射波"] -- "入射角 θi" -- N; P -- "反射角 θr" -- R;',
+            'N --> T["透射波"]',
+        ].join('\n'), { theme: 'dark' });
+        expect(svg.startsWith('<svg')).toBe(true);
+        expect(svg).toContain('入射波');
+        expect(svg).toContain('透射波');
+    });
+    it('wraps bare Mermaid node labels that contain html line breaks or mixed CJK text', () => {
+        const svg = runRenderer('renderMermaidSvg', [
+            'graph TD',
+            'A[Incident Wave] --> I界面<br>Interface;',
+            'I --> R反射波<br>Reflected Wave;',
+        ].join('\n'), { theme: 'dark' });
+        expect(svg.startsWith('<svg')).toBe(true);
+        expect(svg).toContain('Incident Wave');
+        expect(svg).toContain('Interface');
+    });
+    it('rewrites quoted labels that were displaced after a semicolon into valid Mermaid edge labels', () => {
+        const svg = runRenderer('renderMermaidSvg', [
+            'flowchart TD',
+            'A[Incident Wave] --> I[Interface]; "界面法线 Normal"',
+            'I --> R[Reflected Wave]',
+        ].join('\n'), { theme: 'dark' });
+        expect(svg.startsWith('<svg')).toBe(true);
+        expect(svg).toContain('界面法线');
+        expect(svg).toContain('Reflected Wave');
+    });
+    it('converts directional note directives into note nodes instead of leaving parser-breaking legacy syntax', () => {
+        const svg = runRenderer('renderMermaidSvg', [
+            'flowchart TD',
+            'A[Incident Wave] --> B[Interface]',
+            'note right of A : Important constraint',
+        ].join('\n'), { theme: 'dark' });
+        expect(svg.startsWith('<svg')).toBe(true);
+        expect(svg).toContain('Important constraint');
+        expect(svg).toContain('Incident Wave');
+    });
+    it('repairs legacy double-dash labelled edges before rendering', () => {
+        const svg = runRenderer('renderMermaidSvg', [
+            'graph TD;',
+            'P["Incident Wave"] -- "theta_i" -- N;',
+            'P -- "theta_r" -- R;',
+            'N --> T["Transmitted Wave"]',
+        ].join('\n'), { theme: 'dark' });
+        expect(svg.startsWith('<svg')).toBe(true);
+        expect(svg).toContain('Incident Wave');
+        expect(svg).toContain('Transmitted Wave');
+        expect(svg).toContain('theta_i');
+        expect(svg).toContain('theta_r');
+    });
+    it('wraps spaced mixed-language html-break labels into Mermaid node syntax', () => {
+        const svg = runRenderer('renderMermaidSvg', [
+            'flowchart TD',
+            'A[Incident Wave] --> I Interface<br/>Boundary;',
+            'I --> R Reflected<br/>Wave;',
+        ].join('\n'), { theme: 'dark' });
+        expect(svg.startsWith('<svg')).toBe(true);
+        expect(svg).toContain('Incident Wave');
+        expect(svg).toContain('Interface');
+        expect(svg).toContain('Reflected');
+    });
+    it('repairs Mermaid nodes whose quoted labels end with a stray opening bracket', () => {
+        const svg = runRenderer('renderMermaidSvg', [
+            'graph LR',
+            'IncidentWave["入射波 Incident Wave"]',
+            'InteractionPoint["作用点 Interaction Point["',
+            'IncidentWave --> InteractionPoint',
+            'InteractionPoint --> Absorption["吸收 Absorption"]',
+        ].join('\n'), { theme: 'dark' });
+        expect(svg.startsWith('<svg')).toBe(true);
+        expect(svg).toContain('作用点');
+        expect(svg).toContain('吸收');
+    });
+    it("escapes stray quotes inside Mermaid bracketed node labels before rendering", () => {
+        const svg = runRenderer("renderMermaidSvg", [
+            "flowchart TD",
+            "HQWG[\"High Quality Water Glass\"] -->|\"&gt;Superior Overall\"| FS[\"Final Score \"&gt;Superior Overall\"| FS\"]",
+        ].join("\n"), { theme: "dark" });
+        expect(svg.startsWith("<svg")).toBe(true);
+        expect(svg).toContain("High Quality Water Glass");
+        expect(svg).toContain("Superior");
+        expect(svg).toContain("Overall");
+        expect(svg).toContain("Final Score");
+    });
     it('does not leak JSDOM globals onto Node global scope after Mermaid rendering', () => {
         const scopeProbe = runRendererScopeProbe(['flowchart TD', 'A[Start] --> B{Check}', 'B -->|Yes| C[Done]', 'B -->|No| D[Retry]'].join('\n'), { theme: 'dark' });
         expect(scopeProbe.afterWindow).toBe(scopeProbe.beforeWindow);

package/dist/src/release.godot.mirror.contract.test.js

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+describe('release workflow godot mirror contract', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const workflowPath = path.join(repoRoot, '.github', 'workflows', 'release-desktop-multi-os.yml');
+    test('release workflow seeds a project-controlled godot mirror and builds from that mirror first', () => {
+        const workflow = fs.readFileSync(workflowPath, 'utf8');
+        expect(workflow).toContain('allow_godot_upstream_fallback:');
+        expect(workflow).toContain('description: "Allow desktop release jobs to fall back to the upstream Godot release when the project mirror is unavailable."');
+        expect(workflow).toContain('default: true');
+        expect(workflow).toContain('type: boolean');
+        expect(workflow).toContain('GODOT_MIRROR_TAG: "godot-mirror-v4.3-stable"');
+        expect(workflow).toContain('GODOT_WINDOWS_ARCHIVE_SHA256: "8f2c75b734bd956027ae3ca92c41f78b5d5a255dacc0f20e4e3c523c545ad410"');
+        expect(workflow).toContain('GODOT_LINUX_ARCHIVE_SHA256: "7de56444b130b10af84d19c7e0cf63cf9e9937ee4ba94364c3b7dd114253ca21"');
+        expect(workflow).toContain('GODOT_MACOS_ARCHIVE_SHA256: "d17940b913b3f3bf54c941eeb09042099d93865c6e2638e09e20f7c649aa474a"');
+        expect(workflow).toContain("GODOT_ALLOW_UPSTREAM_FALLBACK: ${{ github.event_name != 'workflow_dispatch' || github.event.inputs.allow_godot_upstream_fallback != 'false' }}");
+        expect(workflow).toContain('ensure-godot-mirror-assets:');
+        expect(workflow).toContain('gh release view "$GODOT_MIRROR_TAG" --repo "$GITHUB_REPOSITORY"');
+        expect(workflow).toContain('gh release create "$GODOT_MIRROR_TAG" \\');
+        expect(workflow).toContain('--repo "$GITHUB_REPOSITORY" \\');
+        expect(workflow).toContain('--target "$GITHUB_SHA" \\');
+        expect(workflow).toContain('EXPECTED_SHA256="$(expected_sha256_for_asset "$ASSET_NAME")"');
+        expect(workflow).toContain('sha256sum "$ARCHIVE_PATH"');
+        expect(workflow).toContain('Archive digest mismatch for $ASSET_NAME');
+        expect(workflow).toContain('gh release upload "$GODOT_MIRROR_TAG" "$ARCHIVE_PATH" --repo "$GITHUB_REPOSITORY" --clobber');
+        expect(workflow).toContain('https://github.com/Jacobinwwey/NoteConnection/releases/download/${GODOT_MIRROR_TAG}');
+        expect(workflow).toContain('$allowUpstreamFallback = "$env:GODOT_ALLOW_UPSTREAM_FALLBACK".ToLower() -eq "true"');
+        expect(workflow).toContain('if (-not $allowUpstreamFallback) {');
+        expect(workflow).toContain('throw "Project mirror download failed and upstream fallback is disabled');
+        expect(workflow).toContain('if [ "${GODOT_ALLOW_UPSTREAM_FALLBACK}" != "true" ]; then');
+        expect(workflow).toContain('echo "::error::Project mirror download failed and upstream fallback is disabled."');
+        expect(workflow).toContain('Get-FileHash -Path $archive -Algorithm SHA256');
+        expect(workflow).toContain('Downloaded Godot archive digest mismatch');
+        expect(workflow).toContain('ACTUAL_SHA256="$(sha256sum build/godot/godot-linux.zip | awk \'{print $1}\')"');
+        expect(workflow).toContain('ACTUAL_SHA256="$(sha256sum build/godot/godot-macos.zip | awk \'{print $1}\')"');
+        expect(workflow).toContain('needs: [ensure-release, ensure-godot-mirror-assets]');
+    });
+});