@hominis/fireforge 0.9.0

package/dist/src/core/patch-transform.js

@@ -0,0 +1,138 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Pure content transformation functions for patch operations.
+ * These operate on file content strings without filesystem side effects.
+ */
+import { PatchError } from '../errors/patch.js';
+import { readText } from '../utils/fs.js';
+import { isNewFileInPatch, parseHunksForFile } from './patch-parse.js';
+/**
+ * Extracts the complete file content from a "new file" patch.
+ * When targetFile is provided, only extracts content for that file
+ * (required for multi-file patches).
+ * @param patchPath - Path to the patch file
+ * @param targetFile - Optional target file to scope extraction to
+ * @returns The file content that the patch would create
+ */
+export async function extractNewFileContent(patchPath, targetFile) {
+    const content = await readText(patchPath);
+    const lines = content.split('\n');
+    const contentLines = [];
+    let inHunk = false;
+    let inTargetFile = !targetFile; // If no targetFile, accept all sections
+    let hasNoNewlineMarker = false;
+    for (const line of lines) {
+        // Track which file section we're in
+        if (line.startsWith('diff --git')) {
+            if (targetFile) {
+                const match = /^diff --git a\/.+ b\/(.+)$/.exec(line);
+                const wasInTarget = inTargetFile;
+                inTargetFile = match?.[1] === targetFile;
+                // If we were in the target file and hit a new diff header, we're done
+                if (wasInTarget && !inTargetFile)
+                    break;
+            }
+            inHunk = false;
+            continue;
+        }
+        if (!inTargetFile)
+            continue;
+        // Start of hunk
+        if (line.startsWith('@@')) {
+            inHunk = true;
+            continue;
+        }
+        if (inHunk) {
+            // Check for "No newline at end of file" marker
+            if (line === '\') {
+                hasNoNewlineMarker = true;
+                continue;
+            }
+            // Lines starting with + are added content (skip the + prefix)
+            if (line.startsWith('+')) {
+                contentLines.push(line.slice(1));
+            }
+            // Lines starting with - are removed (shouldn't exist in new file patches)
+            // Context lines (no prefix) shouldn't exist in new file patches
+        }
+    }
+    // Join lines and handle trailing newline
+    const result = contentLines.join('\n');
+    return hasNoNewlineMarker ? result : result + '\n';
+}
+/**
+ * Applies a patch's changes to content.
+ * @param content - Original content (null for new files)
+ * @param patchPath - Path to the patch file
+ * @param targetFile - The file path within the patch
+ * @returns Modified content
+ */
+export async function applyPatchToContent(content, patchPath, targetFile) {
+    const patchContent = await readText(patchPath);
+    // Check if this is a new file patch for the target file specifically
+    if (content === null) {
+        if (isNewFileInPatch(patchContent, targetFile)) {
+            return await extractNewFileContent(patchPath, targetFile);
+        }
+        // If not a new file patch but content is null, return empty
+        return '';
+    }
+    const hunks = parseHunksForFile(patchContent, targetFile);
+    if (hunks.length === 0) {
+        return content;
+    }
+    // Apply hunks
+    const contentLines = content.split('\n');
+    // Remove trailing empty line if content ends with newline (but not for empty files)
+    if (contentLines.length > 1 && contentLines[contentLines.length - 1] === '') {
+        contentLines.pop();
+    }
+    // Process hunks in reverse order to preserve line numbers
+    const sortedHunks = [...hunks].sort((a, b) => b.oldStart - a.oldStart);
+    // The "no newline at end" marker applies to the last hunk in file order
+    // (highest oldStart), which is the *first* hunk in our reverse-sorted array.
+    const lastHunkNoNewline = sortedHunks[0]?.noNewlineAtEnd ?? false;
+    for (const hunk of sortedHunks) {
+        const newLines = [];
+        // Compute actual old-line count from hunk body for cross-check
+        let actualOldCount = 0;
+        for (const line of hunk.lines) {
+            if (line.startsWith('+')) {
+                newLines.push(line.slice(1));
+            }
+            else if (line.startsWith(' ')) {
+                newLines.push(line.slice(1));
+                actualOldCount++;
+            }
+            else if (line.startsWith('-')) {
+                actualOldCount++;
+            }
+            // Lines starting with '-' are removed (not added to newLines)
+        }
+        if (actualOldCount !== hunk.oldCount) {
+            throw new PatchError(`Patch hunk header mismatch for ${targetFile}: header says ${hunk.oldCount} old lines but body has ${actualOldCount}`, targetFile);
+        }
+        // Replace the old lines with new lines
+        const startIndex = hunk.oldStart - 1;
+        // Verify context lines match before applying
+        let verifyIndex = startIndex;
+        for (const hunkLine of hunk.lines) {
+            if (hunkLine.startsWith(' ') || hunkLine.startsWith('-')) {
+                const expectedContent = hunkLine.slice(1);
+                const actualContent = contentLines[verifyIndex];
+                if (actualContent !== expectedContent) {
+                    throw new PatchError(`Patch context mismatch at line ${verifyIndex + 1} for ${targetFile}: ` +
+                        `expected "${expectedContent}", got "${actualContent}"`, targetFile);
+                }
+                verifyIndex++;
+            }
+        }
+        contentLines.splice(startIndex, hunk.oldCount, ...newLines);
+    }
+    // Respect the no-newline-at-end-of-file marker from the last hunk
+    if (lastHunkNoNewline) {
+        return contentLines.join('\n');
+    }
+    return contentLines.join('\n') + '\n';
+}
+//# sourceMappingURL=patch-transform.js.map

package/dist/src/core/rebase-session.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Rebase session persistence for multi-patch ESR version upgrades.
+ * Session state is stored at `.fireforge/rebase-session.json` and
+ * survives across CLI invocations so the user can fix conflicts and
+ * resume with `fireforge rebase --continue`.
+ */
+export type RebasePatchStatus = 'pending' | 'applied-clean' | 'applied-fuzz' | 'failed' | 'resolved' | 'skipped';
+export interface RebasePatchEntry {
+    filename: string;
+    status: RebasePatchStatus;
+    /** Fuzz factor used when status is `applied-fuzz`. */
+    fuzzFactor?: number;
+    /** Error message when status is `failed`. */
+    error?: string;
+    /** Files that caused conflicts. */
+    conflictingFiles?: string[];
+}
+export interface RebaseSession {
+    /** ISO timestamp when the rebase started. */
+    startedAt: string;
+    /** ESR version being rebased FROM. */
+    fromVersion: string;
+    /** ESR version being rebased TO. */
+    toVersion: string;
+    /** Commit hash recorded before the rebase started (for --abort). */
+    preRebaseCommit: string;
+    /** Ordered list of all patches and their status. */
+    patches: RebasePatchEntry[];
+    /** Index of the next patch to process (resume point). */
+    currentIndex: number;
+}
+/**
+ * Loads an existing rebase session, or returns `null` if none exists.
+ */
+export declare function loadRebaseSession(projectRoot: string): Promise<RebaseSession | null>;
+/**
+ * Persists a rebase session atomically.
+ */
+export declare function saveRebaseSession(projectRoot: string, session: RebaseSession): Promise<void>;
+/**
+ * Removes the rebase session file.
+ */
+export declare function clearRebaseSession(projectRoot: string): Promise<void>;
+/**
+ * Returns `true` when an active rebase session exists on disk.
+ */
+export declare function hasActiveRebaseSession(projectRoot: string): Promise<boolean>;

package/dist/src/core/rebase-session.js

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Rebase session persistence for multi-patch ESR version upgrades.
+ * Session state is stored at `.fireforge/rebase-session.json` and
+ * survives across CLI invocations so the user can fix conflicts and
+ * resume with `fireforge rebase --continue`.
+ */
+import { join } from 'node:path';
+import { pathExists, readJson, removeFile, writeJson } from '../utils/fs.js';
+import { isArray, isObject, isString } from '../utils/validation.js';
+import { getProjectPaths } from './config-paths.js';
+import { createSiblingLockPath, withFileLock } from './file-lock.js';
+// ── Helpers ──
+const SESSION_FILENAME = 'rebase-session.json';
+function sessionPath(projectRoot) {
+    return join(getProjectPaths(projectRoot).fireforgeDir, SESSION_FILENAME);
+}
+function isValidSession(data) {
+    if (!isObject(data))
+        return false;
+    return (isString(data['startedAt']) &&
+        isString(data['fromVersion']) &&
+        isString(data['toVersion']) &&
+        isString(data['preRebaseCommit']) &&
+        isArray(data['patches']) &&
+        typeof data['currentIndex'] === 'number');
+}
+// ── Public API ──
+/**
+ * Loads an existing rebase session, or returns `null` if none exists.
+ */
+export async function loadRebaseSession(projectRoot) {
+    const path = sessionPath(projectRoot);
+    if (!(await pathExists(path)))
+        return null;
+    const data = await readJson(path);
+    if (!isValidSession(data))
+        return null;
+    return data;
+}
+/**
+ * Persists a rebase session atomically.
+ */
+export async function saveRebaseSession(projectRoot, session) {
+    const path = sessionPath(projectRoot);
+    await withFileLock(createSiblingLockPath(path, '.rebase-session.lock'), async () => {
+        await writeJson(path, session);
+    });
+}
+/**
+ * Removes the rebase session file.
+ */
+export async function clearRebaseSession(projectRoot) {
+    const path = sessionPath(projectRoot);
+    if (await pathExists(path)) {
+        await removeFile(path);
+    }
+}
+/**
+ * Returns `true` when an active rebase session exists on disk.
+ */
+export async function hasActiveRebaseSession(projectRoot) {
+    return pathExists(sessionPath(projectRoot));
+}
+//# sourceMappingURL=rebase-session.js.map

package/dist/src/core/register-browser-content.d.ts

@@ -0,0 +1,11 @@
+/**
+ * JS/content registration in browser/base/jar.mn.
+ */
+import type { RegisterResult } from './manifest-register.js';
+/**
+ * Registers a JS/content file in browser/base/jar.mn.
+ *
+ * Entry format (8-space indent):
+ *         content/browser/{name}.js    (content/{name}.js)
+ */
+export declare function registerBrowserContent(engineDir: string, fileName: string, after?: string, sourcePath?: string, dryRun?: boolean): Promise<RegisterResult>;

package/dist/src/core/register-browser-content.js

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * JS/content registration in browser/base/jar.mn.
+ */
+import { join } from 'node:path';
+import { GeneralError } from '../errors/base.js';
+import { pathExists, readText, writeText } from '../utils/fs.js';
+import { findAlphabeticalPosition, findAlphabeticalTokenPosition } from './manifest-helpers.js';
+import { tokenizeJarMn } from './manifest-tokenizers.js';
+import { withParserFallback } from './parser-fallback.js';
+/**
+ * Tokenizer-based implementation for browser content registration.
+ */
+function registerBrowserContentTokenized(content, fileName, entry, after) {
+    const lines = content.split('\n');
+    const tokens = tokenizeJarMn(lines);
+    let afterFallback = false;
+    let insertIndex;
+    let previousEntry;
+    if (after) {
+        const afterPattern = new RegExp(`(?:^|/)${after.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?:\\s|\\)|$)`);
+        const afterToken = tokens.find((t) => afterPattern.test(t.raw));
+        if (afterToken) {
+            insertIndex = afterToken.lineIndex + 1;
+            previousEntry = afterToken.raw.trim();
+        }
+        else {
+            afterFallback = true;
+            ({ insertIndex, previousEntry } = findAlphabeticalTokenPosition(tokens, /content\/browser\/([^\s]+)/, fileName));
+        }
+    }
+    else {
+        ({ insertIndex, previousEntry } = findAlphabeticalTokenPosition(tokens, /content\/browser\/([^\s]+)/, fileName));
+    }
+    if (insertIndex === -1) {
+        throw new GeneralError('Could not find content/browser/ section in browser/base/jar.mn');
+    }
+    lines.splice(insertIndex, 0, entry);
+    return { result: lines.join('\n'), previousEntry, afterFallback };
+}
+/**
+ * Legacy line-based implementation preserved as fallback.
+ */
+function legacyRegisterBrowserContent(content, fileName, entry, after) {
+    const lines = content.split('\n');
+    let afterFallback = false;
+    const extractKey = (line) => {
+        const match = /content\/browser\/([^\s]+)/.exec(line);
+        return match?.[1];
+    };
+    let sectionStart = -1;
+    let sectionEnd = lines.length;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line === undefined)
+            continue;
+        if (/^\s+content\/browser\//.test(line)) {
+            if (sectionStart === -1)
+                sectionStart = i;
+            sectionEnd = i + 1;
+        }
+    }
+    if (sectionStart === -1) {
+        throw new GeneralError('Could not find content/browser/ section in browser/base/jar.mn');
+    }
+    let insertIndex;
+    let previousEntry;
+    if (after) {
+        const afterLineIdx = lines.findIndex((l) => l.includes(after));
+        if (afterLineIdx !== -1) {
+            insertIndex = afterLineIdx + 1;
+            previousEntry = lines[afterLineIdx]?.trim();
+        }
+        else {
+            afterFallback = true;
+            ({ insertIndex, previousEntry } = findAlphabeticalPosition(lines, sectionStart, sectionEnd, fileName, extractKey));
+        }
+    }
+    else {
+        ({ insertIndex, previousEntry } = findAlphabeticalPosition(lines, sectionStart, sectionEnd, fileName, extractKey));
+    }
+    lines.splice(insertIndex, 0, entry);
+    return { result: lines.join('\n'), previousEntry, afterFallback };
+}
+/**
+ * Registers a JS/content file in browser/base/jar.mn.
+ *
+ * Entry format (8-space indent):
+ *         content/browser/{name}.js    (content/{name}.js)
+ */
+export async function registerBrowserContent(engineDir, fileName, after, sourcePath, dryRun = false) {
+    const manifest = 'browser/base/jar.mn';
+    const manifestPath = join(engineDir, manifest);
+    if (!(await pathExists(manifestPath))) {
+        throw new GeneralError(`Manifest not found: ${manifest}`);
+    }
+    const source = (sourcePath ?? `content/${fileName}`).replace(/\\/g, '/');
+    const entry = `        content/browser/${fileName}    (${source})`.replace(/\\/g, '/');
+    const content = await readText(manifestPath);
+    // Idempotency check
+    if (content.includes(`content/browser/${fileName}`)) {
+        return { manifest, entry, skipped: true };
+    }
+    const { value } = withParserFallback(() => registerBrowserContentTokenized(content, fileName, entry, after), () => legacyRegisterBrowserContent(content, fileName, entry, after), manifest);
+    if (!dryRun) {
+        await writeText(manifestPath, value.result);
+    }
+    return {
+        manifest,
+        entry,
+        previousEntry: value.previousEntry,
+        skipped: false,
+        afterFallback: value.afterFallback,
+    };
+}
+//# sourceMappingURL=register-browser-content.js.map

package/dist/src/core/register-module.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Module registration in browser/modules/{binaryName}/moz.build.
+ */
+import type { RegisterResult } from './manifest-register.js';
+/**
+ * Registers a module in browser/modules/{binaryName}/moz.build.
+ *
+ * Entry format:
+ *     "{name}.sys.mjs",
+ */
+export declare function registerFireForgeModule(engineDir: string, fileName: string, moduleDir: string, dryRun?: boolean): Promise<RegisterResult>;

package/dist/src/core/register-module.js

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Module registration in browser/modules/{binaryName}/moz.build.
+ */
+import { join } from 'node:path';
+import { GeneralError } from '../errors/base.js';
+import { pathExists, readText, writeText } from '../utils/fs.js';
+import { findAlphabeticalMozBuildPosition, findAlphabeticalPosition } from './manifest-helpers.js';
+import { tokenizeMozBuildList } from './manifest-tokenizers.js';
+import { withParserFallback } from './parser-fallback.js';
+/**
+ * Tokenizer-based implementation for module registration.
+ */
+function registerFireForgeModuleTokenized(content, fileName, entry) {
+    const lines = content.split('\n');
+    const listResult = tokenizeMozBuildList(lines, /EXTRA_JS_MODULES/);
+    if (!listResult) {
+        throw new GeneralError('Could not find EXTRA_JS_MODULES in moz.build');
+    }
+    const { insertIndex, previousEntry } = findAlphabeticalMozBuildPosition(listResult.tokens, fileName);
+    lines.splice(insertIndex, 0, entry);
+    return { result: lines.join('\n'), previousEntry };
+}
+/**
+ * Legacy line-based implementation preserved as fallback.
+ */
+function legacyRegisterFireForgeModule(content, fileName, entry, moduleDir) {
+    const lines = content.split('\n');
+    const extractKey = (line) => {
+        const match = /^\s+"([^"]+\.sys\.mjs)"/.exec(line);
+        return match?.[1];
+    };
+    let sectionStart = -1;
+    let sectionEnd = lines.length;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line === undefined)
+            continue;
+        if (/^\s+"[^"]+\.sys\.mjs"/.test(line)) {
+            if (sectionStart === -1)
+                sectionStart = i;
+            sectionEnd = i + 1;
+        }
+    }
+    if (sectionStart === -1) {
+        throw new GeneralError(`Could not find module list section in ${moduleDir}/moz.build`);
+    }
+    const { insertIndex, previousEntry } = findAlphabeticalPosition(lines, sectionStart, sectionEnd, fileName, extractKey);
+    lines.splice(insertIndex, 0, entry);
+    return { result: lines.join('\n'), previousEntry };
+}
+/**
+ * Registers a module in browser/modules/{binaryName}/moz.build.
+ *
+ * Entry format:
+ *     "{name}.sys.mjs",
+ */
+export async function registerFireForgeModule(engineDir, fileName, moduleDir, dryRun = false) {
+    const manifest = `${moduleDir}/moz.build`;
+    const manifestPath = join(engineDir, manifest);
+    if (!(await pathExists(manifestPath))) {
+        throw new GeneralError(`Manifest not found: ${manifest}`);
+    }
+    const entry = `    "${fileName}",`.replace(/\\/g, '/');
+    const content = await readText(manifestPath);
+    // Idempotency check
+    if (content.includes(`"${fileName}"`)) {
+        return { manifest, entry, skipped: true };
+    }
+    const { value } = withParserFallback(() => registerFireForgeModuleTokenized(content, fileName, entry), () => legacyRegisterFireForgeModule(content, fileName, entry, moduleDir), manifest);
+    if (!dryRun) {
+        await writeText(manifestPath, value.result);
+    }
+    return { manifest, entry, previousEntry: value.previousEntry, skipped: false };
+}
+//# sourceMappingURL=register-module.js.map

package/dist/src/core/register-shared-css.d.ts

@@ -0,0 +1,11 @@
+/**
+ * CSS registration in browser/themes/shared/jar.inc.mn.
+ */
+import type { RegisterResult } from './manifest-register.js';
+/**
+ * Registers a CSS file in browser/themes/shared/jar.inc.mn.
+ *
+ * Entry format:
+ *   skin/classic/browser/{name}.css    (../shared/{name}.css)
+ */
+export declare function registerSharedCSS(engineDir: string, fileName: string, after?: string, dryRun?: boolean): Promise<RegisterResult>;

package/dist/src/core/register-shared-css.js

@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * CSS registration in browser/themes/shared/jar.inc.mn.
+ */
+import { basename, join } from 'node:path';
+import { GeneralError } from '../errors/base.js';
+import { pathExists, readText, writeText } from '../utils/fs.js';
+import { findAlphabeticalPosition, findAlphabeticalTokenPosition } from './manifest-helpers.js';
+import { tokenizeJarMn } from './manifest-tokenizers.js';
+import { withParserFallback } from './parser-fallback.js';
+/**
+ * Tokenizer-based implementation for shared CSS registration.
+ */
+function registerSharedCSSTokenized(content, name, entry, after) {
+    const lines = content.split('\n');
+    const tokens = tokenizeJarMn(lines);
+    let afterFallback = false;
+    let insertIndex;
+    let previousEntry;
+    if (after) {
+        const afterPattern = new RegExp(`(?:^|/)${after.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?:\\s|\\)|$)`);
+        const afterToken = tokens.find((t) => afterPattern.test(t.raw));
+        if (afterToken) {
+            insertIndex = afterToken.lineIndex + 1;
+            previousEntry = afterToken.raw.trim();
+        }
+        else {
+            afterFallback = true;
+            ({ insertIndex, previousEntry } = findAlphabeticalTokenPosition(tokens, /skin\/classic\/browser\/([^.]+)\.css/, name));
+        }
+    }
+    else {
+        ({ insertIndex, previousEntry } = findAlphabeticalTokenPosition(tokens, /skin\/classic\/browser\/([^.]+)\.css/, name));
+    }
+    if (insertIndex === -1) {
+        throw new GeneralError('Could not find skin/classic/browser/ section in jar.inc.mn');
+    }
+    lines.splice(insertIndex, 0, entry);
+    return { result: lines.join('\n'), insertIndex, previousEntry, afterFallback };
+}
+/**
+ * Legacy line-based implementation preserved as fallback.
+ */
+function legacyRegisterSharedCSS(content, name, entry, after) {
+    const lines = content.split('\n');
+    let afterFallback = false;
+    const extractKey = (line) => {
+        const match = /skin\/classic\/browser\/([^.]+)\.css/.exec(line);
+        return match?.[1];
+    };
+    let insertIndex;
+    let previousEntry;
+    // Find skin/classic/browser/ section boundaries
+    let sectionStart = -1;
+    let sectionEnd = lines.length;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line === undefined)
+            continue;
+        if (/skin\/classic\/browser\//.test(line)) {
+            if (sectionStart === -1)
+                sectionStart = i;
+            sectionEnd = i + 1;
+        }
+    }
+    if (sectionStart === -1) {
+        throw new GeneralError('Could not find skin/classic/browser/ section in jar.inc.mn');
+    }
+    if (after) {
+        const afterLineIdx = lines.findIndex((l) => l.includes(after));
+        if (afterLineIdx !== -1) {
+            insertIndex = afterLineIdx + 1;
+            previousEntry = lines[afterLineIdx]?.trim();
+        }
+        else {
+            afterFallback = true;
+            ({ insertIndex, previousEntry } = findAlphabeticalPosition(lines, sectionStart, sectionEnd, name, extractKey));
+        }
+    }
+    else {
+        ({ insertIndex, previousEntry } = findAlphabeticalPosition(lines, sectionStart, sectionEnd, name, extractKey));
+    }
+    lines.splice(insertIndex, 0, entry);
+    return { result: lines.join('\n'), previousEntry, afterFallback };
+}
+/**
+ * Registers a CSS file in browser/themes/shared/jar.inc.mn.
+ *
+ * Entry format:
+ *   skin/classic/browser/{name}.css    (../shared/{name}.css)
+ */
+export async function registerSharedCSS(engineDir, fileName, after, dryRun = false) {
+    const manifest = 'browser/themes/shared/jar.inc.mn';
+    const manifestPath = join(engineDir, manifest);
+    if (!(await pathExists(manifestPath))) {
+        throw new GeneralError(`Manifest not found: ${manifest}`);
+    }
+    const name = basename(fileName, '.css');
+    const entry = `  skin/classic/browser/${name}.css    (../shared/${name}.css)`.replace(/\\/g, '/');
+    const content = await readText(manifestPath);
+    // Idempotency check
+    if (content.includes(`skin/classic/browser/${name}.css`)) {
+        return { manifest, entry, skipped: true };
+    }
+    const { value } = withParserFallback(() => registerSharedCSSTokenized(content, name, entry, after), () => legacyRegisterSharedCSS(content, name, entry, after), manifest);
+    if (!dryRun) {
+        await writeText(manifestPath, value.result);
+    }
+    return {
+        manifest,
+        entry,
+        previousEntry: value.previousEntry,
+        skipped: false,
+        afterFallback: value.afterFallback,
+    };
+}
+//# sourceMappingURL=register-shared-css.js.map

package/dist/src/core/register-test-manifest.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Test manifest registration in browser/base/moz.build.
+ */
+import type { RegisterResult } from './manifest-register.js';
+/**
+ * Registers a test manifest (browser.toml) in browser/base/moz.build.
+ *
+ * Entry format:
+ *     "content/test/{dir}/browser.toml",
+ */
+export declare function registerTestManifest(engineDir: string, testDir: string, dryRun?: boolean): Promise<RegisterResult>;
+/**
+ * Deregisters a test manifest (browser.toml) from browser/base/moz.build.
+ * @param engineDir - Path to the engine directory
+ * @param testDir - Test directory name (e.g. 'mybrowser')
+ * @returns Whether the entry was removed
+ */
+export declare function deregisterTestManifest(engineDir: string, testDir: string): Promise<boolean>;