@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/rebase-dry-run.d.ts

@@ -1,48 +0,0 @@
-/** A patch to replay, in queue order. */
-export interface DryRunPatch {
-    filename: string;
-    path: string;
-}
-/** What the real rebase loop would do with one patch. */
-export type DryRunVerdict = {
-    filename: string;
-    outcome: 'clean';
-} | {
-    filename: string;
-    outcome: 'reduced-context';
-    step: number;
-    contextArg: string;
-} | {
-    filename: string;
-    outcome: 'reject';
-    /** Files git named as not applying. Empty when stderr named none. */
-    files: string[];
-    /** git's own explanation, from the exact-context `--check`. */
-    detail: string;
-};
-/** Result of a full queue replay. */
-export interface DryRunReplay {
-    verdicts: DryRunVerdict[];
-    /**
-     * Index of the first reject, or `undefined`. Verdicts after it were
-     * computed without that patch applied, so a reject there may cascade from
-     * the earlier one rather than be a conflict of its own.
-     */
-    firstRejectIndex: number | undefined;
-}
-/**
- * Parses the file names out of `git apply --check` failure output. Git
- * reports a context mismatch as `error: patch failed: <file>:<line>` and
- * `error: <file>: patch does not apply`, and a missing or pre-existing
- * target as `error: <file>: does not exist in index` /
- * `error: <file>: already exists in index`.
- */
-export declare function parseApplyCheckFailures(stderr: string): string[];
-/**
- * Replays `patches` onto the engine's HEAD tree in a private index.
- * @param engineDir - Engine repository root
- * @param patches - Patches in queue order
- * @param maxFuzz - Maximum context-reduction steps, as for the real rebase
- * @returns One verdict per patch
- */
-export declare function replayQueueIndexOnly(engineDir: string, patches: readonly DryRunPatch[], maxFuzz: number): Promise<DryRunReplay>;

package/dist/src/core/rebase-dry-run.js

@@ -1,105 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `rebase --dry-run`: replays the patch queue against the engine's base
- * commit without touching `engine/`.
- *
- * The replay runs on a private index seeded from HEAD (`GIT_INDEX_FILE`
- * plus `git read-tree HEAD`) and applies each patch there with
- * `git apply --cached`, in queue order, so a later patch sees what the
- * earlier ones did, exactly as the real loop's worktree does. Each patch
- * walks the same context-reduction ladder as {@link applyPatchWithFuzz}.
- * The worktree and the real index are never written. The private index is
- * deleted when the replay ends.
- */
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { GitError } from '../errors/git.js';
-import { exec } from '../utils/process.js';
-import { ensureGit } from './git-base.js';
-import { assertValidMaxFuzz, contextReductionSteps } from './patch-apply-fuzz.js';
-/**
- * Parses the file names out of `git apply --check` failure output. Git
- * reports a context mismatch as `error: patch failed: <file>:<line>` and
- * `error: <file>: patch does not apply`, and a missing or pre-existing
- * target as `error: <file>: does not exist in index` /
- * `error: <file>: already exists in index`.
- */
-export function parseApplyCheckFailures(stderr) {
-    const files = new Set();
-    for (const line of stderr.split('\n')) {
-        const failed = /^error: patch failed: (.+):\d+$/.exec(line);
-        if (failed?.[1]) {
-            files.add(failed[1]);
-            continue;
-        }
-        const named = /^error: (.+?): (?:patch does not apply|does not exist in index|already exists in index)$/.exec(line);
-        if (named?.[1])
-            files.add(named[1]);
-    }
-    return [...files];
-}
-/**
- * Replays `patches` onto the engine's HEAD tree in a private index.
- * @param engineDir - Engine repository root
- * @param patches - Patches in queue order
- * @param maxFuzz - Maximum context-reduction steps, as for the real rebase
- * @returns One verdict per patch
- */
-export async function replayQueueIndexOnly(engineDir, patches, maxFuzz) {
-    assertValidMaxFuzz(maxFuzz);
-    await ensureGit();
-    const scratch = await mkdtemp(join(tmpdir(), 'fireforge-rebase-dry-run-'));
-    const env = { GIT_INDEX_FILE: join(scratch, 'index') };
-    try {
-        const seeded = await exec('git', ['read-tree', 'HEAD'], { cwd: engineDir, env });
-        if (seeded.exitCode !== 0) {
-            throw new GitError(seeded.stderr.trim() || 'Could not seed a private index from HEAD', 'read-tree HEAD');
-        }
-        const ladder = contextReductionSteps(maxFuzz);
-        const verdicts = [];
-        let firstRejectIndex;
-        for (const patch of patches) {
-            let verdict;
-            let exactFailure = '';
-            for (const [step, contextArgs] of ladder.entries()) {
-                const check = await exec('git', ['apply', '--cached', '--check', ...contextArgs, '--', patch.path], { cwd: engineDir, env });
-                if (check.exitCode !== 0) {
-                    if (step === 0)
-                        exactFailure = check.stderr;
-                    continue;
-                }
-                const apply = await exec('git', ['apply', '--cached', ...contextArgs, '--', patch.path], {
-                    cwd: engineDir,
-                    env,
-                });
-                if (apply.exitCode !== 0)
-                    continue;
-                verdict =
-                    step === 0
-                        ? { filename: patch.filename, outcome: 'clean' }
-                        : {
-                            filename: patch.filename,
-                            outcome: 'reduced-context',
-                            step,
-                            contextArg: contextArgs[0] ?? '',
-                        };
-                break;
-            }
-            if (verdict === undefined) {
-                verdict = {
-                    filename: patch.filename,
-                    outcome: 'reject',
-                    files: parseApplyCheckFailures(exactFailure),
-                    detail: exactFailure.trim(),
-                };
-                firstRejectIndex ??= verdicts.length;
-            }
-            verdicts.push(verdict);
-        }
-        return { verdicts, firstRejectIndex };
-    }
-    finally {
-        await rm(scratch, { recursive: true, force: true });
-    }
-}

package/dist/src/core/rebase-from-version.d.ts

@@ -1,46 +0,0 @@
-/**
- * Resolves the "from" side of a `fireforge rebase` source move.
- *
- * The rebase target is the working `firefox.version` pin, which
- * `fireforge source set` has already moved. The tree the queue was last
- * applied to is the previous pin: the `firefox` block of `fireforge.json`
- * as committed in the project repository. Patch `sourceVersion` stamps are
- * a poor stand-in: patches untouched since an older hop keep their older
- * stamp, so the oldest stamp can trail the real previous tree by several
- * releases. The stamps are only the fallback, for a project that is not a
- * git checkout or whose committed pin already equals the target.
- */
-import type { FirefoxProduct } from '../types/config.js';
-/** A `firefox.version` / `firefox.product` pair. */
-export interface FirefoxPin {
-    version: string;
-    product?: FirefoxProduct;
-}
-/** Where the rebase's "from" label came from. */
-export interface RebaseFromVersion extends FirefoxPin {
-    /** `committed-pin`: the project's committed `fireforge.json`; `patch-stamps`: the oldest stamp. */
-    origin: 'committed-pin' | 'patch-stamps';
-}
-/** Tally of the queue's `sourceVersion` stamps, oldest first. */
-export interface PatchStampSpread {
-    versions: string[];
-    counts: Map<string, number>;
-}
-/**
- * Reads the `firefox` pin from `fireforge.json` as committed at the project
- * repository's HEAD. `HEAD:./fireforge.json` resolves relative to the
- * project root, so a project nested inside a larger repository works too.
- * Returns `undefined` when there is no repository, no commit, no committed
- * config, or no valid pin in it.
- */
-export declare function readCommittedFirefoxPin(projectRoot: string): Promise<FirefoxPin | undefined>;
-/** Counts the queue's stamps and orders them semantically (a lexical sort put 153.10.0esr before 153.2.0esr). */
-export declare function tallyPatchStamps(stamps: readonly string[]): PatchStampSpread;
-/** `"317 at 153.0esr, 5 at 153.3.0esr"`. */
-export declare function formatPatchStampSpread(spread: PatchStampSpread): string;
-/**
- * Picks the rebase's "from": the committed pin when it differs from the
- * target, otherwise the oldest patch stamp (`oldestStampProduct` is that
- * stamp's recorded product, when any patch carries one).
- */
-export declare function resolveRebaseFromVersion(target: string, committed: FirefoxPin | undefined, spread: PatchStampSpread, oldestStampProduct: FirefoxProduct | undefined): RebaseFromVersion;

package/dist/src/core/rebase-from-version.js

@@ -1,71 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Resolves the "from" side of a `fireforge rebase` source move.
- *
- * The rebase target is the working `firefox.version` pin, which
- * `fireforge source set` has already moved. The tree the queue was last
- * applied to is the previous pin: the `firefox` block of `fireforge.json`
- * as committed in the project repository. Patch `sourceVersion` stamps are
- * a poor stand-in: patches untouched since an older hop keep their older
- * stamp, so the oldest stamp can trail the real previous tree by several
- * releases. The stamps are only the fallback, for a project that is not a
- * git checkout or whose committed pin already equals the target.
- */
-import { exec } from '../utils/process.js';
-import { compareFirefoxVersions, isObject, isValidFirefoxProduct, isValidFirefoxVersion, } from '../utils/validation.js';
-/**
- * Reads the `firefox` pin from `fireforge.json` as committed at the project
- * repository's HEAD. `HEAD:./fireforge.json` resolves relative to the
- * project root, so a project nested inside a larger repository works too.
- * Returns `undefined` when there is no repository, no commit, no committed
- * config, or no valid pin in it.
- */
-export async function readCommittedFirefoxPin(projectRoot) {
-    const result = await exec('git', ['show', 'HEAD:./fireforge.json'], { cwd: projectRoot }).catch(() => undefined);
-    if (result?.exitCode !== 0)
-        return undefined;
-    let parsed;
-    try {
-        parsed = JSON.parse(result.stdout);
-    }
-    catch {
-        return undefined;
-    }
-    const firefox = isObject(parsed) ? parsed['firefox'] : undefined;
-    if (!isObject(firefox))
-        return undefined;
-    const version = firefox['version'];
-    if (typeof version !== 'string' || !isValidFirefoxVersion(version))
-        return undefined;
-    const product = firefox['product'];
-    return typeof product === 'string' && isValidFirefoxProduct(product)
-        ? { version, product }
-        : { version };
-}
-/** Counts the queue's stamps and orders them semantically (a lexical sort put 153.10.0esr before 153.2.0esr). */
-export function tallyPatchStamps(stamps) {
-    const counts = new Map();
-    for (const stamp of stamps)
-        counts.set(stamp, (counts.get(stamp) ?? 0) + 1);
-    return { versions: [...counts.keys()].sort(compareFirefoxVersions), counts };
-}
-/** `"317 at 153.0esr, 5 at 153.3.0esr"`. */
-export function formatPatchStampSpread(spread) {
-    return spread.versions.map((v) => `${spread.counts.get(v)} at ${v}`).join(', ');
-}
-/**
- * Picks the rebase's "from": the committed pin when it differs from the
- * target, otherwise the oldest patch stamp (`oldestStampProduct` is that
- * stamp's recorded product, when any patch carries one).
- */
-export function resolveRebaseFromVersion(target, committed, spread, oldestStampProduct) {
-    if (committed !== undefined && committed.version !== target) {
-        return { ...committed, origin: 'committed-pin' };
-    }
-    const oldest = spread.versions[0] ?? target;
-    return {
-        version: oldest,
-        ...(oldestStampProduct !== undefined ? { product: oldestStampProduct } : {}),
-        origin: 'patch-stamps',
-    };
-}

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

@@ -1,100 +0,0 @@
-/**
- * Rebase session persistence for multi-patch Firefox source 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 type { FirefoxProduct } from '../types/config.js';
-export type RebasePatchStatus = 'pending' | 'applied-clean' | 'applied-fuzz' | 'failed' | 'resolved' | 'skipped';
-/**
- * One patch's outcome in a rebase session.
- *
- * A discriminated union on `status`, so a payload can only be present on the
- * status it belongs to. A flat-optionals shape makes
- * `{ status: 'resolved', error, conflictingFiles }` representable, and
- * `rebase --continue` will write it, flipping the status without clearing
- * the failure payload, then persisting that to the session file.
- *
- * The on-disk validator (`isValidPatchEntry`) is not tightened to
- * match, on purpose. The session file carries no schema version, so a stricter
- * validator would reject an older file mid-rebase, where the only remedies
- * discard the operator's in-progress conflict resolution. Instead
- * {@link normalizeEntry} drops payload that does not belong to the status on
- * read, so an older file loads and is corrected rather than refused.
- */
-export type RebasePatchEntry = {
-    filename: string;
-} & ({
-    status: 'pending' | 'applied-clean' | 'skipped' | 'resolved';
-} | {
-    status: 'applied-fuzz';
-    fuzzFactor: number;
-} | {
-    status: 'failed';
-    error?: string;
-    conflictingFiles?: string[];
-});
-export interface RebaseSession {
-    /** ISO timestamp when the rebase started. */
-    startedAt: string;
-    /** Source product being rebased FROM. */
-    fromProduct?: FirefoxProduct;
-    /** Source product being rebased TO. */
-    toProduct?: FirefoxProduct;
-    /** Source version being rebased FROM. */
-    fromVersion: string;
-    /** Source 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;
-}
-/** Absolute path of the session file, for messages that must name it. */
-export declare function getRebaseSessionPath(projectRoot: string): string;
-/**
- * Outcome of reading the session file, following the {@link LockOwner}
- * discriminated-union form rather than collapsing three states into `null`.
- *
- * Distinguishing `present: false` from `present: true, valid: false` is
- * important. Collapsing both to `null` while reporting liveness from
- * `pathExists` alone wedges the operator in a closed cycle: `rebase` says
- * "already in progress, use --continue or --abort", and both of those say
- * "no rebase session in progress", with no CLI path deleting the file and no
- * message naming it.
- */
-export type RebaseSessionRead = {
-    present: false;
-} | {
-    present: true;
-    valid: true;
-    session: RebaseSession;
-} | {
-    present: true;
-    valid: false;
-    reason: string;
-};
-/**
- * Reads the session file, reporting absent, valid, and corrupt as three
- * distinct outcomes. Never throws for a malformed file: `readJson` calls
- * `JSON.parse` with no guard of its own, so an interrupted write would
- * otherwise surface a raw `SyntaxError` out of `--continue`/`--abort`.
- *
- * A single read determines liveness and validity: only ENOENT/ENOTDIR from
- * that read mean `absent`. A pathExists pre-probe both races deletion (a
- * file removed between probe and read misreports an absent session as
- * corrupt) and swallows EACCES (an unreadable `.fireforge/` misreports a
- * session as absent). It is the same failure `readTreeMarker` avoids for
- * tree markers.
- */
-export declare function readRebaseSession(projectRoot: string): Promise<RebaseSessionRead>;
-/**
- * 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>;

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

@@ -1,174 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Rebase session persistence for multi-patch Firefox source 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 { getNodeErrorCode, toError } from '../utils/errors.js';
-import { pathExists, readJson, removeFile, writeJson } from '../utils/fs.js';
-import { isArray, isNumber, isObject, isString, isValidFirefoxProduct, isValidFirefoxVersion, } from '../utils/validation.js';
-import { getProjectPaths } from './config-paths.js';
-import { createSiblingLockPath, withFileLock } from './file-lock.js';
-// ── Helpers ──
-const SESSION_FILENAME = 'rebase-session.json';
-/** Absolute path of the session file, for messages that must name it. */
-export function getRebaseSessionPath(projectRoot) {
-    return join(getProjectPaths(projectRoot).fireforgeDir, SESSION_FILENAME);
-}
-const REBASE_PATCH_STATUSES = [
-    'pending',
-    'applied-clean',
-    'applied-fuzz',
-    'failed',
-    'resolved',
-    'skipped',
-];
-/** Validates one `patches[]` element to its declared shape. */
-/**
- * Drops payload that does not belong to an entry's status.
- *
- * Applied on read so a session whose `resolved` entry still carries
- * `error`/`conflictingFiles` loads cleanly and is corrected, instead of being refused by a
- * stricter validator mid-rebase.
- *
- * @param entry - A structurally valid entry, possibly carrying stale payload
- * @returns The entry with only the fields its status permits
- */
-function normalizeEntry(entry) {
-    if (entry.status === 'applied-fuzz') {
-        return { filename: entry.filename, status: 'applied-fuzz', fuzzFactor: entry.fuzzFactor };
-    }
-    if (entry.status === 'failed') {
-        return {
-            filename: entry.filename,
-            status: 'failed',
-            ...(entry.error !== undefined ? { error: entry.error } : {}),
-            ...(entry.conflictingFiles !== undefined ? { conflictingFiles: entry.conflictingFiles } : {}),
-        };
-    }
-    return { filename: entry.filename, status: entry.status };
-}
-function isValidPatchEntry(value) {
-    if (!isObject(value))
-        return false;
-    if (!isString(value['filename']) || value['filename'].length === 0)
-        return false;
-    if (!REBASE_PATCH_STATUSES.includes(value['status']))
-        return false;
-    if (value['fuzzFactor'] !== undefined && !isNumber(value['fuzzFactor']))
-        return false;
-    if (value['error'] !== undefined && !isString(value['error']))
-        return false;
-    const conflicting = value['conflictingFiles'];
-    if (conflicting !== undefined && (!isArray(conflicting) || !conflicting.every(isString))) {
-        return false;
-    }
-    return true;
-}
-/** Optional product field: absent is legal, present must be a real product. */
-function isValidOptionalProduct(value) {
-    return value === undefined || (isString(value) && isValidFirefoxProduct(value));
-}
-/**
- * Validates a session file against the shape the rebase commands actually
- * consume, not merely against broad field types.
- *
- * A looser predicate that checks six `typeof`s and nothing else admits
- * sessions the resume path then acts on. `patches: [null]` reaches
- * `patch-loop.ts`, which reads `.filename` off each entry and hands it to
- * `stampPatchVersions`. A `currentIndex` of `NaN` (legal for
- * `typeof === 'number'`) makes the resume loop run zero iterations and
- * report success. A negative one indexes out of range in `continue.ts`.
- * `toVersion: ""` passes `isString` and is stamped verbatim onto every
- * Furnace override's `baseVersion`. `fromProduct`/`toProduct` go unchecked
- * despite being typed `FirefoxProduct`.
- *
- * The session file is written only by `rebase/index.ts` from validated CLI
- * and config values, so every one of these is a corrupt-file or hand-edit
- * case, which is exactly what this predicate exists to catch.
- */
-function isValidSession(data) {
-    if (!isObject(data))
-        return false;
-    if (!isString(data['startedAt']) || Number.isNaN(Date.parse(data['startedAt'])))
-        return false;
-    // 4 is git's own minimum abbreviation length. 40/64 are full SHA-1/SHA-256.
-    if (!isString(data['preRebaseCommit']) || !/^[0-9a-f]{4,64}$/i.test(data['preRebaseCommit'])) {
-        return false;
-    }
-    if (!isString(data['fromVersion']) || !isValidFirefoxVersion(data['fromVersion']))
-        return false;
-    if (!isString(data['toVersion']) || !isValidFirefoxVersion(data['toVersion']))
-        return false;
-    if (!isValidOptionalProduct(data['fromProduct']))
-        return false;
-    if (!isValidOptionalProduct(data['toProduct']))
-        return false;
-    const patches = data['patches'];
-    if (!isArray(patches) || !patches.every(isValidPatchEntry))
-        return false;
-    // `<= patches.length` because the resume point legally sits one past the
-    // last entry once every patch has been processed.
-    const currentIndex = data['currentIndex'];
-    if (!isNumber(currentIndex) || !Number.isInteger(currentIndex))
-        return false;
-    return currentIndex >= 0 && currentIndex <= patches.length;
-}
-/**
- * Reads the session file, reporting absent, valid, and corrupt as three
- * distinct outcomes. Never throws for a malformed file: `readJson` calls
- * `JSON.parse` with no guard of its own, so an interrupted write would
- * otherwise surface a raw `SyntaxError` out of `--continue`/`--abort`.
- *
- * A single read determines liveness and validity: only ENOENT/ENOTDIR from
- * that read mean `absent`. A pathExists pre-probe both races deletion (a
- * file removed between probe and read misreports an absent session as
- * corrupt) and swallows EACCES (an unreadable `.fireforge/` misreports a
- * session as absent). It is the same failure `readTreeMarker` avoids for
- * tree markers.
- */
-export async function readRebaseSession(projectRoot) {
-    const path = getRebaseSessionPath(projectRoot);
-    let data;
-    try {
-        data = await readJson(path);
-    }
-    catch (error) {
-        const code = getNodeErrorCode(error);
-        if (code === 'ENOENT' || code === 'ENOTDIR')
-            return { present: false };
-        return { present: true, valid: false, reason: toError(error).message };
-    }
-    if (!isValidSession(data)) {
-        return { present: true, valid: false, reason: 'the file is not a valid rebase session' };
-    }
-    // Normalize on read: a session can carry a failure's
-    // `error`/`conflictingFiles` on an entry whose status has since been
-    // flipped to `resolved`. Correcting it here is what lets the validator
-    // stay permissive, so such an in-flight rebase still loads.
-    return {
-        present: true,
-        valid: true,
-        session: { ...data, patches: data.patches.map(normalizeEntry) },
-    };
-}
-/**
- * Persists a rebase session atomically.
- */
-export async function saveRebaseSession(projectRoot, session) {
-    const path = getRebaseSessionPath(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 = getRebaseSessionPath(projectRoot);
-    if (await pathExists(path)) {
-        await removeFile(path);
-    }
-}

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

@@ -1,11 +0,0 @@
-/**
- * JS/content registration in browser/base/jar.mn.
- */
-import type { RegisterResult } from './register-result.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

@@ -1,52 +0,0 @@
-// 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 { normalizePathSlashes } from '../utils/paths.js';
-import { insertJarMnEntry } from './moz-manifest-helpers.js';
-/**
- * Tokenizer-based implementation for browser content registration.
- */
-function registerBrowserContentTokenized(content, fileName, entry, after) {
-    const { result, previousEntry, afterFallback } = insertJarMnEntry(content, entry, {
-        sortPattern: /content\/browser\/([^\s]+)/,
-        sortKey: fileName,
-        missingSectionMessage: 'Could not find content/browser/ section in browser/base/jar.mn',
-        after,
-    });
-    return { result, 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 = normalizePathSlashes(sourcePath ?? `content/${fileName}`);
-    const entry = normalizePathSlashes(`        content/browser/${fileName}    (${source})`);
-    const content = await readText(manifestPath);
-    // Idempotency check
-    if (content.includes(`content/browser/${fileName}`)) {
-        return { manifest, entry, skipped: true };
-    }
-    const value = registerBrowserContentTokenized(content, fileName, entry, after);
-    if (!dryRun) {
-        await writeText(manifestPath, value.result);
-    }
-    return {
-        manifest,
-        entry,
-        previousEntry: value.previousEntry,
-        skipped: false,
-        afterFallback: value.afterFallback,
-    };
-}

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

@@ -1,18 +0,0 @@
-/**
- * Test manifest registration in browser/base/moz.build.
- */
-import type { RegisterResult } from './register-result.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>;