@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/wire-dom-fragment.js

@@ -1,139 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Top-level chrome document: DOM fragment insertion.
- *
- * Default target is `browser/base/content/browser.xhtml`. Forks that replace
- * browser.xhtml with a custom top-level chrome document pass the replacement
- * path in via `targetPath`. The insertion logic is shape-agnostic (looks for
- * `#include browser-sets.inc`, then falls back to `<html:body>`), so any
- * browser.xhtml-shaped xhtml works.
- */
-import { dirname, join, relative } from 'node:path';
-import { GeneralError } from '../errors/base.js';
-import { pathExists, readText, writeText } from '../utils/fs.js';
-import { toRootRelativePath } from '../utils/paths.js';
-import { normalizePathSlashes } from '../utils/paths.js';
-import { escapeRegex } from '../utils/regex.js';
-import { tokenizeXhtml } from './wire-utils.js';
-export const DEFAULT_DOM_TARGET = 'browser/base/content/browser.xhtml';
-/**
- * Tokenizer-based implementation for DOM fragment insertion.
- */
-export function addDomFragmentTokenized(content, includeDirective) {
-    const lines = content.split('\n');
-    const tokens = tokenizeXhtml(lines);
-    // Find the #include browser-sets.inc token
-    let insertIndex = tokens.findIndex((token) => token.type === 'macro' && token.raw.includes('browser-sets.inc'));
-    if (insertIndex === -1) {
-        // Fallback: after <html:body>
-        const bodyIndex = tokens.findIndex((token) => token.type === 'xml' && /<html:body/.test(token.raw));
-        insertIndex = bodyIndex === -1 ? -1 : bodyIndex + 1;
-    }
-    if (insertIndex === -1) {
-        throw new GeneralError('Could not find insertion point in chrome document');
-    }
-    lines.splice(insertIndex, 0, includeDirective);
-    return lines.join('\n');
-}
-/**
- * Dry-run precheck for `addDomFragment`. Reads the resolved chrome document
- * and verifies it either already contains the `#include` directive (the
- * idempotent-skip case) or offers a locatable insertion point via
- * {@link addDomFragmentTokenized} / {@link legacyAddDomFragment}. Throws the
- * same `Could not find insertion point in chrome document` error the real
- * run would throw when neither condition holds.
- *
- * Without it, `wire --dry-run` previews a plausible mutation plan while the
- * real run throws on the same arguments, because only the real run called
- * the insertion helpers.
- */
-export async function probeDomFragmentInsertionPoint(engineDir, domFilePath, targetPath = DEFAULT_DOM_TARGET) {
-    const targetAbsPath = join(engineDir, targetPath);
-    if (!(await pathExists(targetAbsPath))) {
-        // The callers in `wire.ts` run their own existence probe before
-        // invoking this helper, but a well-behaved probe is careful: if
-        // something changed between the two checks, fail with the same
-        // error the real run would surface.
-        throw new GeneralError(`${targetPath} not found in engine`);
-    }
-    const safeDomFilePath = toRootRelativePath(engineDir, domFilePath);
-    const targetDir = dirname(targetPath);
-    const includePath = normalizePathSlashes(relative(targetDir, safeDomFilePath));
-    const includeDirective = `#include ${includePath}`;
-    const content = await readText(targetAbsPath);
-    if (new RegExp(`^${escapeRegex(includeDirective)}$`, 'm').test(content)) {
-        // Already wired. The real run would idempotent-skip here, so
-        // dry-run is allowed to proceed too.
-        return;
-    }
-    // Check the tokenised and line-based insertion paths symmetrically with
-    // the real run. Either helper returning without throwing is sufficient
-    // evidence that the real run can land the directive.
-    addDomFragmentTokenized(content, includeDirective);
-}
-/**
- * Inserts a `#include` directive for an `.inc.xhtml` file into the top-level
- * chrome document (default: `browser/base/content/browser.xhtml`), before
- * `#include browser-sets.inc`.
- *
- * If the file's content was previously inlined (detected by root element id=),
- * the inlined block is automatically replaced with the `#include` directive.
- *
- * @param engineDir - Engine source root
- * @param domFilePath - Path to the `.inc.xhtml` file relative to engine root
- * @param targetPath - Chrome document to insert into, relative to engine
- *   root. Defaults to {@link DEFAULT_DOM_TARGET}. Forks that replace
- *   browser.xhtml with a custom top-level chrome document pass the
- *   replacement path here.
- * @returns true if inserted, false if already present
- */
-export async function addDomFragment(engineDir, domFilePath, targetPath = DEFAULT_DOM_TARGET) {
-    const targetAbsPath = join(engineDir, targetPath);
-    const safeDomFilePath = toRootRelativePath(engineDir, domFilePath);
-    if (!(await pathExists(targetAbsPath))) {
-        throw new GeneralError(`${targetPath} not found in engine`);
-    }
-    // Compute include path relative to the target's directory. The `#include`
-    // directive is resolved by the preprocessor relative to the file that
-    // contains it, so this must track the chrome doc's location, not a
-    // hardcoded `browser/base/content/`.
-    const targetDir = dirname(targetPath);
-    const includePath = normalizePathSlashes(relative(targetDir, safeDomFilePath));
-    const includeDirective = `#include ${includePath}`;
-    let content = await readText(targetAbsPath);
-    // Idempotency: check if the #include directive already exists (line-anchored to avoid substring matches)
-    if (new RegExp(`^${escapeRegex(includeDirective)}$`, 'm').test(content)) {
-        return false;
-    }
-    // Migration: check if inlined content from this file exists (by id= match)
-    // and replace it with the #include directive
-    const domFileFullPath = join(engineDir, safeDomFilePath);
-    if (await pathExists(domFileFullPath)) {
-        const domContent = await readText(domFileFullPath);
-        const idMatch = /id\s*=\s*["']([^"']+)["']/.exec(domContent);
-        if (idMatch && content.includes(`id="${idMatch[1]}"`)) {
-            const lines = content.split('\n');
-            const rootId = idMatch[1];
-            const startIdx = lines.findIndex((l) => l.includes(`id="${rootId}"`));
-            if (startIdx !== -1) {
-                let endIdx = startIdx;
-                for (let i = startIdx; i < lines.length; i++) {
-                    const line = lines[i] ?? '';
-                    if (i > startIdx && (/^#include\s/.test(line.trim()) || line.trim() === '')) {
-                        endIdx = i;
-                        break;
-                    }
-                    endIdx = i + 1;
-                }
-                lines.splice(startIdx, endIdx - startIdx, includeDirective);
-                content = lines.join('\n');
-                await writeText(targetAbsPath, content);
-                return true;
-            }
-        }
-    }
-    // Normal insertion
-    const value = addDomFragmentTokenized(content, includeDirective);
-    await writeText(targetAbsPath, value);
-    return true;
-}

package/dist/src/core/wire-init.d.ts

@@ -1,28 +0,0 @@
-/**
- * browser-init.js: init expression in onLoad().
- */
-/**
- * AST-based implementation: finds onLoad() method body, locates existing
- * fireforge init blocks (TryStatements containing typeof guards), and inserts
- * after the correct position.
- *
- * `marker` is prepended (uppercased) to the generated comment line so the
- * emitted block carries the patch-lint `// <MARKER>:` signature that
- * `lintModificationComments` looks for. Otherwise the first export after
- * `wire` trips `missing-modification-comment` on wire-generated edits.
- */
-export declare function addInitAST(content: string, expression: string, after?: string, marker?: string): string;
-/**
- * Regex/line-based fallback implementation.
- */
-export declare function legacyAddInit(content: string, expression: string, after?: string, marker?: string): string;
-/**
- * Adds an init expression as the first statement(s) in gBrowserInit.onLoad()
- * in browser-init.js, after any previously-wired fireforge init blocks.
- *
- * @param engineDir - Engine source root
- * @param expression - The init expression (e.g., "MyComponent.init()")
- * @param after - Optional name to insert after (e.g., "MyComponent" to insert after its block)
- * @returns true if added, false if already present
- */
-export declare function addInitToBrowserInit(engineDir: string, expression: string, after?: string, marker?: string): Promise<boolean>;

package/dist/src/core/wire-init.js

@@ -1,219 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * browser-init.js: init expression in onLoad().
- */
-import { join } from 'node:path';
-import MagicString from 'magic-string';
-import { GeneralError } from '../errors/base.js';
-import { BuildError } from '../errors/build.js';
-import { pathExists, readText, writeText } from '../utils/fs.js';
-import { escapeRegex } from '../utils/regex.js';
-import { asEstree, detectIndent, getNodeSource, parseScript, } from './ast-utils.js';
-import { isInternalInvariantFailure, withParserFallback } from './parser-fallback.js';
-import { assertBraceBalancePreserved, coerceToCall, extractNameFromExpression, findInsertionAfterFireforgeBlocks, findMethodBody, findMethodBraceIndex, validateWireName, walkToTryBlockEnd, } from './wire-utils.js';
-const BROWSER_INIT_JS = 'browser/base/content/browser-init.js';
-/**
- * Default patch-lint marker used when a caller does not supply a
- * project-specific one. Kept as a constant so test fixtures and
- * fallback code paths agree on the shape.
- */
-const DEFAULT_MARKER = 'FIREFORGE:';
-/**
- * Default insertion point: after the last consecutive fireforge block, or at
- * the top of the method body when there is none.
- *
- * Both callers below (the `--after`-target-not-found fallthrough and the
- * no-`--after` default) must emit identical blocks, since `browser-init.js`
- * is written through both paths. One implementation enforces that invariant
- * rather than merely tidying.
- */
-function resolveDefaultInsertion(content, body, fireforgeBlocks) {
-    if (fireforgeBlocks.length > 0) {
-        const lastBlock = fireforgeBlocks[fireforgeBlocks.length - 1];
-        if (!lastBlock)
-            throw new GeneralError('Unexpected empty fireforgeBlocks array');
-        return { insertPos: lastBlock.end, indent: detectIndent(content, lastBlock.start) };
-    }
-    const firstStmt = body.body[0];
-    if (firstStmt) {
-        const insertPos = asEstree(firstStmt).start;
-        return { insertPos, indent: detectIndent(content, insertPos) };
-    }
-    return { insertPos: body.start + 1, indent: '    ' };
-}
-/**
- * AST-based implementation: finds onLoad() method body, locates existing
- * fireforge init blocks (TryStatements containing typeof guards), and inserts
- * after the correct position.
- *
- * `marker` is prepended (uppercased) to the generated comment line so the
- * emitted block carries the patch-lint `// <MARKER>:` signature that
- * `lintModificationComments` looks for. Otherwise the first export after
- * `wire` trips `missing-modification-comment` on wire-generated edits.
- */
-export function addInitAST(content, expression, after, marker = DEFAULT_MARKER) {
-    const name = extractNameFromExpression(expression);
-    // `validateWireName` accepts both `Foo.bar` and `Foo.bar()` shapes. The
-    // template below interpolates the value verbatim, so a bare property
-    // path compiles to `Foo.bar;`, a silent no-op rather than a lifecycle
-    // invocation. `coerceToCall` normalises to the function-call form so
-    // the emitted block always invokes the hook the operator asked for.
-    const callExpression = coerceToCall(expression);
-    const ast = parseScript(content);
-    const ms = new MagicString(content);
-    const body = findMethodBody(ast, 'onLoad');
-    if (!body) {
-        throw new BuildError('Could not find onLoad method body via AST');
-    }
-    // Collect fireforge try-catch blocks (those containing typeof guards)
-    const fireforgeBlocks = [];
-    for (const stmt of body.body) {
-        if (stmt.type === 'TryStatement') {
-            const tryNode = asEstree(stmt);
-            const src = getNodeSource(content, tryNode);
-            if (/typeof\s+\w+\s*!==\s*"undefined"/.test(src)) {
-                fireforgeBlocks.push(tryNode);
-            }
-        }
-    }
-    let insertPos;
-    let indent;
-    if (after) {
-        // Find the specific fireforge block containing the --after target
-        const targetBlock = fireforgeBlocks.find((block) => {
-            const src = getNodeSource(content, block);
-            return src.includes(`typeof ${after}`) || src.includes(`${after}.init(`);
-        });
-        if (targetBlock) {
-            insertPos = targetBlock.end;
-            indent = detectIndent(content, targetBlock.start);
-        }
-        else {
-            // --after target not found: fall through to default (after last fireforge block)
-            ({ insertPos, indent } = resolveDefaultInsertion(content, body, fireforgeBlocks));
-        }
-    }
-    else {
-        // Default: insert after the last consecutive fireforge block at the start
-        ({ insertPos, indent } = resolveDefaultInsertion(content, body, fireforgeBlocks));
-    }
-    const block = [
-        `${indent}// ${marker} wire-init ${name} — must be first, before Firefox subsystem`,
-        `${indent}// inits that reference native UI elements we hide.`,
-        `${indent}try {`,
-        `${indent}  if (typeof ${name} !== "undefined") {`,
-        `${indent}    ${callExpression};`,
-        `${indent}  }`,
-        `${indent}} catch (e) {`,
-        `${indent}  console.error("${name} init failed:", e);`,
-        `${indent}}`,
-    ].join('\n');
-    ms.appendRight(insertPos, '\n' + block + '\n');
-    return ms.toString();
-}
-/**
- * Regex/line-based fallback implementation.
- */
-export function legacyAddInit(content, expression, after, marker = DEFAULT_MARKER) {
-    const name = extractNameFromExpression(expression);
-    // See `addInitAST` for the rationale: the AST and fallback paths must
-    // agree on whether the emitted block is a function call, otherwise
-    // operators would see different behaviour depending on which parser
-    // happened to handle their browser-init.js layout.
-    const callExpression = coerceToCall(expression);
-    const lines = content.split('\n');
-    const onLoadRegex = /\b(?:async\s+)?onLoad\s*[(:]/;
-    const found = findMethodBraceIndex(lines, onLoadRegex, { requireBrace: true });
-    if (!found) {
-        throw new GeneralError('Could not find "onLoad" method in browser-init.js.\n' +
-            'FireForge was looking for a signature matching: \\b(?:async\\s+)?onLoad\\s*[(:]');
-    }
-    const { braceIndex } = found;
-    let insertIndex = braceIndex + 1;
-    if (after) {
-        // Try to find the specific --after target block
-        let located = false;
-        for (let i = braceIndex + 1; i < lines.length; i++) {
-            const line = lines[i] ?? '';
-            if (line.includes(`typeof ${after}`) || line.includes(`${after}.init(`)) {
-                // Walk backward to find the enclosing try, including a preceding comment
-                let tryStart = i;
-                for (let k = i - 1; k > braceIndex; k--) {
-                    if (/\btry\s*\{/.test(lines[k] ?? '')) {
-                        tryStart = k;
-                        break;
-                    }
-                    if (/\/\//.test(lines[k] ?? '') && /\btry\s*\{/.test(lines[k + 1] ?? '')) {
-                        tryStart = k;
-                        break;
-                    }
-                }
-                insertIndex = walkToTryBlockEnd(lines, tryStart, {
-                    strict: true,
-                    context: BROWSER_INIT_JS,
-                });
-                located = true;
-                break;
-            }
-        }
-        // If --after target not found, fall through to default fireforge block scan
-        if (!located) {
-            insertIndex = findInsertionAfterFireforgeBlocks(lines, braceIndex + 1, braceIndex);
-        }
-    }
-    else {
-        insertIndex = findInsertionAfterFireforgeBlocks(lines, braceIndex + 1, braceIndex);
-    }
-    // Detect indent from surrounding code instead of hardcoding
-    const refLine = lines
-        .slice(0, insertIndex)
-        .reverse()
-        .find((l) => l.trim());
-    const baseIndent = refLine?.match(/^(\s*)/)?.[1] ?? '    ';
-    const inner = baseIndent + '  ';
-    const inner2 = inner + '  ';
-    const block = [
-        `${baseIndent}// ${marker} wire-init ${name} — must be first, before Firefox subsystem`,
-        `${baseIndent}// inits that reference native UI elements we hide.`,
-        `${baseIndent}try {`,
-        `${inner}if (typeof ${name} !== "undefined") {`,
-        `${inner2}${callExpression};`,
-        `${inner}}`,
-        `${baseIndent}} catch (e) {`,
-        `${inner}console.error("${name} init failed:", e);`,
-        `${baseIndent}}`,
-    ];
-    lines.splice(insertIndex, 0, ...block);
-    return lines.join('\n');
-}
-/**
- * Adds an init expression as the first statement(s) in gBrowserInit.onLoad()
- * in browser-init.js, after any previously-wired fireforge init blocks.
- *
- * @param engineDir - Engine source root
- * @param expression - The init expression (e.g., "MyComponent.init()")
- * @param after - Optional name to insert after (e.g., "MyComponent" to insert after its block)
- * @returns true if added, false if already present
- */
-export async function addInitToBrowserInit(engineDir, expression, after, marker = DEFAULT_MARKER) {
-    validateWireName(expression, 'init expression');
-    const filePath = join(engineDir, BROWSER_INIT_JS);
-    if (!(await pathExists(filePath))) {
-        throw new GeneralError(`${BROWSER_INIT_JS} not found in engine`);
-    }
-    const content = await readText(filePath);
-    // Idempotency check: look for the coerced (call) form because that is
-    // what the emitter writes. Matching against the raw input would miss a
-    // bare `X.init` invocation that coercion already persisted as `X.init()`.
-    const callExpression = coerceToCall(expression);
-    const initPattern = new RegExp(`(?:^|\\W)${escapeRegex(callExpression)}\\s*;?\\s*$`, 'm');
-    if (initPattern.test(content)) {
-        return false;
-    }
-    const { value, usedFallback } = withParserFallback(() => addInitAST(content, expression, after, marker), () => legacyAddInit(content, expression, after, marker), BROWSER_INIT_JS, isInternalInvariantFailure);
-    if (usedFallback) {
-        assertBraceBalancePreserved(content, value, BROWSER_INIT_JS);
-    }
-    await writeText(filePath, value);
-    return true;
-}

package/dist/src/core/wire-subscript.d.ts

@@ -1,23 +0,0 @@
-/**
- * browser-main.js: loadSubScript registration.
- */
-/**
- * AST-based implementation: finds the last try/catch containing
- * `loadSubScript` and inserts a new try/catch block after it.
- *
- * The inserted block carries a `// <MARKER>: wire-subscript ...` comment so
- * the emitted edit satisfies `lintModificationComments`.
- */
-export declare function addSubscriptAST(content: string, name: string, marker?: string): string;
-/**
- * Regex/line-based fallback implementation.
- */
-export declare function legacyAddSubscript(content: string, name: string, marker?: string): string;
-/**
- * Adds a loadSubScript entry to browser-main.js with try/catch error handling.
- *
- * @param engineDir - Engine source root
- * @param name - Subscript name (without .js extension)
- * @returns true if added, false if already present
- */
-export declare function addSubscriptToBrowserMain(engineDir: string, name: string, marker?: string): Promise<boolean>;

package/dist/src/core/wire-subscript.js

@@ -1,145 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * browser-main.js: loadSubScript registration.
- */
-import { join } from 'node:path';
-import MagicString from 'magic-string';
-import { GeneralError } from '../errors/base.js';
-import { BuildError } from '../errors/build.js';
-import { pathExists, readText, writeText } from '../utils/fs.js';
-import { asEstree, detectIndent, getNodeSource, parseScript, walkAST, } from './ast-utils.js';
-import { isInternalInvariantFailure, withParserFallback } from './parser-fallback.js';
-import { assertBraceBalancePreserved, findNearestTryLine, validateWireName, walkToTryBlockEnd, } from './wire-utils.js';
-const BROWSER_MAIN_JS = 'browser/base/content/browser-main.js';
-const DEFAULT_MARKER = 'FIREFORGE:';
-/**
- * AST-based implementation: finds the last try/catch containing
- * `loadSubScript` and inserts a new try/catch block after it.
- *
- * The inserted block carries a `// <MARKER>: wire-subscript ...` comment so
- * the emitted edit satisfies `lintModificationComments`.
- */
-export function addSubscriptAST(content, name, marker = DEFAULT_MARKER) {
-    const ast = parseScript(content);
-    const ms = new MagicString(content);
-    // Collect all TryStatements containing loadSubScript
-    const tryNodes = [];
-    walkAST(ast, {
-        enter(node) {
-            if (node.type === 'TryStatement') {
-                const n = asEstree(node);
-                const src = getNodeSource(content, n);
-                if (src.includes('loadSubScript')) {
-                    tryNodes.push(n);
-                }
-            }
-        },
-    });
-    let insertPos;
-    let indent;
-    if (tryNodes.length > 0) {
-        const lastTry = tryNodes[tryNodes.length - 1];
-        if (!lastTry)
-            throw new GeneralError('Unexpected empty tryNodes array');
-        insertPos = lastTry.end;
-        indent = detectIndent(content, lastTry.start);
-    }
-    else {
-        // No existing loadSubScript: insert before last standalone closing brace
-        // Use line-based search to avoid matching braces inside strings/comments
-        const allLines = content.split('\n');
-        let lastBrace = -1;
-        for (let i = allLines.length - 1; i >= 0; i--) {
-            if (allLines[i]?.trim() === '}') {
-                lastBrace = allLines.slice(0, i).join('\n').length + 1;
-                break;
-            }
-        }
-        if (lastBrace === -1) {
-            throw new BuildError('Could not find closing brace in browser-main.js');
-        }
-        insertPos = lastBrace;
-        indent = detectIndent(content, lastBrace);
-    }
-    const block = [
-        `${indent}// ${marker} wire-subscript ${name}`,
-        `${indent}try {`,
-        `${indent}  Services.scriptloader.loadSubScript("chrome://browser/content/${name}.js", this);`,
-        `${indent}} catch (e) {`,
-        `${indent}  console.error("Failed to load ${name}.js:", e);`,
-        `${indent}}`,
-    ].join('\n');
-    ms.appendRight(insertPos, '\n' + block + '\n');
-    return ms.toString();
-}
-/**
- * Regex/line-based fallback implementation.
- */
-export function legacyAddSubscript(content, name, marker = DEFAULT_MARKER) {
-    const lines = content.split('\n');
-    let lastSubScriptLine = -1;
-    for (let i = 0; i < lines.length; i++) {
-        if (/loadSubScript/.test(lines[i] ?? '')) {
-            lastSubScriptLine = i;
-        }
-    }
-    let insertIndex;
-    if (lastSubScriptLine !== -1) {
-        const tryStart = findNearestTryLine(lines, lastSubScriptLine - 1, -1);
-        insertIndex =
-            tryStart !== -1
-                ? walkToTryBlockEnd(lines, tryStart, { strict: true, context: BROWSER_MAIN_JS })
-                : lastSubScriptLine + 1;
-    }
-    else {
-        insertIndex = lines.length;
-        for (let i = lines.length - 1; i >= 0; i--) {
-            if (lines[i]?.trim() === '}') {
-                insertIndex = i;
-                break;
-            }
-        }
-    }
-    // Detect indent from surrounding code instead of hardcoding
-    const refLine = lines
-        .slice(0, insertIndex)
-        .reverse()
-        .find((l) => l.trim());
-    const ind = refLine?.match(/^(\s*)/)?.[1] ?? '  ';
-    const inner = ind + '  ';
-    const block = [
-        `${ind}// ${marker} wire-subscript ${name}`,
-        `${ind}try {`,
-        `${inner}Services.scriptloader.loadSubScript("chrome://browser/content/${name}.js", this);`,
-        `${ind}} catch (e) {`,
-        `${inner}console.error("Failed to load ${name}.js:", e);`,
-        `${ind}}`,
-    ];
-    lines.splice(insertIndex, 0, ...block);
-    return lines.join('\n');
-}
-/**
- * Adds a loadSubScript entry to browser-main.js with try/catch error handling.
- *
- * @param engineDir - Engine source root
- * @param name - Subscript name (without .js extension)
- * @returns true if added, false if already present
- */
-export async function addSubscriptToBrowserMain(engineDir, name, marker = DEFAULT_MARKER) {
-    validateWireName(name, 'subscript name');
-    const filePath = join(engineDir, BROWSER_MAIN_JS);
-    if (!(await pathExists(filePath))) {
-        throw new GeneralError(`${BROWSER_MAIN_JS} not found in engine`);
-    }
-    const content = await readText(filePath);
-    // Idempotency check. Include the closing quote to avoid substring false positives
-    if (content.includes(`content/${name}.js"`)) {
-        return false;
-    }
-    const { value, usedFallback } = withParserFallback(() => addSubscriptAST(content, name, marker), () => legacyAddSubscript(content, name, marker), BROWSER_MAIN_JS, isInternalInvariantFailure);
-    if (usedFallback) {
-        assertBraceBalancePreserved(content, value, BROWSER_MAIN_JS);
-    }
-    await writeText(filePath, value);
-    return true;
-}