@hominis/fireforge 0.48.0 → 0.49.0

package/dist/src/core/component-source-guard.js

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { getNodeErrorCode } from '../utils/errors.js';
+import { sha256Hex } from '../utils/hash.js';
+/** Records authored bytes without following directory aliases or writing to source directories. */
+export async function snapshotComponentSources(roots) {
+    const files = new Map();
+    async function visit(directory) {
+        let entries;
+        try {
+            entries = await readdir(directory, { withFileTypes: true });
+        }
+        catch (error) {
+            if (getNodeErrorCode(error) === 'ENOENT')
+                return;
+            throw error;
+        }
+        for (const entry of entries) {
+            const path = join(directory, entry.name);
+            if (entry.isDirectory())
+                await visit(path);
+            else if (entry.isFile())
+                files.set(path, sha256Hex(await readFile(path)));
+        }
+    }
+    for (const root of roots)
+        await visit(root);
+    return files;
+}
+/** Detects reverted, removed or added source files before deployment can be committed. */
+export async function changedComponentSources(roots, before) {
+    const after = await snapshotComponentSources(roots);
+    return [...new Set([...before.keys(), ...after.keys()])]
+        .filter((path) => before.get(path) !== after.get(path))
+        .sort();
+}
+/** Captures only configured inputs for a real deploy, plus shared CSS fragments. */
+export async function captureComponentSources(paths, config, dryRun, options) {
+    if (dryRun)
+        return undefined;
+    const componentName = options?.componentName;
+    const selected = (name) => componentName === undefined || name === componentName;
+    const roots = [
+        ...Object.keys(config.custom)
+            .filter(selected)
+            .map((name) => join(paths.customDir, name)),
+        ...Object.keys(config.overrides)
+            .filter(selected)
+            .map((name) => join(paths.overridesDir, name)),
+        paths.sharedDir,
+    ];
+    return { roots, files: await snapshotComponentSources(roots) };
+}
+/** Produces a blocking apply error before the journal or ownership state is committed. */
+export async function componentSourceErrors(snapshot) {
+    if (!snapshot)
+        return [];
+    const changed = await changedComponentSources(snapshot.roots, snapshot.files);
+    return changed.length === 0
+        ? []
+        : [
+            {
+                name: 'component-sources',
+                error: `Component sources changed during deployment: ${changed.join(', ')}. Refusing this build/proof; inspect the source edits before retrying.`,
+            },
+        ];
+}

package/dist/src/core/coverage-extend.d.ts

@@ -1,37 +1,8 @@
 /**
- * `test --build/--build-only --extend-coverage`: unions the requested paths
- * into the recorded `testPackagingCoverage` instead of replacing it, under
- * an anchor guard.
- *
- * Coverage replaces by default for a reason documented in
- * `build-baseline-types.ts`: every baseline write refreshes
- * `packageableFingerprints` for all dirty packageable paths, so a blind
- * union would whitewash an earlier scope's edited fixtures while
- * `obj-*`/`_tests/` still holds that scope's stale staging. Extending is
- * honest only while everything the previous record vouched for is still
- * true, which is what {@link checkExtendCoverageAnchor} and
- * {@link checkExtendMozconfigAnchor} verify:
- *
- *   1. engine HEAD is unchanged, so every committed edit is excluded.
- *   2. every path the previous baseline fingerprinted still hashes to the
- *      recorded digest, so the earlier scope's staging inputs are
- *      byte-identical. Files that became dirty since that build are fine:
- *      the current whole-tree `mach build faster` repackages `dist/` and
- *      vouches for them.
- *   3. the generated `engine/mozconfig` is unchanged. Engine HEAD does not
- *      cover this: the mozconfig is regenerated from project-side
- *      `configs/*.mozconfig` templates plus `fireforge.json` on every build,
- *      so two builds at the same engine SHA can configure differently.
- *
- * Every failure refuses fail-closed. The operator's remedy is always a plain
- * scoped build, which resets the claim to the paths it actually vouches for.
- *
- * Known boundary, documented rather than closed: dirty non-packageable
- * fixtures under previously covered paths (plain test files, manifests
- * `isPackageablePath` rejects) are invisible to check 2. Editing one
- * uncommitted between two builds leaves the earlier scope's `_tests/`
- * staging stale while extend still vouches for it. Plain replacement has no such
- * window, because the earlier scope simply stops being covered.
+ * Retains prior test staging only when HEAD, mozconfig and every recorded
+ * dirty input outside the newly rebuilt scope are unchanged. Complete
+ * input fingerprints are required: packageable-only legacy records cannot
+ * prove that a test fixture or manifest still matches its staged copy.
  */
 import { type BuildBaseline, type TestPackagingCoverage } from './build-baseline-types.js';
 /** Why `--extend-coverage` could not union onto the recorded claim. */
@@ -51,7 +22,7 @@ export type ExtendAnchorResult = {
  * @param engineDir - Path to the engine directory
  * @param previousBaseline - Baseline recorded by the previous build
  */
-export declare function checkExtendCoverageAnchor(engineDir: string, previousBaseline: BuildBaseline | undefined): Promise<ExtendAnchorResult>;
+export declare function checkExtendCoverageAnchor(engineDir: string, previousBaseline: BuildBaseline | undefined, rebuiltPaths?: readonly string[]): Promise<ExtendAnchorResult>;
 /**
  * Verifies the mozconfig half of the anchor. Split from
  * {@link checkExtendCoverageAnchor} because it can only run after

package/dist/src/core/coverage-extend.js

@@ -1,38 +1,9 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
- * `test --build/--build-only --extend-coverage`: unions the requested paths
- * into the recorded `testPackagingCoverage` instead of replacing it, under
- * an anchor guard.
- *
- * Coverage replaces by default for a reason documented in
- * `build-baseline-types.ts`: every baseline write refreshes
- * `packageableFingerprints` for all dirty packageable paths, so a blind
- * union would whitewash an earlier scope's edited fixtures while
- * `obj-*`/`_tests/` still holds that scope's stale staging. Extending is
- * honest only while everything the previous record vouched for is still
- * true, which is what {@link checkExtendCoverageAnchor} and
- * {@link checkExtendMozconfigAnchor} verify:
- *
- *   1. engine HEAD is unchanged, so every committed edit is excluded.
- *   2. every path the previous baseline fingerprinted still hashes to the
- *      recorded digest, so the earlier scope's staging inputs are
- *      byte-identical. Files that became dirty since that build are fine:
- *      the current whole-tree `mach build faster` repackages `dist/` and
- *      vouches for them.
- *   3. the generated `engine/mozconfig` is unchanged. Engine HEAD does not
- *      cover this: the mozconfig is regenerated from project-side
- *      `configs/*.mozconfig` templates plus `fireforge.json` on every build,
- *      so two builds at the same engine SHA can configure differently.
- *
- * Every failure refuses fail-closed. The operator's remedy is always a plain
- * scoped build, which resets the claim to the paths it actually vouches for.
- *
- * Known boundary, documented rather than closed: dirty non-packageable
- * fixtures under previously covered paths (plain test files, manifests
- * `isPackageablePath` rejects) are invisible to check 2. Editing one
- * uncommitted between two builds leaves the earlier scope's `_tests/`
- * staging stale while extend still vouches for it. Plain replacement has no such
- * window, because the earlier scope simply stops being covered.
+ * Retains prior test staging only when HEAD, mozconfig and every recorded
+ * dirty input outside the newly rebuilt scope are unchanged. Complete
+ * input fingerprints are required: packageable-only legacy records cannot
+ * prove that a test fixture or manifest still matches its staged copy.
  */
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -41,6 +12,8 @@ import { sha256Hex } from '../utils/hash.js';
 import { verbose } from '../utils/logger.js';
 import { DELETED_FILE_FINGERPRINT, } from './build-baseline-types.js';
 import { getHead, isMissingHeadError } from './git.js';
+import { git } from './git-base.js';
+import { getUntrackedFiles } from './git-status.js';
 /** Filename of the generated mozconfig, relative to the engine directory. */
 const MOZCONFIG_FILENAME = 'mozconfig';
 /** How many diverged paths a refusal names before truncating. */
@@ -52,14 +25,15 @@ const MAX_DIVERGED_REPORTED = 5;
  * @param engineDir - Path to the engine directory
  * @param previousBaseline - Baseline recorded by the previous build
  */
-export async function checkExtendCoverageAnchor(engineDir, previousBaseline) {
+export async function checkExtendCoverageAnchor(engineDir, previousBaseline, rebuiltPaths = []) {
     if (previousBaseline === undefined) {
         return { ok: false, reason: 'no-baseline', detail: [] };
     }
     if (previousBaseline.mozconfigHash === undefined) {
         return { ok: false, reason: 'no-mozconfig-hash', detail: [] };
     }
-    const recordedFingerprints = previousBaseline.packageableFingerprints;
+    const recordedFingerprints = previousBaseline.testInputFingerprints;
+    const rebuilt = (file) => rebuiltPaths.some((path) => file === path || file.startsWith(path.replace(/\/$/, '') + '/'));
     if (recordedFingerprints === undefined) {
         return { ok: false, reason: 'no-fingerprints', detail: [] };
     }
@@ -77,10 +51,25 @@ export async function checkExtendCoverageAnchor(engineDir, previousBaseline) {
     }
     const diverged = [];
     for (const [relPath, recordedHash] of Object.entries(recordedFingerprints)) {
+        if (rebuilt(relPath))
+            continue;
         const liveHash = await hashEngineFile(engineDir, relPath);
         if (liveHash !== recordedHash)
             diverged.push(relPath);
     }
+    // New dirty test inputs are absent from the previous fingerprint map.
+    // They invalidate retained staging too; explicitly rebuilt inputs are safe.
+    if (previousBaseline.testInputFingerprints !== undefined) {
+        const changed = (await git(['diff', '--name-only', 'HEAD'], engineDir)).split('\n');
+        changed.push(...(await getUntrackedFiles(engineDir)));
+        for (const file of changed.filter(Boolean)) {
+            if (file === MOZCONFIG_FILENAME || rebuilt(file) || Object.hasOwn(recordedFingerprints, file))
+                continue;
+            // A retained manifest may stage a shared fixture outside test-named
+            // directories. Without its full dependency graph, refuse conservatively.
+            diverged.push(file);
+        }
+    }
     if (diverged.length > 0) {
         return { ok: false, reason: 'fingerprint-diverged', detail: diverged.sort() };
     }
@@ -136,7 +125,7 @@ export function formatExtendCoverageRefusal(result) {
             return ('--extend-coverage refused: the recorded baseline predates the mozconfig anchor, so it ' +
                 `cannot be proven that this build configures identically. ${remedy}`);
         case 'no-fingerprints':
-            return ('--extend-coverage refused: the recorded baseline carries no packageable fingerprints, so ' +
+            return ('--extend-coverage refused: the recorded baseline carries no complete test-input fingerprints, so ' +
                 `the earlier scope's staging inputs cannot be verified unchanged. ${remedy}`);
         case 'head-moved':
             return ('--extend-coverage refused: engine HEAD moved since the recorded build ' +
@@ -144,7 +133,7 @@ export function formatExtendCoverageRefusal(result) {
                 `longer anchored. ${remedy}`);
         case 'fingerprint-diverged':
             return ('--extend-coverage refused: ' +
-                `${result.detail.length} packageable file(s) the recorded build staged have changed ` +
+                `${result.detail.length} staging input(s) the recorded build staged have changed ` +
                 `since (${formatDivergedPaths(result.detail)}). Extending would vouch for the earlier scope ` +
                 `while obj-*/_tests/ still holds its stale staging. ${remedy}`);
         case 'mozconfig-changed':

package/dist/src/core/engine-write-boundary.d.ts

@@ -0,0 +1,5 @@
+import type { FurnaceConfig } from '../types/furnace.js';
+/** Checks all component destinations before an apply starts writing. */
+export declare function assertComponentWriteBoundaries(engineDir: string, config: FurnaceConfig, ftlDir: string): Promise<void>;
+/** Resolves the nearest existing parent before any mkdir/copy can write through an alias. */
+export declare function assertEngineWriteBoundary(engineDir: string, directory: string): Promise<void>;

package/dist/src/core/engine-write-boundary.js

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { realpath } from 'node:fs/promises';
+import { dirname, join, resolve, sep } from 'node:path';
+import { FurnaceError } from '../errors/furnace.js';
+import { getNodeErrorCode } from '../utils/errors.js';
+import { CUSTOM_ELEMENTS_JS, JAR_MN } from './furnace-constants.js';
+/** Checks all component destinations before an apply starts writing. */
+export async function assertComponentWriteBoundaries(engineDir, config, ftlDir) {
+    const destinations = new Set([
+        ftlDir,
+        dirname(JAR_MN),
+        dirname(CUSTOM_ELEMENTS_JS),
+        ...Object.values(config.custom).map((entry) => entry.targetPath),
+        ...Object.values(config.overrides).map((entry) => entry.basePath),
+    ]);
+    for (const destination of destinations) {
+        await assertEngineWriteBoundary(engineDir, join(engineDir, destination));
+    }
+}
+/** Resolves the nearest existing parent before any mkdir/copy can write through an alias. */
+export async function assertEngineWriteBoundary(engineDir, directory) {
+    const root = await realpath(engineDir);
+    let parent = resolve(directory);
+    for (;;) {
+        try {
+            const canonical = await realpath(parent);
+            if (canonical !== root && !canonical.startsWith(root + sep)) {
+                throw new FurnaceError(`Engine destination ${directory} resolves outside engine/ (${canonical}). Refusing to write through into component sources or another checkout.`);
+            }
+            return;
+        }
+        catch (error) {
+            if (getNodeErrorCode(error) !== 'ENOENT')
+                throw error;
+            const next = dirname(parent);
+            if (next === parent)
+                throw error;
+            parent = next;
+        }
+    }
+}

package/dist/src/core/furnace-apply-helpers.js

@@ -323,13 +323,16 @@ export async function applyCustomComponent(ctx, config, dryRun = false, rollback
     // fragment-expanded form. The workspace source keeps only the directive,
     // so shared CSS stays single-sourced.
     const sharedDir = join(componentDir, '..', '..', SHARED_FRAGMENTS_DIR);
-    await Promise.all(filesToCopy.map(async (entry) => {
+    const copies = await Promise.allSettled(filesToCopy.map(async (entry) => {
         const src = join(componentDir, entry.name);
         const dest = join(targetDir, entry.name);
         await deployFileWithFragments(src, dest, sharedDir);
         affectedPaths.push(normalizePathSlashes(relative(engineDir, dest)));
         copiedFileNames.push(entry.name);
     }));
+    const failedCopy = copies.find((copy) => copy.status === 'rejected');
+    if (failedCopy?.status === 'rejected')
+        throw failedCopy.reason;
     // See buildCustomDryRunActions for the rationale: when `sharedFtl` is set
     // the shared bundle is owned elsewhere and FireForge must not copy or
     // register a per-component `.ftl` on its behalf.
@@ -416,12 +419,15 @@ export async function applyOverrideComponent(ctx, config, dryRun = false, rollba
         }
     }
     // Copy phase (parallel)
-    await Promise.all(candidateEntries.map(async (entry) => {
+    const copies = await Promise.allSettled(candidateEntries.map(async (entry) => {
         const src = join(componentDir, entry.name);
         const dest = getOverrideEngineTargetPath(engineDir, config, entry.name, ftlDir);
         await copyFile(src, dest);
         affectedPaths.push(normalizePathSlashes(relative(engineDir, dest)));
     }));
+    const failedCopy = copies.find((copy) => copy.status === 'rejected');
+    if (failedCopy?.status === 'rejected')
+        throw failedCopy.reason;
     if (affectedPaths.length === 0) {
         throw new FurnaceError(`No matching files found in override directory for "${name}"`, name);
     }

package/dist/src/core/furnace-apply.js

@@ -5,7 +5,9 @@ import { assert } from '../utils/assert.js';
 import { toError } from '../utils/errors.js';
 import { pathExists } from '../utils/fs.js';
 import { info } from '../utils/logger.js';
+import { captureComponentSources, componentSourceErrors } from './component-source-guard.js';
 import { getProjectPaths, loadConfig } from './config.js';
+import { assertComponentWriteBoundaries } from './engine-write-boundary.js';
 import { applyCustomComponent, applyOverrideComponent, computeComponentChecksums, diffDeletedFiles, extractComponentChecksums, hasComponentChanged, hasCustomEngineDrift, hasOverrideEngineDrift, prefixChecksums, undeployCustomFiles, undeployOverrideFiles, } from './furnace-apply-helpers.js';
 import { findPatchOwnedOverwrites, loadPatchClaimsForApply, recordOverwriteWarnings, } from './furnace-apply-overwrite-warn.js';
 import { buildCustomUndeployActions, buildOverrideUndeployActions, } from './furnace-apply-undeploy-actions.js';
@@ -334,6 +336,10 @@ export async function applyAllComponents(root, dryRun = false, options) {
     const forgeConfig = await loadConfig(root).catch(() => undefined);
     const markerComment = resolveFurnaceMarkerComment(forgeConfig);
     await assertFurnaceEngineDirReady(engineDir);
+    if (!dryRun) {
+        await assertComponentWriteBoundaries(engineDir, config, ftlDir);
+    }
+    const sourceSnapshot = await captureComponentSources(furnacePaths, config, dryRun, options);
     const rollbackJournal = dryRun ? undefined : createRollbackJournal();
     if (rollbackJournal && operationContext) {
         operationContext.registerJournal(rollbackJournal);
@@ -381,6 +387,7 @@ export async function applyAllComponents(root, dryRun = false, options) {
     };
     await applyOverrideBatch(batchContext);
     await applyCustomBatch(batchContext, root, markerComment);
+    result.errors.push(...(await componentSourceErrors(sourceSnapshot)));
     // Check for any partial failures (blocking step errors on applied
     // components). Advisory step errors (e.g. FTL degradation) are warnings
     // and never gate rollback.

package/dist/src/core/furnace-validate-accessibility.js

@@ -2,6 +2,7 @@
 import { join } from 'node:path';
 import { pathExists, readText } from '../utils/fs.js';
 import { createIssue } from './furnace-validate-helpers.js';
+import { collectLitTemplateRegions, parseTemplateAttributes } from './lit-template-regions.js';
 /**
  * Validates accessibility patterns in a component's .mjs file.
  * Checks for ARIA roles, keyboard handlers, l10n, and focus delegation.
@@ -103,15 +104,16 @@ function hasUnlabelledFormInput(content) {
     // (id implies an external <label for="..."> could exist). A control wrapped
     // in a <label> that carries actual text is implicitly associated and is
     // exempt as well.
+    content = collectLitTemplateRegions(content).join('\n');
     const labelledSpans = collectLabelledSpans(content);
-    const inputPattern = /<(input|select|textarea)\b([^>]*)>/gi;
+    const inputPattern = /<(input|select|textarea)\b((?:"[^"]*"|'[^']*'|[^'">])*)>/gi;
     let inputMatch;
     while ((inputMatch = inputPattern.exec(content)) !== null) {
-        const attrs = inputMatch[2] ?? '';
-        if (/aria-label\s*=/.test(attrs) ||
-            /aria-labelledby\s*=/.test(attrs) ||
-            /\bid\s*=/.test(attrs) ||
-            /type\s*=\s*["']hidden["']/i.test(attrs)) {
+        const attrs = parseTemplateAttributes(inputMatch[2] ?? '');
+        if (attrs.has('aria-label') ||
+            attrs.has('aria-labelledby') ||
+            attrs.has('id') ||
+            attrs.get('type')?.toLowerCase() === 'hidden') {
             continue;
         }
         const index = inputMatch.index;
@@ -315,12 +317,7 @@ function isFlaggableText(text) {
     return true;
 }
 function hasFlaggedTextInLitTemplates(content) {
-    // Match `html\`…\`` regions, anchored on a non-identifier char before `html`
-    // so substrings like `otherhtml` do not spuriously open a template.
-    const htmlPattern = /(?:^|[^a-zA-Z0-9_$])html`([\s\S]*?)`/g;
-    let litMatch;
-    while ((litMatch = htmlPattern.exec(content)) !== null) {
-        const region = litMatch[1] ?? '';
+    for (const region of collectLitTemplateRegions(content)) {
         const textPattern = />([^<$\s][^<$]*)</g;
         let textMatch;
         while ((textMatch = textPattern.exec(region)) !== null) {

package/dist/src/core/furnace-validate.js

@@ -1,14 +1,12 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
-import { toError } from '../utils/errors.js';
 import { pathExists } from '../utils/fs.js';
 import { getProjectPaths, loadConfig } from './config.js';
 import { extractComponentChecksums } from './furnace-checksum-utils.js';
 import { getFurnacePaths, loadFurnaceConfig, loadFurnaceState } from './furnace-config.js';
 import { resolveFtlDir, xpcshellTestParentDir } from './furnace-constants.js';
 import { validateCssFragments } from './furnace-css-fragments.js';
-import { detectComposesCycles, validateComposesReferences } from './furnace-graph-utils.js';
 import { findJsconfigPathsDrift } from './furnace-jsconfig.js';
 import { validateAccessibility, validateCompatibility, validateJarMnEntries, validateRegistrationPatterns, validateStructure, validateTokenLink, } from './furnace-validate-checks.js';
 import { createIssue } from './furnace-validate-helpers.js';
@@ -110,47 +108,6 @@ export async function validateAllComponents(root) {
         const config = await loadFurnaceConfig(root);
         const furnacePaths = getFurnacePaths(root);
         const results = new Map();
-        // Validate composition graph integrity (dangling references and cycles)
-        try {
-            validateComposesReferences(config.stock, config.overrides, config.custom);
-        }
-        catch (err) {
-            const message = toError(err).message;
-            // Attribute the issue to the first custom component with a bad composes reference
-            for (const [name, cfg] of Object.entries(config.custom)) {
-                if (cfg.composes) {
-                    const existing = results.get(name) ?? [];
-                    existing.push({
-                        component: name,
-                        severity: 'error',
-                        check: 'composes-dangling-reference',
-                        message,
-                    });
-                    results.set(name, existing);
-                    break;
-                }
-            }
-        }
-        try {
-            detectComposesCycles(config.custom);
-        }
-        catch (err) {
-            const message = toError(err).message;
-            // Attribute the cycle issue to the first custom component in the cycle
-            for (const name of Object.keys(config.custom)) {
-                if (config.custom[name]?.composes) {
-                    const existing = results.get(name) ?? [];
-                    existing.push({
-                        component: name,
-                        severity: 'error',
-                        check: 'composes-cycle',
-                        message,
-                    });
-                    results.set(name, existing);
-                    break;
-                }
-            }
-        }
         // Override components
         for (const name of Object.keys(config.overrides)) {
             const componentDir = join(furnacePaths.overridesDir, name);

package/dist/src/core/gecko-dom-types.d.ts

@@ -0,0 +1,2 @@
+/** Adds Gecko's cross-compartment DOM predicates to virtual lib.dom constructor types. */
+export declare function withGeckoDomTypes(ts: typeof import('typescript'), host: import('typescript').CompilerHost): import('typescript').CompilerHost;

package/dist/src/core/gecko-dom-types.js

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: EUPL-1.2
+/** Adds Gecko's cross-compartment DOM predicates to virtual lib.dom constructor types. */
+export function withGeckoDomTypes(ts, host) {
+    const original = host.getSourceFile.bind(host);
+    return {
+        ...host,
+        getSourceFile(...args) {
+            const file = original(...args);
+            if (!file || !args[0].endsWith('/lib.dom.d.ts'))
+                return file;
+            const source = file.text.replace(/declare var (\w+): \{\s*prototype: (\w+);/g, (declaration, name, instance) => declaration +
+                `\n    isInstance(value: unknown): value is ${instance};` +
+                (name === 'MouseEvent' ? '\n    readonly MOZ_SOURCE_PEN: number;' : ''));
+            return ts.createSourceFile(args[0], source, args[1], true);
+        },
+    };
+}

package/dist/src/core/lit-template-regions.d.ts

@@ -0,0 +1,4 @@
+/** Collects Lit html quasis, masking expressions while preserving nested templates. */
+export declare function collectLitTemplateRegions(content: string): string[];
+/** Reads actual attribute names and values, skipping quoted values as indivisible tokens. */
+export declare function parseTemplateAttributes(source: string): Map<string, string | undefined>;

package/dist/src/core/lit-template-regions.js

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { tokenizer } from 'acorn';
+/** Collects Lit html quasis, masking expressions while preserving nested templates. */
+export function collectLitTemplateRegions(content) {
+    const regions = [];
+    const stack = [];
+    let previous = '';
+    let previousValue;
+    try {
+        for (const token of tokenizer(content, { ecmaVersion: 'latest', sourceType: 'module' })) {
+            const label = token.type.label;
+            if (label === '`') {
+                if (previous === 'template' || previous === 'invalidTemplate') {
+                    const closed = stack.pop();
+                    if (closed?.html)
+                        regions.push(closed.text);
+                }
+                else {
+                    stack.push({ html: previous === 'name' && previousValue === 'html', text: '' });
+                }
+            }
+            else if (label === 'template') {
+                const current = stack.at(-1);
+                if (current)
+                    current.text += content.slice(token.start, token.end);
+            }
+            else if (label === '${') {
+                const current = stack.at(-1);
+                if (current)
+                    current.text += '${expression}';
+            }
+            previous = label;
+            previousValue = content.slice(token.start, token.end);
+        }
+    }
+    catch {
+        // Keep completed regions from a file being edited; never re-pair backticks.
+    }
+    return regions;
+}
+/** Reads actual attribute names and values, skipping quoted values as indivisible tokens. */
+export function parseTemplateAttributes(source) {
+    const attributes = new Map();
+    const pattern = /([^\s=/>]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
+    for (const match of source.matchAll(pattern)) {
+        if (match[1])
+            attributes.set(match[1].toLowerCase(), match[2] ?? match[3] ?? match[4]);
+    }
+    return attributes;
+}

package/dist/src/core/mach-build-artifacts.d.ts

@@ -92,6 +92,8 @@ export interface MozinfoRewriteResult {
     reason?: string;
     /** New `topsrcdir` value written to disk (populated on success). */
     newTopsrcdir?: string;
+    /** Original source prefix checked after configure. */
+    oldTopsrcdir?: string;
     /** New `topobjdir` value written to disk (populated on success). */
     newTopobjdir?: string;
     /** New `mozconfig` value written to disk (populated on success when it lived inside topsrcdir). */
@@ -100,12 +102,10 @@ export interface MozinfoRewriteResult {
 /**
  * Safe-relocation rewriter for mozinfo.json under the active obj-* tree.
  *
- * Firefox build artefacts bake the topsrcdir into many generated files
- * (Makefiles, config.status, backend.mk, .deps dependency files, anything
- * produced by `mach configure`). A fresh `mach configure` rebuilds those
- * from the top, so the rewriter only needs to patch the one file `mach`
- * reads to learn where its checkout actually lives. Once mozinfo.json
- * agrees with the on-disk layout, `mach configure` regenerates the rest.
+ * Copied objdirs retain source symlinks, dependency metadata and tracking
+ * inventories as well as mozinfo.json. Repair them before configure so
+ * config.track cannot write nulls into the primary checkout. Configure then
+ * regenerates the root config files; callers verify old-source links too.
  *
  * Safety rules. The rewrite is refused when any of them are violated:
  *   - `topsrcdir` and `topobjdir` must both be present and non-empty.

package/dist/src/core/mach-build-artifacts.js

@@ -9,6 +9,7 @@ import { verbose } from '../utils/logger.js';
 import { getPlatform } from '../utils/platform.js';
 import { isObject, isString } from '../utils/validation.js';
 import { extractMozObjdirName } from './mach-mozconfig.js';
+import { findStaleObjdirLink, relocateObjdirProducts } from './objdir-maintenance.js';
 function validateBuildMozinfo(data) {
     if (!isObject(data)) {
         throw new Error('mozinfo metadata must be an object');
@@ -239,12 +240,10 @@ export function buildArtifactMismatchMessage(engineDir, buildCheck, commandName)
 /**
  * Safe-relocation rewriter for mozinfo.json under the active obj-* tree.
  *
- * Firefox build artefacts bake the topsrcdir into many generated files
- * (Makefiles, config.status, backend.mk, .deps dependency files, anything
- * produced by `mach configure`). A fresh `mach configure` rebuilds those
- * from the top, so the rewriter only needs to patch the one file `mach`
- * reads to learn where its checkout actually lives. Once mozinfo.json
- * agrees with the on-disk layout, `mach configure` regenerates the rest.
+ * Copied objdirs retain source symlinks, dependency metadata and tracking
+ * inventories as well as mozinfo.json. Repair them before configure so
+ * config.track cannot write nulls into the primary checkout. Configure then
+ * regenerates the root config files; callers verify old-source links too.
  *
  * Safety rules. The rewrite is refused when any of them are violated:
  *   - `topsrcdir` and `topobjdir` must both be present and non-empty.
@@ -328,10 +327,17 @@ export async function attemptMozinfoRewrite(engineDir, objDir) {
         // its mozconfig will still fail configure. The operator can re-point
         // with `MOZCONFIG=…` or run a full clean rebuild.
     }
+    try {
+        await relocateObjdirProducts(engineDir, objDir, oldSrcResolved);
+    }
+    catch (error) {
+        return { rewritten: false, reason: `objdir relocation refused: ${toError(error).message}` };
+    }
     await writeJson(mozinfoPath, patched);
     return {
         rewritten: true,
         newTopsrcdir: newSrc,
+        oldTopsrcdir: oldSrcResolved,
         newTopobjdir: newObj,
         ...(newMozconfig ? { newMozconfig } : {}),
     };
@@ -426,5 +432,5 @@ export async function findObjdirRelocationViolation(args) {
             return `${objDir}/${name} still contains the primary engine path ${forbidden}`;
         }
     }
-    return undefined;
+    return await findStaleObjdirLink(engineDir, objDir, forbidden);
 }