@hominis/fireforge 0.27.0 → 0.27.2

package/dist/src/commands/rebase/conflict-summary.js

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { extractConflictingFiles } from '../../core/patch-parse.js';
+function normalizeRejectFile(file) {
+    return file.replace(/\.rej$/, '');
+}
+function classifyConflict(files) {
+    if (files.some((file) => file.endsWith('toolkit/content/customElements.js'))) {
+        return 'registration context drift';
+    }
+    if (files.some((file) => file.endsWith('jar.mn') ||
+        file.endsWith('moz.build') ||
+        file.endsWith('browser.toml') ||
+        file.endsWith('browser/moz.configure'))) {
+        return 'manifest context drift';
+    }
+    return 'patch context drift';
+}
+/** Builds a concise operator-facing summary for a failed rebase patch. */
+export function buildRebaseConflictSummary(args) {
+    const failedFiles = [
+        ...new Set([
+            ...extractConflictingFiles(args.error),
+            ...(args.rejectFiles ?? []).map(normalizeRejectFile),
+        ]),
+    ].sort();
+    return {
+        patchFilename: args.patchFilename,
+        failedFiles,
+        category: classifyConflict(failedFiles),
+        nextCommands: [
+            "find engine -name '*.rej'",
+            'edit the affected engine/ files',
+            'fireforge rebase --continue',
+            'fireforge rebase --abort',
+        ],
+    };
+}
+//# sourceMappingURL=conflict-summary.js.map

package/dist/src/commands/rebase/continue.js

@@ -73,6 +73,8 @@ export async function handleContinue(projectRoot, maxFuzz) {
         // v0.14.0 resolve.ts fix.
         await updatePatchAndMetadata(paths.patches, currentPatch.filename, diffContent, {
             sourceEsrVersion: session.toVersion,
+            sourceVersion: session.toVersion,
+            ...(session.toProduct !== undefined ? { sourceProduct: session.toProduct } : {}),
         });
     }
     finally {

package/dist/src/commands/rebase/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * `fireforge rebase` — semi-automated ESR version upgrade.
+ * `fireforge rebase` — semi-automated Firefox source version upgrade.
  *
  * Orchestrates the full patch-rebase workflow:
  *   1. Reset engine to baseline
@@ -13,7 +13,7 @@ import { Command } from 'commander';
 import type { CommandContext } from '../../types/cli.js';
 import type { RebaseOptions } from '../../types/commands/index.js';
 /**
- * Runs the rebase command to orchestrate an ESR version upgrade.
+ * Runs the rebase command to orchestrate a Firefox source version upgrade.
  * @param projectRoot - Root directory of the project
  * @param options - Rebase options
  */

package/dist/src/commands/rebase/index.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
- * `fireforge rebase` — semi-automated ESR version upgrade.
+ * `fireforge rebase` — semi-automated Firefox source version upgrade.
  *
  * Orchestrates the full patch-rebase workflow:
  *   1. Reset engine to baseline
@@ -15,6 +15,7 @@ import { getFurnacePaths, updateFurnaceState } from '../../core/furnace-config.j
 import { getHead, isGitRepository, isMissingHeadError, resetChanges } from '../../core/git.js';
 import { discoverPatches } from '../../core/patch-files.js';
 import { loadPatchesManifest } from '../../core/patch-manifest.js';
+import { getPatchSourceProduct, getPatchSourceVersion } from '../../core/patch-source-metadata.js';
 import { hasActiveRebaseSession, saveRebaseSession } from '../../core/rebase-session.js';
 import { GeneralError } from '../../errors/base.js';
 import { RebaseSessionExistsError } from '../../errors/rebase.js';
@@ -65,9 +66,11 @@ async function handleFreshStart(projectRoot, options) {
         throw new GeneralError('No patches found in manifest. Nothing to rebase.');
     }
     // Determine the "from" version from the patches
-    const patchVersions = new Set(manifest.patches.map((p) => p.sourceEsrVersion));
+    const patchVersions = new Set(manifest.patches.map((p) => getPatchSourceVersion(p)));
+    const patchProducts = new Set(manifest.patches.map((p) => getPatchSourceProduct(p)).filter(Boolean));
     const sortedVersions = [...patchVersions].sort();
     const fromVersion = sortedVersions[0] ?? currentVersion;
+    const fromProduct = [...patchProducts].sort()[0] ?? config.firefox.product;
     if (patchVersions.size === 1 && fromVersion === currentVersion) {
         info('All patches already match the current Firefox version. Nothing to rebase.');
         outro('Rebase not needed');
@@ -110,6 +113,8 @@ async function handleFreshStart(projectRoot, options) {
     const allPatches = await discoverPatches(paths.patches);
     const session = {
         startedAt: new Date().toISOString(),
+        fromProduct,
+        toProduct: config.firefox.product,
         fromVersion,
         toVersion: currentVersion,
         preRebaseCommit,
@@ -125,7 +130,7 @@ async function handleFreshStart(projectRoot, options) {
 }
 // ── Public API ──
 /**
- * Runs the rebase command to orchestrate an ESR version upgrade.
+ * Runs the rebase command to orchestrate a Firefox source version upgrade.
  * @param projectRoot - Root directory of the project
  * @param options - Rebase options
  */
@@ -142,7 +147,7 @@ export async function rebaseCommand(projectRoot, options = {}) {
 export function registerRebase(program, { getProjectRoot, withErrorHandling }) {
     program
         .command('rebase')
-        .description('Semi-automated ESR version upgrade — apply patches with fuzz and re-export')
+        .description('Semi-automated Firefox source version upgrade — apply patches with fuzz and re-export')
         .option('--continue', 'Resume after manually resolving a failed patch')
         .option('--abort', 'Cancel the rebase and restore engine to pre-rebase state')
         .option('--dry-run', 'Show what would happen without modifying anything')

package/dist/src/commands/rebase/patch-loop.js

@@ -15,9 +15,11 @@ import { extractConflictingFiles } from '../../core/patch-parse.js';
 import { clearRebaseSession, saveRebaseSession } from '../../core/rebase-session.js';
 import { runInSignalCriticalSection } from '../../core/signal-critical.js';
 import { RebaseError } from '../../errors/rebase.js';
+import { elapsedSince } from '../../utils/elapsed.js';
 import { toError } from '../../utils/errors.js';
 import { pathExists } from '../../utils/fs.js';
 import { error, info, outro, spinner, success, warn } from '../../utils/logger.js';
+import { buildRebaseConflictSummary } from './conflict-summary.js';
 import { printSummary } from './summary.js';
 /**
  * Runs the patch application loop, re-exports applied patches, and stamps versions.
@@ -37,7 +39,7 @@ export async function runPatchLoop(projectRoot, session, paths, maxFuzz) {
             await saveRebaseSession(projectRoot, session);
             continue;
         }
-        s.message(`Applying ${entry.filename}...`);
+        s.message(`Applying ${i + 1}/${session.patches.length}: ${entry.filename}...`);
         // Apply + session persist is wrapped in a signal-deferred critical
         // section so a SIGINT / SIGTERM between the filesystem mutation and
         // the session-file update is held until the bookkeeping write lands.
@@ -90,8 +92,24 @@ export async function runPatchLoop(projectRoot, session, paths, maxFuzz) {
                 },
             }));
             s.error(`${entry.filename} failed to apply`);
+            const summary = buildRebaseConflictSummary({
+                patchFilename: entry.filename,
+                ...(result.error !== undefined ? { error: result.error } : {}),
+                ...(result.rejectFiles !== undefined ? { rejectFiles: result.rejectFiles } : {}),
+            });
+            warn(`Conflict summary for ${summary.patchFilename}: ${summary.category}`);
+            if (summary.failedFiles.length > 0) {
+                warn(`  Failed files: ${summary.failedFiles.join(', ')}`);
+            }
+            else {
+                warn('  Failed files: not detected from git output');
+            }
+            info('  Suggested next commands:');
+            for (const command of summary.nextCommands) {
+                info(`    ${command}`);
+            }
             if (result.error) {
-                error(`  Error: ${result.error}`);
+                error(`  Raw apply detail: ${result.error}`);
             }
             if (result.rejectFiles && result.rejectFiles.length > 0) {
                 info(`  .rej files created for manual resolution`);
@@ -125,16 +143,16 @@ export async function runPatchLoop(projectRoot, session, paths, maxFuzz) {
         .filter((p) => p.status === 'applied-clean' || p.status === 'applied-fuzz' || p.status === 'resolved')
         .map((p) => p.filename);
     if (appliedFilenames.length > 0) {
-        await stampPatchVersions(paths.patches, appliedFilenames, session.toVersion);
+        await stampPatchVersions(paths.patches, appliedFilenames, session.toVersion, session.toProduct);
     }
     // Stamp every Furnace override's `baseVersion` to match the rebased
-    // Firefox version. Before this stamp, a successful ESR bump left
+    // Firefox source version. Before this stamp, a successful source bump left
     // overrides in a doctor-failing drift state (each override still
-    // claimed the pre-rebase ESR as its baseline) and every subsequent
+    // claimed the pre-rebase source as its baseline) and every subsequent
     // `fireforge doctor` failed `Furnace component validation`. The
     // stamp is unconditional per the helper's contract: rebase already
     // succeeded on the patch side, so the operator is committing to the
-    // new ESR baseline; per-component health checking stays with
+    // new source baseline; per-component health checking stays with
     // `fireforge furnace validate` / `doctor --repair-furnace`.
     try {
         const overridesStamped = await stampFurnaceOverrideBaseVersions(projectRoot, session.toVersion);
@@ -158,7 +176,7 @@ export async function runPatchLoop(projectRoot, session, paths, maxFuzz) {
         return next;
     });
     info('');
-    success(`All patches re-exported with sourceEsrVersion=${session.toVersion}`);
+    success(`All patches re-exported with sourceVersion=${session.toVersion}`);
     outro('Rebase complete!');
 }
 async function reExportAppliedPatches(session, paths) {
@@ -167,19 +185,19 @@ async function reExportAppliedPatches(session, paths) {
     if (!manifest)
         return failures;
     const s = spinner('Re-exporting patches...');
-    for (const entry of session.patches) {
-        if (entry.status !== 'applied-clean' && entry.status !== 'applied-fuzz')
-            continue;
+    const reExportable = session.patches.filter((entry) => entry.status === 'applied-clean' || entry.status === 'applied-fuzz');
+    const startedAt = Date.now();
+    for (const [index, entry] of reExportable.entries()) {
         const meta = manifest.patches.find((p) => p.filename === entry.filename);
         if (!meta)
             continue;
-        s.message(`Re-exporting ${entry.filename}...`);
         const existingFiles = [];
         for (const f of meta.filesAffected) {
             if (await pathExists(join(paths.engine, f))) {
                 existingFiles.push(f);
             }
         }
+        s.message(`Re-exporting ${index + 1}/${reExportable.length}: ${entry.filename} (${existingFiles.length}/${meta.filesAffected.length} file(s), ${elapsedSince(startedAt)} elapsed)...`);
         try {
             const diffContent = await getDiffForFilesAgainstHead(paths.engine, existingFiles);
             if (diffContent.trim()) {

package/dist/src/commands/rebase/summary.js

@@ -27,7 +27,11 @@ export function statusLabel(status, fuzzFactor) {
  */
 export function printSummary(session) {
     info('');
-    info(`ESR Rebase Summary: ${session.fromVersion} → ${session.toVersion}`);
+    const from = session.fromProduct
+        ? `${session.fromProduct} ${session.fromVersion}`
+        : session.fromVersion;
+    const to = session.toProduct ? `${session.toProduct} ${session.toVersion}` : session.toVersion;
+    info(`Source Rebase Summary: ${from} → ${to}`);
     info('='.repeat(55));
     for (const patch of session.patches) {
         const label = statusLabel(patch.status, patch.fuzzFactor);
@@ -37,7 +41,8 @@ export function printSummary(session) {
     const fuzz = session.patches.filter((p) => p.status === 'applied-fuzz').length;
     const resolved = session.patches.filter((p) => p.status === 'resolved').length;
     const failed = session.patches.filter((p) => p.status === 'failed').length;
+    const total = session.patches.length;
     info('');
-    info(`Results: ${clean} clean, ${fuzz} fuzz-applied, ${resolved} manually resolved, ${failed} failed`);
+    info(`Results: ${total} total: ${clean} clean, ${fuzz} fuzz-applied, ${resolved} manually resolved, ${failed} failed`);
 }
 //# sourceMappingURL=summary.js.map

package/dist/src/commands/resolve.js

@@ -8,6 +8,7 @@ import { stageFiles, unstageFiles } from '../core/git-file-ops.js';
 import { extractAffectedFiles } from '../core/patch-apply.js';
 import { updatePatchAndMetadata } from '../core/patch-export.js';
 import { loadPatchesManifest } from '../core/patch-manifest.js';
+import { buildPatchSourceMetadata } from '../core/patch-source-metadata.js';
 import { GeneralError, ResolutionError } from '../errors/base.js';
 import { toError } from '../utils/errors.js';
 import { pathExists } from '../utils/fs.js';
@@ -132,7 +133,7 @@ export async function resolveCommand(projectRoot, options = {}) {
         const config = await loadConfig(projectRoot);
         await updatePatchAndMetadata(paths.patches, patchFilename, diffContent, {
             filesAffected: diffFilesAffected,
-            sourceEsrVersion: config.firefox.version,
+            ...buildPatchSourceMetadata(config.firefox),
         });
         // Cleanup: Clear pendingResolution from state.json transactionally so
         // we don't clobber concurrent updates to unrelated keys (e.g. another

package/dist/src/commands/setup-support.js

@@ -19,10 +19,13 @@ function renderLicenseTemplate(license, template, vendor, now = new Date()) {
     return template.replace(/\[year\]/g, String(now.getFullYear())).replace(/\[fullname\]/g, vendor);
 }
 function resolveFirefoxProduct(value, field) {
-    if (value === 'firefox' || value === 'firefox-esr' || value === 'firefox-beta') {
+    if (value === 'firefox' ||
+        value === 'firefox-esr' ||
+        value === 'firefox-beta' ||
+        value === 'firefox-devedition') {
         return value;
     }
-    throw new InvalidArgumentError('Invalid product (use: firefox, firefox-esr, firefox-beta)', field);
+    throw new InvalidArgumentError('Invalid product (use: firefox, firefox-esr, firefox-beta, firefox-devedition)', field);
 }
 function resolveProjectLicense(value, field) {
     if (typeof value === 'string' && isValidProjectLicense(value)) {
@@ -153,6 +156,7 @@ async function promptSetupInputs(options) {
                     { value: 'firefox', label: 'Firefox (stable releases)' },
                     { value: 'firefox-esr', label: 'Firefox ESR (extended support)' },
                     { value: 'firefox-beta', label: 'Firefox Beta (pre-release)' },
+                    { value: 'firefox-devedition', label: 'Firefox Developer Edition' },
                 ],
             });
         },

package/dist/src/commands/setup.js

@@ -71,6 +71,7 @@ export function registerSetup(program, { withErrorHandling }) {
         'firefox',
         'firefox-esr',
         'firefox-beta',
+        'firefox-devedition',
     ]))
         .addOption(new Option('--license <license>', 'Project license').choices([...PROJECT_LICENSES]))
         .option('-f, --force', 'Overwrite existing configuration without prompting')

package/dist/src/commands/source.d.ts

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+import type { CommandContext } from '../types/cli.js';
+import type { SourceSetOptions } from '../types/commands/index.js';
+/**
+ * Atomically updates the Firefox source tuple in fireforge.json.
+ */
+export declare function sourceSetCommand(projectRoot: string, options: SourceSetOptions): Promise<void>;
+/** Registers the source command on the CLI program. */
+export declare function registerSource(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

package/dist/src/commands/source.js

@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { Option } from 'commander';
+import { configExists, loadRawConfigDocument, validateConfig, withConfigFileLock, writeConfigDocument, } from '../core/config.js';
+import { GeneralError, InvalidArgumentError } from '../errors/base.js';
+import { info, intro, outro, success } from '../utils/logger.js';
+import { isValidFirefoxProduct } from '../utils/validation.js';
+const SOURCE_PRODUCTS = [
+    'firefox',
+    'firefox-esr',
+    'firefox-beta',
+    'firefox-devedition',
+];
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function cloneRawConfig(raw) {
+    const cloned = structuredClone(raw);
+    if (!isRecord(cloned)) {
+        throw new GeneralError('Cannot update fireforge.json: config clone was not an object.');
+    }
+    return cloned;
+}
+function parseSourceProduct(product) {
+    if (isValidFirefoxProduct(product)) {
+        return product;
+    }
+    throw new InvalidArgumentError(`--product must be one of: ${SOURCE_PRODUCTS.join(', ')}`, '--product');
+}
+/**
+ * Atomically updates the Firefox source tuple in fireforge.json.
+ */
+export async function sourceSetCommand(projectRoot, options) {
+    intro('FireForge Source');
+    if (!(await configExists(projectRoot))) {
+        throw new GeneralError('No fireforge.json found. Run "fireforge setup" to create a project.');
+    }
+    if (options.sha256 !== undefined && options.clearSha256 === true) {
+        throw new InvalidArgumentError('--sha256 cannot be combined with --clear-sha256', '--sha256');
+    }
+    const written = await withConfigFileLock(projectRoot, async () => {
+        const raw = await loadRawConfigDocument(projectRoot);
+        const updated = cloneRawConfig(raw);
+        const firefox = isRecord(updated['firefox']) ? { ...updated['firefox'] } : {};
+        firefox['version'] = options.version;
+        firefox['product'] = options.product;
+        if (options.clearSha256 === true) {
+            delete firefox['sha256'];
+        }
+        else if (options.sha256 !== undefined) {
+            firefox['sha256'] = options.sha256;
+        }
+        updated['firefox'] = firefox;
+        const validated = validateConfig(updated);
+        if (validated.firefox.sha256 !== undefined) {
+            firefox['sha256'] = validated.firefox.sha256;
+        }
+        await writeConfigDocument(projectRoot, updated);
+        return validated.firefox;
+    });
+    success(`Set firefox.version = ${written.version}`);
+    success(`Set firefox.product = ${written.product}`);
+    if (written.sha256 !== undefined) {
+        success(`Set firefox.sha256 = ${written.sha256}`);
+    }
+    else if (options.clearSha256 === true) {
+        info('Cleared firefox.sha256');
+    }
+    outro('');
+}
+/** Registers the source command on the CLI program. */
+export function registerSource(program, { getProjectRoot, withErrorHandling }) {
+    const source = program.command('source').description('Manage Firefox source configuration');
+    source
+        .command('set')
+        .description('Atomically set Firefox source version, product, and optional checksum')
+        .requiredOption('--version <version>', 'Firefox version to base on')
+        .addOption(new Option('--product <product>', 'Firefox product')
+        .choices([...SOURCE_PRODUCTS])
+        .makeOptionMandatory())
+        .option('--sha256 <hash>', 'Pinned SHA-256 for the resolved source archive')
+        .option('--clear-sha256', 'Clear any existing pinned SHA-256')
+        .action(withErrorHandling(async (options) => {
+        const { product, version, sha256, clearSha256 } = options;
+        await sourceSetCommand(getProjectRoot(), {
+            version,
+            product: parseSourceProduct(product),
+            ...(sha256 !== undefined ? { sha256 } : {}),
+            ...(clearSha256 !== undefined ? { clearSha256 } : {}),
+        });
+    }));
+}
+//# sourceMappingURL=source.js.map

package/dist/src/commands/status-output.d.ts

@@ -0,0 +1,13 @@
+import type { ClassifiedFile } from '../core/status-classify.js';
+export interface ClassifiedBuckets {
+    conflict: ClassifiedFile[];
+    unmanaged: ClassifiedFile[];
+    patchBacked: ClassifiedFile[];
+    patchOwnedDrift: ClassifiedFile[];
+    branding: ClassifiedFile[];
+    furnace: ClassifiedFile[];
+}
+/** Renders the unmanaged-only status view and registration hints. */
+export declare function renderUnmanagedOnly(unmanagedFiles: ClassifiedFile[], totalModified: number, projectRoot: string, binaryName: string): Promise<void>;
+/** Renders the default classified status buckets. */
+export declare function renderDefaultStatus(totalModified: number, buckets: ClassifiedBuckets, projectRoot: string, binaryName: string): Promise<void>;

package/dist/src/commands/status-output.js

@@ -0,0 +1,186 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { isFileRegistered, matchesRegistrablePattern } from '../core/manifest-rules.js';
+import { GeneralError } from '../errors/base.js';
+import { info, outro, warn } from '../utils/logger.js';
+const STATUS_DESCRIPTIONS = {
+    M: 'modified',
+    A: 'added',
+    D: 'deleted',
+    R: 'renamed',
+    C: 'copied',
+    U: 'unmerged',
+    '?': 'untracked',
+    '!': 'ignored',
+};
+function getStatusDescription(code) {
+    return STATUS_DESCRIPTIONS[code] ?? 'changed';
+}
+function getPrimaryStatusCode(status) {
+    if (status.includes('?'))
+        return '?';
+    if (status.includes('!'))
+        return '!';
+    for (const code of status) {
+        if (code !== ' ')
+            return code;
+    }
+    return status;
+}
+function isNewFileStatus(status) {
+    const code = getPrimaryStatusCode(status);
+    return code === '?' || code === 'A';
+}
+function groupFilesByStatus(files) {
+    const grouped = new Map();
+    for (const { status, file } of files) {
+        const code = getPrimaryStatusCode(status);
+        const existing = grouped.get(code) ?? [];
+        existing.push(file);
+        grouped.set(code, existing);
+    }
+    return grouped;
+}
+function printStatusGroups(files) {
+    const grouped = groupFilesByStatus(files);
+    for (const [status, fileList] of grouped) {
+        warn(`${getStatusDescription(status)}:`);
+        for (const file of fileList)
+            info(`  ${file}`);
+    }
+}
+async function printUnregisteredWarnings(files, projectRoot, binaryName) {
+    const newFiles = files.filter((f) => isNewFileStatus(f.status));
+    if (newFiles.length === 0)
+        return;
+    const registrableFiles = newFiles.filter((f) => matchesRegistrablePattern(f.file, binaryName));
+    const registrationChecks = await Promise.all(registrableFiles.map(async (f) => {
+        try {
+            return {
+                file: f.file,
+                registered: await isFileRegistered(projectRoot, f.file),
+                manifestMissing: false,
+                manifestMissingMessage: undefined,
+            };
+        }
+        catch (err) {
+            if (err instanceof GeneralError && /^Manifest not found:/i.test(err.message)) {
+                return {
+                    file: f.file,
+                    registered: false,
+                    manifestMissing: true,
+                    manifestMissingMessage: err.message,
+                };
+            }
+            throw err;
+        }
+    }));
+    const unregistered = registrationChecks.filter((f) => !f.registered && !f.manifestMissing);
+    const manifestMissing = registrationChecks.filter((f) => f.manifestMissing);
+    if (unregistered.length > 0) {
+        info('');
+        warn('Potentially unregistered files:');
+        for (const f of unregistered)
+            info(`  ${f.file} — run 'fireforge register ${f.file}'`);
+    }
+    if (manifestMissing.length > 0) {
+        info('');
+        warn('Files whose registration manifest does not exist yet:');
+        for (const f of manifestMissing) {
+            info(`  ${f.file} — ${f.manifestMissingMessage}`);
+            info(`    Create the parent manifest, then run 'fireforge register ${f.file}'.`);
+        }
+    }
+}
+/** Renders the unmanaged-only status view and registration hints. */
+export async function renderUnmanagedOnly(unmanagedFiles, totalModified, projectRoot, binaryName) {
+    info(`${unmanagedFiles.length} unmanaged file${unmanagedFiles.length === 1 ? '' : 's'} (${totalModified} total modified):\n`);
+    if (unmanagedFiles.length > 0) {
+        printStatusGroups(unmanagedFiles);
+        await printUnregisteredWarnings(unmanagedFiles, projectRoot, binaryName);
+    }
+    else {
+        info('No unmanaged changes');
+    }
+    outro(unmanagedFiles.length === 0
+        ? 'No unmanaged changes'
+        : `${unmanagedFiles.length} unmanaged change${unmanagedFiles.length === 1 ? '' : 's'}`);
+}
+/** Renders the default classified status buckets. */
+export async function renderDefaultStatus(totalModified, buckets, projectRoot, binaryName) {
+    const { conflict, unmanaged, patchBacked, patchOwnedDrift, branding, furnace } = buckets;
+    info(`${totalModified} modified file${totalModified === 1 ? '' : 's'}:\n`);
+    if (conflict.length > 0) {
+        warn('Cross-patch ownership conflicts (same file claimed by multiple patches):');
+        printStatusGroups(conflict);
+        for (const entry of conflict) {
+            if (entry.claimedBy && entry.claimedBy.length > 0) {
+                info(`  ${entry.file} — claimed by ${entry.claimedBy.join(', ')}`);
+            }
+        }
+        info('Run "fireforge status --ownership" for the full conflict table, then repartition with "fireforge re-export --files <paths> <patch>".');
+    }
+    if (unmanaged.length > 0) {
+        if (conflict.length > 0)
+            info('');
+        warn('Unmanaged changes:');
+        printStatusGroups(unmanaged);
+        await printUnregisteredWarnings(unmanaged, projectRoot, binaryName);
+    }
+    if (patchBacked.length > 0) {
+        if (conflict.length > 0 || unmanaged.length > 0)
+            info('');
+        warn('Patch-backed materialized changes:');
+        printStatusGroups(patchBacked);
+    }
+    if (patchOwnedDrift.length > 0) {
+        if (conflict.length > 0 || unmanaged.length > 0 || patchBacked.length > 0)
+            info('');
+        warn('Patch-owned drift:');
+        printStatusGroups(patchOwnedDrift);
+        info('These files are claimed by exactly one patch, but engine/ no longer matches that patch output. Re-export the owning patch after reviewing the manual resolution.');
+    }
+    if (branding.length > 0) {
+        if (conflict.length > 0 ||
+            unmanaged.length > 0 ||
+            patchBacked.length > 0 ||
+            patchOwnedDrift.length > 0) {
+            info('');
+        }
+        warn('Tool-managed branding changes:');
+        printStatusGroups(branding);
+    }
+    if (furnace.length > 0) {
+        if (conflict.length > 0 ||
+            unmanaged.length > 0 ||
+            patchBacked.length > 0 ||
+            patchOwnedDrift.length > 0 ||
+            branding.length > 0) {
+            info('');
+        }
+        warn('Furnace-managed component changes:');
+        printStatusGroups(furnace);
+    }
+    if (conflict.length === 0 &&
+        unmanaged.length === 0 &&
+        patchBacked.length === 0 &&
+        patchOwnedDrift.length === 0 &&
+        branding.length === 0 &&
+        furnace.length === 0) {
+        info('No changes');
+    }
+    const parts = [];
+    if (conflict.length > 0)
+        parts.push(`${conflict.length} conflict`);
+    if (unmanaged.length > 0)
+        parts.push(`${unmanaged.length} unmanaged`);
+    if (patchBacked.length > 0)
+        parts.push(`${patchBacked.length} patch-backed`);
+    if (patchOwnedDrift.length > 0)
+        parts.push(`${patchOwnedDrift.length} patch-owned drift`);
+    if (branding.length > 0)
+        parts.push(`${branding.length} branding`);
+    if (furnace.length > 0)
+        parts.push(`${furnace.length} furnace`);
+    outro(parts.join(', '));
+}
+//# sourceMappingURL=status-output.js.map