@hominis/fireforge 0.19.3 → 0.19.4

package/dist/src/commands/bootstrap-checks.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { execFile } from 'node:child_process';
-import { failure, warning } from './doctor.js';
+import { failure, warning } from './doctor-check-core.js';
 /**
  * Scans bootstrap output for known failure patterns and returns structured
  * issue tags. A Python traceback paired with an HTTP 403 is collapsed into

package/dist/src/commands/doctor-check-core.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Doctor check types and lightweight result builders shared between
+ * `doctor.ts` and sibling check modules. Kept separate so registries can import
+ * these symbols without creating cycles through `doctor.ts`.
+ */
+import type { DoctorCheck, DoctorOptions } from '../types/commands/index.js';
+import type { FireForgeConfig, FireForgeState, ProjectPaths } from '../types/config.js';
+import type { FurnaceConfig } from '../types/furnace.js';
+/**
+ * Shared state available to every doctor check during a single run.
+ *
+ * The context is populated lazily by the doctor runner. Individual checks
+ * can record side-observations (e.g. the parsed `fireforge.json`) into the
+ * context for later checks to consume without re-parsing.
+ */
+export interface DoctorCheckContext {
+    projectRoot: string;
+    paths: ProjectPaths;
+    state: FireForgeState;
+    options: DoctorOptions;
+    /**
+     * Whether the engine/ directory exists on disk. Populated before checks
+     * run so downstream checks can skip git/mach inspections cheaply.
+     */
+    engineExists: boolean;
+    /**
+     * The loaded project config, set by the "fireforge.json is valid" check
+     * when it succeeds. Undefined before that check runs and whenever loading
+     * failed.
+     */
+    config: FireForgeConfig | undefined;
+    /**
+     * Whether `furnace.json` exists on disk. Populated before checks run so
+     * the furnace group can skipIf cheaply when the subsystem is not in use.
+     */
+    furnaceConfigExists: boolean;
+    /**
+     * The parsed furnace config, set by the "Furnace configuration" check
+     * when it succeeds. Later furnace checks read from this so they do not
+     * re-parse the file; undefined when the config could not be loaded.
+     */
+    furnaceConfig: FurnaceConfig | undefined;
+}
+/**
+ * Result a check may return. A single object is the common case; an array
+ * lets a single check emit multiple related rows (e.g. the engine branch
+ * check which may report on branch + detached state together).
+ */
+export type CheckResult = DoctorCheck | DoctorCheck[];
+/**
+ * Declarative definition of a single doctor check.
+ *
+ * Every check opts into the shared execution/reporting pipeline by
+ * implementing only its inspection logic in `run`. Cross-cutting concerns
+ * (result aggregation, summary, exit codes) live in the runner instead of
+ * being duplicated at each call site.
+ */
+export interface DoctorCheckDefinition {
+    /**
+     * Human-readable name surfaced in the check report (e.g. "Git installed").
+     * Not required to be unique, but tests assert on it.
+     */
+    name: string;
+    /**
+     * When `true`, the check is silently skipped. Used for checks that only
+     * apply when the engine is present, or only when specific state flags
+     * are set. Skipped checks contribute nothing to the final report.
+     */
+    skipIf?: (ctx: DoctorCheckContext) => boolean;
+    /**
+     * Names of checks that must appear earlier in the registry and run before
+     * this check. Enforced at startup via validateCheckDependencies so
+     * accidental reorders surface immediately instead of producing subtle
+     * context-population bugs at runtime.
+     */
+    dependsOn?: readonly string[];
+    /**
+     * Runs the inspection. Throwing is shorthand for "this check failed with
+     * severity 'error'" — the runner converts the exception message into a
+     * DoctorCheck. Returning a DoctorCheck (or array) lets the check control
+     * severity, warnings, and fix hints directly.
+     */
+    run: (ctx: DoctorCheckContext) => CheckResult | Promise<CheckResult>;
+    /**
+     * Optional recovery hint attached to the auto-generated failure result
+     * when `run` throws. Ignored when `run` returns a DoctorCheck explicitly.
+     */
+    fix?: string;
+}
+/**
+ * Builds a DoctorCheck object representing a successful "OK" check.
+ */
+export declare function ok(name: string): DoctorCheck;
+/**
+ * Builds a DoctorCheck object representing a warning result.
+ */
+export declare function warning(name: string, message: string, fix?: string): DoctorCheck;
+/**
+ * Builds a DoctorCheck object representing a failure result.
+ */
+export declare function failure(name: string, message: string, fix?: string): DoctorCheck;

package/dist/src/commands/doctor-check-core.js

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Doctor check types and lightweight result builders shared between
+ * `doctor.ts` and sibling check modules. Kept separate so registries can import
+ * these symbols without creating cycles through `doctor.ts`.
+ */
+/**
+ * Builds a DoctorCheck object representing a successful "OK" check.
+ */
+export function ok(name) {
+    return { name, passed: true, severity: 'ok', message: 'OK' };
+}
+/**
+ * Builds a DoctorCheck object representing a warning result.
+ */
+export function warning(name, message, fix) {
+    return {
+        name,
+        passed: true,
+        severity: 'warning',
+        warning: true,
+        message,
+        ...(fix ? { fix } : {}),
+    };
+}
+/**
+ * Builds a DoctorCheck object representing a failure result.
+ */
+export function failure(name, message, fix) {
+    return { name, passed: false, severity: 'error', message, ...(fix ? { fix } : {}) };
+}
+//# sourceMappingURL=doctor-check-core.js.map

package/dist/src/commands/doctor-furnace-manifest-sync.d.ts

@@ -14,5 +14,5 @@
  * Lives in a sibling module to keep `doctor-furnace.ts` under the
  * per-file LOC budget.
  */
-import type { DoctorCheckDefinition } from './doctor.js';
+import type { DoctorCheckDefinition } from './doctor-check-core.js';
 export declare const furnaceManifestSyncCheck: DoctorCheckDefinition;

package/dist/src/commands/doctor-furnace-manifest-sync.js

@@ -20,7 +20,7 @@ import { join } from 'node:path';
 import { getFurnacePaths, loadFurnaceConfig, writeFurnaceConfig } from '../core/furnace-config.js';
 import { toError } from '../utils/errors.js';
 import { pathExists, readJson } from '../utils/fs.js';
-import { failure, ok, warning } from './doctor.js';
+import { failure, ok, warning } from './doctor-check-core.js';
 async function listComponentDirs(dir) {
     if (!(await pathExists(dir)))
         return [];

package/dist/src/commands/doctor-furnace.d.ts

@@ -1,4 +1,4 @@
-import type { DoctorCheckDefinition } from './doctor.js';
+import type { DoctorCheckDefinition } from './doctor-check-core.js';
 /**
  * The ordered furnace check group. Exported as an array so `doctor.ts`
  * can splice it into the main registry at the right position. The order

package/dist/src/commands/doctor-furnace.js

@@ -9,7 +9,7 @@ import { getFurnaceLockPath, runFurnaceMutation } from '../core/furnace-operatio
 import { validateAllComponents } from '../core/furnace-validate.js';
 import { toError } from '../utils/errors.js';
 import { pathExists } from '../utils/fs.js';
-import { failure, ok, warning } from './doctor.js';
+import { failure, ok, warning } from './doctor-check-core.js';
 import { furnaceManifestSyncCheck } from './doctor-furnace-manifest-sync.js';
 const ENGINE_REPAIRABLE_OPERATIONS = [
     'preview-teardown',

package/dist/src/commands/doctor-working-tree.d.ts

@@ -10,7 +10,7 @@
  * budget; see the call site in `runEngineGitChecks`.
  */
 import type { DoctorCheck } from '../types/commands/index.js';
-import type { DoctorCheckContext } from './doctor.js';
+import type { DoctorCheckContext } from './doctor-check-core.js';
 /**
  * Inspects the engine working tree and returns a single
  * `DoctorCheck`. Ownership-aware: patch-backed / branding / furnace

package/dist/src/commands/doctor-working-tree.js

@@ -13,7 +13,7 @@
 import { collectFurnaceManagedPrefixes } from '../core/furnace-config.js';
 import { expandUntrackedDirectoryEntries, getWorkingTreeStatus } from '../core/git-status.js';
 import { classifyFiles } from '../core/status-classify.js';
-import { ok, warning } from './doctor.js';
+import { ok, warning } from './doctor-check-core.js';
 function summarizeWorkingTreeChangeCount(changeCount) {
     return `Engine working tree has ${changeCount} local change${changeCount === 1 ? '' : 's'}. Some FireForge commands assume a clean baseline and may behave differently until these are exported, discarded, or committed.`;
 }

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

@@ -2,113 +2,7 @@ import { Command } from 'commander';
 import { ExitCode } from '../errors/codes.js';
 import type { CommandContext } from '../types/cli.js';
 import type { DoctorCheck, DoctorOptions } from '../types/commands/index.js';
-import type { FireForgeConfig, FireForgeState, ProjectPaths } from '../types/config.js';
-import type { FurnaceConfig } from '../types/furnace.js';
-/**
- * Shared state available to every doctor check during a single run.
- *
- * The context is populated lazily by the doctor runner. Individual checks
- * can record side-observations (e.g. the parsed `fireforge.json`) into the
- * context for later checks to consume without re-parsing.
- *
- * Exported so sibling modules (e.g. `doctor-furnace.ts`) can declare
- * `DoctorCheckDefinition` entries against the same shared context.
- */
-export interface DoctorCheckContext {
-    projectRoot: string;
-    paths: ProjectPaths;
-    state: FireForgeState;
-    options: DoctorOptions;
-    /**
-     * Whether the engine/ directory exists on disk. Populated before checks
-     * run so downstream checks can skip git/mach inspections cheaply.
-     */
-    engineExists: boolean;
-    /**
-     * The loaded project config, set by the "fireforge.json is valid" check
-     * when it succeeds. Undefined before that check runs and whenever loading
-     * failed.
-     */
-    config: FireForgeConfig | undefined;
-    /**
-     * Whether `furnace.json` exists on disk. Populated before checks run so
-     * the furnace group can skipIf cheaply when the subsystem is not in use.
-     * A missing furnace.json is not an error — plenty of projects never touch
-     * the subsystem — so the doctor stays silent rather than failing.
-     */
-    furnaceConfigExists: boolean;
-    /**
-     * The parsed furnace config, set by the "Furnace configuration" check
-     * when it succeeds. Later furnace checks read from this so they do not
-     * re-parse the file; undefined when the config could not be loaded.
-     */
-    furnaceConfig: FurnaceConfig | undefined;
-}
-/**
- * Result a check may return. A single object is the common case; an array
- * lets a single check emit multiple related rows (e.g. the engine branch
- * check which may report on branch + detached state together).
- */
-export type CheckResult = DoctorCheck | DoctorCheck[];
-/**
- * Declarative definition of a single doctor check.
- *
- * Every check opts into the shared execution/reporting pipeline by
- * implementing only its inspection logic in `run`. Cross-cutting concerns
- * (result aggregation, summary, exit codes) live in the runner instead of
- * being duplicated at each call site.
- *
- * Exported so sibling modules (e.g. `doctor-furnace.ts`) can declare
- * new checks without re-deriving the shape.
- */
-export interface DoctorCheckDefinition {
-    /**
-     * Human-readable name surfaced in the check report (e.g. "Git installed").
-     * Not required to be unique, but tests assert on it.
-     */
-    name: string;
-    /**
-     * When `true`, the check is silently skipped. Used for checks that only
-     * apply when the engine is present, or only when specific state flags
-     * are set. Skipped checks contribute nothing to the final report.
-     */
-    skipIf?: (ctx: DoctorCheckContext) => boolean;
-    /**
-     * Names of checks that must appear earlier in the registry and run before
-     * this check. Enforced at startup via {@link validateCheckDependencies} so
-     * accidental reorders surface immediately instead of producing subtle
-     * context-population bugs at runtime.
-     */
-    dependsOn?: readonly string[];
-    /**
-     * Runs the inspection. Throwing is shorthand for "this check failed with
-     * severity 'error'" — the runner converts the exception message into a
-     * DoctorCheck. Returning a DoctorCheck (or array) lets the check control
-     * severity, warnings, and fix hints directly.
-     */
-    run: (ctx: DoctorCheckContext) => CheckResult | Promise<CheckResult>;
-    /**
-     * Optional recovery hint attached to the auto-generated failure result
-     * when `run` throws. Ignored when `run` returns a DoctorCheck explicitly.
-     */
-    fix?: string;
-}
-/**
- * Builds a DoctorCheck object representing a successful "OK" check.
- * Exported for sibling check modules that declare `DoctorCheckDefinition`
- * entries out-of-file (e.g. `doctor-furnace.ts`).
- */
-export declare function ok(name: string): DoctorCheck;
-/**
- * Builds a DoctorCheck object representing a warning result.
- * Exported for sibling check modules — see {@link ok}.
- */
-export declare function warning(name: string, message: string, fix?: string): DoctorCheck;
-/**
- * Builds a DoctorCheck object representing a failure result.
- * Exported for sibling check modules — see {@link ok}.
- */
-export declare function failure(name: string, message: string, fix?: string): DoctorCheck;
+import type { DoctorCheckDefinition } from './doctor-check-core.js';
 /**
  * Validates that every check's `dependsOn` entries appear earlier in the
  * registry. Called once at module load time so a broken reorder surfaces

package/dist/src/commands/doctor.js

@@ -10,37 +10,9 @@ import { toError } from '../utils/errors.js';
 import { pathExists } from '../utils/fs.js';
 import { error, info, intro, outro, success, warn } from '../utils/logger.js';
 import { findExecutable } from '../utils/process.js';
+import { failure, ok, warning } from './doctor-check-core.js';
 import { FURNACE_DOCTOR_CHECKS } from './doctor-furnace.js';
 import { inspectEngineWorkingTree } from './doctor-working-tree.js';
-/**
- * Builds a DoctorCheck object representing a successful "OK" check.
- * Exported for sibling check modules that declare `DoctorCheckDefinition`
- * entries out-of-file (e.g. `doctor-furnace.ts`).
- */
-export function ok(name) {
-    return { name, passed: true, severity: 'ok', message: 'OK' };
-}
-/**
- * Builds a DoctorCheck object representing a warning result.
- * Exported for sibling check modules — see {@link ok}.
- */
-export function warning(name, message, fix) {
-    return {
-        name,
-        passed: true,
-        severity: 'warning',
-        warning: true,
-        message,
-        ...(fix ? { fix } : {}),
-    };
-}
-/**
- * Builds a DoctorCheck object representing a failure result.
- * Exported for sibling check modules — see {@link ok}.
- */
-export function failure(name, message, fix) {
-    return { name, passed: false, severity: 'error', message, ...(fix ? { fix } : {}) };
-}
 /**
  * Runs a single check definition, converting thrown errors into
  * DoctorCheck failure rows. Always returns an array so the caller can

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

@@ -1,21 +1,4 @@
 import { Command } from 'commander';
 import type { CommandContext } from '../../types/cli.js';
-import { furnaceApplyCommand } from './apply.js';
-import { furnaceChromeDocCreateCommand } from './chrome-doc.js';
-import { furnaceCreateCommand } from './create.js';
-import { furnaceDeployCommand } from './deploy.js';
-import { furnaceDiffCommand } from './diff.js';
-import { furnaceInitCommand } from './init.js';
-import { furnaceListCommand } from './list.js';
-import { furnaceBatchOverrideCommand, furnaceOverrideCommand } from './override.js';
-import { furnacePreviewCommand } from './preview.js';
-import { furnaceRefreshCommand } from './refresh.js';
-import { furnaceRemoveCommand } from './remove.js';
-import { furnaceRenameCommand } from './rename.js';
-import { furnaceScanCommand } from './scan.js';
-import { furnaceStatusCommand } from './status.js';
-import { furnaceSyncCommand } from './sync.js';
-import { furnaceValidateCommand } from './validate.js';
-export { furnaceApplyCommand, furnaceBatchOverrideCommand, furnaceChromeDocCreateCommand, furnaceCreateCommand, furnaceDeployCommand, furnaceDiffCommand, furnaceInitCommand, furnaceListCommand, furnaceOverrideCommand, furnacePreviewCommand, furnaceRefreshCommand, furnaceRemoveCommand, furnaceRenameCommand, furnaceScanCommand, furnaceStatusCommand, furnaceSyncCommand, furnaceValidateCommand, };
 /** Registers the furnace command on the CLI program. */
 export declare function registerFurnace(program: Command, context: CommandContext): void;

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

@@ -17,7 +17,6 @@ import { furnaceScanCommand } from './scan.js';
 import { furnaceStatusCommand } from './status.js';
 import { furnaceSyncCommand } from './sync.js';
 import { furnaceValidateCommand } from './validate.js';
-export { furnaceApplyCommand, furnaceBatchOverrideCommand, furnaceChromeDocCreateCommand, furnaceCreateCommand, furnaceDeployCommand, furnaceDiffCommand, furnaceInitCommand, furnaceListCommand, furnaceOverrideCommand, furnacePreviewCommand, furnaceRefreshCommand, furnaceRemoveCommand, furnaceRenameCommand, furnaceScanCommand, furnaceStatusCommand, furnaceSyncCommand, furnaceValidateCommand, };
 /**
  * Registers Furnace commands for querying component state: status, scan,
  * and action commands like apply, deploy, and create.

package/dist/src/commands/furnace/validate.d.ts

@@ -1,9 +1,8 @@
+import type { FurnaceValidateOptions } from '../../types/commands/index.js';
 /**
  * Runs the furnace validate command to perform static analysis on components.
  * @param projectRoot - Root directory of the project
  * @param name - Optional component name to validate (validates all if omitted)
  * @param options - Optional command options (e.g. --fix)
  */
-export declare function furnaceValidateCommand(projectRoot: string, name?: string, options?: {
-    fix?: boolean;
-}): Promise<void>;
+export declare function furnaceValidateCommand(projectRoot: string, name?: string, options?: FurnaceValidateOptions): Promise<void>;

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

@@ -7,12 +7,6 @@
  */
 import { Command } from 'commander';
 import type { CommandContext } from '../../types/cli.js';
-export { patchCompactCommand } from './compact.js';
-export { patchDeleteCommand } from './delete.js';
-export { patchLintIgnoreCommand } from './lint-ignore.js';
-export { patchRenameCommand } from './rename.js';
-export { patchReorderCommand } from './reorder.js';
-export { patchTierCommand } from './tier.js';
 /**
  * Registers the `patch` subcommand parent and its verbs on the CLI.
  *

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

@@ -12,12 +12,6 @@ import { registerPatchLintIgnore } from './lint-ignore.js';
 import { registerPatchRename } from './rename.js';
 import { registerPatchReorder } from './reorder.js';
 import { registerPatchTier } from './tier.js';
-export { patchCompactCommand } from './compact.js';
-export { patchDeleteCommand } from './delete.js';
-export { patchLintIgnoreCommand } from './lint-ignore.js';
-export { patchRenameCommand } from './rename.js';
-export { patchReorderCommand } from './reorder.js';
-export { patchTierCommand } from './tier.js';
 /**
  * Registers the `patch` subcommand parent and its verbs on the CLI.
  *

package/dist/src/commands/wire.js

@@ -111,6 +111,38 @@ async function assertDomTargetIsWireable(projectRoot, domFilePath, domTargetPath
             '`--target <path>`.', 'target');
     }
 }
+async function resolveWireSubscriptDir(projectRoot, options) {
+    let subscriptDir = DEFAULT_BROWSER_SUBSCRIPT_DIR;
+    try {
+        const config = await loadConfig(projectRoot);
+        if (config.wire?.subscriptDir) {
+            subscriptDir = config.wire.subscriptDir;
+        }
+    }
+    catch (error) {
+        warn(`Using default wire.subscriptDir because fireforge.json could not be loaded: ${toError(error).message}`);
+    }
+    if (options.subscriptDir) {
+        if (!isContainedRelativePath(options.subscriptDir)) {
+            throw new InvalidArgumentError(`Subscript directory must stay within engine/: ${options.subscriptDir}`, 'subscriptDir');
+        }
+        subscriptDir = options.subscriptDir;
+    }
+    return subscriptDir;
+}
+async function ensureSubscriptSourceExists(projectRoot, subscriptDir, name, dryRun) {
+    const paths = getProjectPaths(projectRoot);
+    const subscriptPath = join(paths.engine, subscriptDir, `${name}.js`);
+    if (!(await pathExists(subscriptPath))) {
+        if (dryRun) {
+            info(`Note: ${subscriptDir}/${name}.js does not exist yet — the real wire command will require it before writing. Create the file before re-running without --dry-run.`);
+        }
+        else {
+            throw new InvalidArgumentError(`Subscript file not found: ${subscriptDir}/${name}.js\n` +
+                'Create the file in engine/ before wiring.', 'name');
+        }
+    }
+}
 /**
  * Wires a chrome subscript into the browser.
  *
@@ -144,23 +176,7 @@ export async function wireCommand(projectRoot, name, options = {}) {
         validateWireExpression(options.destroy, 'destroy expression');
     }
     consumeParserFallbackEvents();
-    // Resolve subscript directory: CLI flag > fireforge.json > default
-    let subscriptDir = DEFAULT_BROWSER_SUBSCRIPT_DIR;
-    try {
-        const config = await loadConfig(projectRoot);
-        if (config.wire?.subscriptDir) {
-            subscriptDir = config.wire.subscriptDir;
-        }
-    }
-    catch (error) {
-        warn(`Using default wire.subscriptDir because fireforge.json could not be loaded: ${toError(error).message}`);
-    }
-    if (options.subscriptDir) {
-        if (!isContainedRelativePath(options.subscriptDir)) {
-            throw new InvalidArgumentError(`Subscript directory must stay within engine/: ${options.subscriptDir}`, 'subscriptDir');
-        }
-        subscriptDir = options.subscriptDir;
-    }
+    const subscriptDir = await resolveWireSubscriptDir(projectRoot, options);
     // Validate DOM fragment file exists and compute path relative to engine root.
     //
     // Accepts three shapes:
@@ -235,21 +251,7 @@ export async function wireCommand(projectRoot, name, options = {}) {
     // plausible plan and the non-dry-run invocation then errored. The
     // info line surfaces the mismatch in preview mode so the operator
     // can act on the warning before re-running without --dry-run.
-    if (!options.dryRun) {
-        const paths = getProjectPaths(projectRoot);
-        const subscriptPath = join(paths.engine, subscriptDir, `${name}.js`);
-        if (!(await pathExists(subscriptPath))) {
-            throw new InvalidArgumentError(`Subscript file not found: ${subscriptDir}/${name}.js\n` +
-                'Create the file in engine/ before wiring.', 'name');
-        }
-    }
-    else {
-        const paths = getProjectPaths(projectRoot);
-        const subscriptPath = join(paths.engine, subscriptDir, `${name}.js`);
-        if (!(await pathExists(subscriptPath))) {
-            info(`Note: ${subscriptDir}/${name}.js does not exist yet — the real wire command will require it before writing. Create the file before re-running without --dry-run.`);
-        }
-    }
+    await ensureSubscriptSourceExists(projectRoot, subscriptDir, name, options.dryRun ?? false);
     if (options.dryRun) {
         printWireDryRun(getProjectPaths(projectRoot).engine, name, subscriptDir, domFilePath, domTargetPath, options);
         return;

package/dist/src/core/config.d.ts

@@ -9,8 +9,8 @@
  */
 import type { FireForgeConfig } from '../types/config.js';
 export { mutateConfig } from './config-mutate.js';
-export { CONFIG_FILENAME, CONFIGS_DIR, ENGINE_DIR, FIREFORGE_DIR, getProjectPaths, PATCHES_DIR, SRC_DIR, STATE_FILENAME, SUPPORTED_CONFIG_PATHS, SUPPORTED_CONFIG_ROOT_KEYS, } from './config-paths.js';
-export { loadState, saveState, updateState, validateFireForgeState } from './config-state.js';
+export { CONFIG_FILENAME, FIREFORGE_DIR, getProjectPaths, STATE_FILENAME, SUPPORTED_CONFIG_PATHS, SUPPORTED_CONFIG_ROOT_KEYS, } from './config-paths.js';
+export { loadState, saveState, updateState } from './config-state.js';
 export { validateConfig } from './config-validate.js';
 /**
  * Checks if a fireforge.json exists in the given directory.

package/dist/src/core/config.js

@@ -17,8 +17,8 @@ import { validateConfig } from './config-validate.js';
 import { createSiblingLockPath, withFileLock } from './file-lock.js';
 // ---- re-exports ----
 export { mutateConfig } from './config-mutate.js';
-export { CONFIG_FILENAME, CONFIGS_DIR, ENGINE_DIR, FIREFORGE_DIR, getProjectPaths, PATCHES_DIR, SRC_DIR, STATE_FILENAME, SUPPORTED_CONFIG_PATHS, SUPPORTED_CONFIG_ROOT_KEYS, } from './config-paths.js';
-export { loadState, saveState, updateState, validateFireForgeState } from './config-state.js';
+export { CONFIG_FILENAME, FIREFORGE_DIR, getProjectPaths, STATE_FILENAME, SUPPORTED_CONFIG_PATHS, SUPPORTED_CONFIG_ROOT_KEYS, } from './config-paths.js';
+export { loadState, saveState, updateState } from './config-state.js';
 export { validateConfig } from './config-validate.js';
 // ---- config I/O (stays here because it bridges paths + validation) ----
 /**

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

@@ -8,7 +8,7 @@ import { copyFile, ensureDir, pathExists, readText, removeFile } from '../utils/
 import { verbose } from '../utils/logger.js';
 import { applyCustomFtlFile, describeLocaleFtlJarMnRegistration, removeCustomFtlJarMnEntry, } from './furnace-apply-ftl.js';
 import { CUSTOM_ELEMENTS_JS, JAR_MN } from './furnace-constants.js';
-import { addCustomElementRegistration, addJarMnEntries, validateCustomElementRegistration, validateJarMnEntries, } from './furnace-registration.js';
+import { addCustomElementRegistration, addJarMnEntries, validateCustomElementRegistration, validateJarMnInsertionForFiles, } from './furnace-registration.js';
 import { recordCreatedDir, snapshotFile } from './furnace-rollback.js';
 import { checkRegistrationConsistency } from './furnace-validate-registration.js';
 import { isGitRepository } from './git.js';
@@ -352,7 +352,7 @@ async function buildCustomDryRunActions(name, componentDir, engineDir, config, t
         .map((entry) => entry.name);
     if (copiedFileNames.length > 0) {
         try {
-            await validateJarMnEntries(engineDir, name, copiedFileNames);
+            await validateJarMnInsertionForFiles(engineDir, name, copiedFileNames);
         }
         catch (error) {
             stepErrors.push({

package/dist/src/core/furnace-config-array-utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Shared string-array parsing for furnace.json validation. Lives in its own
+ * module so `furnace-config-custom.ts` and `furnace-config-tokens.ts` can use
+ * it without importing `furnace-config.ts`, which would create import cycles.
+ */
+/**
+ * Parses a JSON array-of-strings field from raw furnace config data.
+ * @param value - Raw value from JSON
+ * @param fieldName - Field label for error messages
+ */
+export declare function parseStringArray(value: unknown, fieldName: string): string[];

package/dist/src/core/furnace-config-array-utils.js

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Shared string-array parsing for furnace.json validation. Lives in its own
+ * module so `furnace-config-custom.ts` and `furnace-config-tokens.ts` can use
+ * it without importing `furnace-config.ts`, which would create import cycles.
+ */
+import { FurnaceError } from '../errors/furnace.js';
+import { isArray, isString } from '../utils/validation.js';
+/**
+ * Parses a JSON array-of-strings field from raw furnace config data.
+ * @param value - Raw value from JSON
+ * @param fieldName - Field label for error messages
+ */
+export function parseStringArray(value, fieldName) {
+    if (!isArray(value)) {
+        throw new FurnaceError(`Furnace config: "${fieldName}" must be an array`);
+    }
+    const items = [];
+    for (const item of value) {
+        if (!isString(item)) {
+            throw new FurnaceError(`Furnace config: "${fieldName}" array must contain only strings`);
+        }
+        items.push(item);
+    }
+    return items;
+}
+//# sourceMappingURL=furnace-config-array-utils.js.map

package/dist/src/core/furnace-config-custom.js

@@ -9,7 +9,7 @@
 import { FurnaceError } from '../errors/furnace.js';
 import { isExplicitAbsolutePath } from '../utils/paths.js';
 import { isBoolean, isString } from '../utils/validation.js';
-import { parseStringArray } from './furnace-config.js';
+import { parseStringArray } from './furnace-config-array-utils.js';
 import { validateSharedFtl } from './shared-ftl.js';
 /**
  * Validates a custom component config object.

package/dist/src/core/furnace-config-tokens.js

@@ -6,7 +6,7 @@
  */
 import { FurnaceError } from '../errors/furnace.js';
 import { isContainedRelativePath } from '../utils/paths.js';
-import { parseStringArray } from './furnace-config.js';
+import { parseStringArray } from './furnace-config-array-utils.js';
 /**
  * Validates a `tokenHostDocuments` raw value. Each entry must be a non-empty
  * relative path contained in the engine tree. Throws `FurnaceError` on

package/dist/src/core/furnace-config.d.ts

@@ -38,12 +38,6 @@ export declare function getFurnacePaths(root: string): FurnacePaths;
  * @returns True if furnace.json exists
  */
 export declare function furnaceConfigExists(root: string): Promise<boolean>;
-/**
- * Validates an override component config object.
- * @param data - Raw data to validate
- * @param name - Component name for error messages
- */
-export declare function parseStringArray(value: unknown, fieldName: string): string[];
 /**
  * Migrates a furnace config from an older schema version to the current one.
  * Returns the data unchanged if it is already at the current version.

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

@@ -4,8 +4,9 @@ import { FurnaceError } from '../errors/furnace.js';
 import { toError } from '../utils/errors.js';
 import { pathExists, readJson, writeJson } from '../utils/fs.js';
 import { warn } from '../utils/logger.js';
-import { isArray, isObject, isString } from '../utils/validation.js';
+import { isObject, isString } from '../utils/validation.js';
 import { FIREFORGE_DIR } from './config.js';
+import { parseStringArray } from './furnace-config-array-utils.js';
 import { parseCustomConfig } from './furnace-config-custom.js';
 import { validateRuntimeVariables, validateTokenHostDocuments } from './furnace-config-tokens.js';
 import { resolveFtlDir } from './furnace-constants.js';
@@ -51,19 +52,6 @@ export async function furnaceConfigExists(root) {
  * @param data - Raw data to validate
  * @param name - Component name for error messages
  */
-export function parseStringArray(value, fieldName) {
-    if (!isArray(value)) {
-        throw new FurnaceError(`Furnace config: "${fieldName}" must be an array`);
-    }
-    const items = [];
-    for (const item of value) {
-        if (!isString(item)) {
-            throw new FurnaceError(`Furnace config: "${fieldName}" array must contain only strings`);
-        }
-        items.push(item);
-    }
-    return items;
-}
 function parseOverrideConfig(data, name) {
     const validTypes = ['css-only', 'full'];
     if (!isString(data['type']) || !validTypes.includes(data['type'])) {

package/dist/src/core/furnace-refresh.d.ts

@@ -3,10 +3,6 @@ export interface RefreshFileResult {
     status: 'merged' | 'conflict' | 'unchanged' | 'new-file';
     conflictMarkers?: number;
 }
-export interface RefreshResult {
-    files: RefreshFileResult[];
-    newBaseVersion: string;
-}
 /**
  * Refreshes a single override file against the current engine HEAD.
  *

package/dist/src/core/furnace-registration-ast.d.ts

@@ -15,7 +15,6 @@ export interface RegistrationWriteOptions {
     markerComment?: string;
 }
 export { removeCustomElementRegistration } from './furnace-registration-remove.js';
-export { CUSTOM_ELEMENTS_JS, JAR_MN } from './furnace-constants.js';
 /**
  * Adds a custom element registration entry to customElements.js.
  *

package/dist/src/core/furnace-registration-ast.js

@@ -49,7 +49,6 @@ function formatMarkerSuffix(markerComment) {
 // Re-export from split modules so existing import sites continue working
 export { removeCustomElementRegistration } from './furnace-registration-remove.js';
 // Re-export constants so existing import sites continue working
-export { CUSTOM_ELEMENTS_JS, JAR_MN } from './furnace-constants.js';
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------

package/dist/src/core/furnace-registration.d.ts

@@ -1,4 +1,3 @@
-export { CUSTOM_ELEMENTS_JS, JAR_MN } from './furnace-constants.js';
 export { addCustomElementRegistration, removeCustomElementRegistration, validateCustomElementRegistration, } from './furnace-registration-ast.js';
 /**
  * Adds jar.mn entries that map chrome:// URIs to on-disk paths for a
@@ -27,7 +26,7 @@ export { addCustomElementRegistration, removeCustomElementRegistration, validate
  *
  * If Firefox upstream changes the jar.mn section ordering or switches to a
  * different resource registration mechanism, the preflight validation in
- * `validateJarMnEntries` will catch the format mismatch before any writes
+ * `validateJarMnInsertionForFiles` will catch the format mismatch before any writes
  * occur.
  *
  * @param engineDir - Path to the Firefox engine source root
@@ -76,4 +75,4 @@ export declare function removeJarMnEntries(engineDir: string, tagName: string):
  * Validates that jar.mn entries *could* be added without writing anything.
  * Used by dry-run to surface structural problems early.
  */
-export declare function validateJarMnEntries(engineDir: string, tagName: string, files: string[]): Promise<void>;
+export declare function validateJarMnInsertionForFiles(engineDir: string, tagName: string, files: string[]): Promise<void>;

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

@@ -21,7 +21,6 @@ function detectJarMnIndent(lines) {
     return '   ';
 }
 // Re-export everything from the AST module so existing imports keep working
-export { CUSTOM_ELEMENTS_JS, JAR_MN } from './furnace-constants.js';
 export { addCustomElementRegistration, removeCustomElementRegistration, validateCustomElementRegistration, } from './furnace-registration-ast.js';
 import { JAR_MN } from './furnace-constants.js';
 /**
@@ -51,7 +50,7 @@ import { JAR_MN } from './furnace-constants.js';
  *
  * If Firefox upstream changes the jar.mn section ordering or switches to a
  * different resource registration mechanism, the preflight validation in
- * `validateJarMnEntries` will catch the format mismatch before any writes
+ * `validateJarMnInsertionForFiles` will catch the format mismatch before any writes
  * occur.
  *
  * @param engineDir - Path to the Firefox engine source root
@@ -237,7 +236,7 @@ export async function removeJarMnEntries(engineDir, tagName) {
  * Validates that jar.mn entries *could* be added without writing anything.
  * Used by dry-run to surface structural problems early.
  */
-export async function validateJarMnEntries(engineDir, tagName, files) {
+export async function validateJarMnInsertionForFiles(engineDir, tagName, files) {
     const filePath = join(engineDir, JAR_MN);
     if (!(await pathExists(filePath))) {
         throw new FurnaceError('jar.mn not found in engine', tagName);

package/dist/src/core/git-file-ops.d.ts

@@ -1,10 +1,4 @@
 import type { GitStatusEntry } from './git-base.js';
-/**
- * Discards changes to a specific file.
- * @param repoDir - Repository directory
- * @param filePath - Path to the file (relative to repo)
- */
-export declare function discardFile(repoDir: string, filePath: string): Promise<void>;
 /**
  * Restores a tracked path from HEAD, including staged changes.
  * @param repoDir - Repository directory

package/dist/src/core/git-file-ops.js

@@ -5,14 +5,6 @@ import { GitError } from '../errors/git.js';
 import { removeFile } from '../utils/fs.js';
 import { exec } from '../utils/process.js';
 import { ensureGit, git } from './git-base.js';
-/**
- * Discards changes to a specific file.
- * @param repoDir - Repository directory
- * @param filePath - Path to the file (relative to repo)
- */
-export async function discardFile(repoDir, filePath) {
-    await restoreTrackedPath(repoDir, filePath);
-}
 /**
  * Restores a tracked path from HEAD, including staged changes.
  * @param repoDir - Repository directory

package/dist/src/core/git-status.d.ts

@@ -20,12 +20,6 @@ export declare function getWorkingTreeStatus(repoDir: string): Promise<GitStatus
  * @returns Status entries with untracked directories expanded to individual files
  */
 export declare function expandUntrackedDirectoryEntries(repoDir: string, entries: GitStatusEntry[]): Promise<GitStatusEntry[]>;
-/**
- * Gets the list of modified files.
- * @param repoDir - Repository directory
- * @returns List of modified file paths
- */
-export declare function getModifiedFiles(repoDir: string): Promise<string[]>;
 /**
  * Gets all untracked files (including files inside untracked directories).
  * @param repoDir - Repository directory
@@ -55,11 +49,3 @@ export declare function getModifiedFilesInDir(repoDir: string, dir: string): Pro
  * @returns List of dirty file paths
  */
 export declare function getDirtyFiles(repoDir: string, files: string[]): Promise<string[]>;
-/**
- * Lists all files in a directory (tracked and untracked, respecting .gitignore).
- * Combines git ls-files for tracked files and --others for untracked files.
- * @param repoDir - Repository directory
- * @param dir - Directory path (relative to repo root)
- * @returns List of file paths relative to repo root
- */
-export declare function listAllFilesInDir(repoDir: string, dir: string): Promise<string[]>;

package/dist/src/core/git-status.js

@@ -72,15 +72,6 @@ export async function expandUntrackedDirectoryEntries(repoDir, entries) {
     }
     return expanded;
 }
-/**
- * Gets the list of modified files.
- * @param repoDir - Repository directory
- * @returns List of modified file paths
- */
-export async function getModifiedFiles(repoDir) {
-    const entries = await getWorkingTreeStatus(repoDir);
-    return entries.map((entry) => entry.file);
-}
 /**
  * Gets all untracked files (including files inside untracked directories).
  * @param repoDir - Repository directory
@@ -134,19 +125,4 @@ export async function getDirtyFiles(repoDir, files) {
     const untracked = untrackedOutput.split('\n').filter((line) => line.trim().length > 0);
     return [...new Set([...tracked, ...untracked])].sort();
 }
-/**
- * Lists all files in a directory (tracked and untracked, respecting .gitignore).
- * Combines git ls-files for tracked files and --others for untracked files.
- * @param repoDir - Repository directory
- * @param dir - Directory path (relative to repo root)
- * @returns List of file paths relative to repo root
- */
-export async function listAllFilesInDir(repoDir, dir) {
-    await ensureGit();
-    const trackedOutput = await git(['ls-files', '--', dir], repoDir);
-    const trackedFiles = trackedOutput.split('\n').filter((line) => line.trim().length > 0);
-    const untrackedOutput = await git(['ls-files', '--others', '--exclude-standard', '--', dir], repoDir);
-    const untrackedFiles = untrackedOutput.split('\n').filter((line) => line.trim().length > 0);
-    return [...new Set([...trackedFiles, ...untrackedFiles])].sort();
-}
 //# sourceMappingURL=git-status.js.map

package/dist/src/core/git.d.ts

@@ -1,4 +1,3 @@
-export type { GitStatusEntry } from './git-base.js';
 /**
  * Checks if a directory is a git repository.
  * @param dir - Directory to check

package/dist/src/core/mach.d.ts

@@ -1,6 +1,6 @@
 import { type SmokeLineCallback, type SmokeRunResult } from '../utils/process.js';
-export { attemptMozinfoRewrite, type BuildArtifactCheck, buildArtifactMismatchMessage, hasBuildArtifacts, hasRunnableBundle, type MozinfoRewriteResult, type RunnableBundleCheck, } from './mach-build-artifacts.js';
-export { generateMozconfig, type MozconfigVariables } from './mach-mozconfig.js';
+export { attemptMozinfoRewrite, buildArtifactMismatchMessage, hasBuildArtifacts, hasRunnableBundle, } from './mach-build-artifacts.js';
+export { generateMozconfig } from './mach-mozconfig.js';
 export { ensurePython, resetResolvedPython } from './mach-python.js';
 /**
  * Ensures mach is available in the engine directory.

package/dist/src/core/patch-apply.d.ts

@@ -6,8 +6,8 @@ import type { ImportSummary, PatchResult } from '../types/commands/index.js';
 export { PatchError } from '../errors/patch.js';
 export { countPatches, discoverPatches, getAllTargetFilesFromPatch, getTargetFileFromPatch, isNewFilePatch, } from './patch-files.js';
 export { withPatchDirectoryLock } from './patch-lock.js';
-export { extractAffectedFiles, extractOrder, isNewFileInPatch, parseHunksForFile, } from './patch-parse.js';
-export { applyPatchToContent, extractNewFileContent, extractNewFileContentFromDiff, } from './patch-transform.js';
+export { extractAffectedFiles, extractOrder, isNewFileInPatch } from './patch-parse.js';
+export { applyPatchToContent, extractNewFileContent } from './patch-transform.js';
 /**
  * Applies all patches in order. Rolls back all successfully applied
  * patches when one fails so the engine directory stays clean.

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

@@ -21,8 +21,8 @@ import { applyPatchToContent, extractNewFileContent } from './patch-transform.js
 export { PatchError } from '../errors/patch.js';
 export { countPatches, discoverPatches, getAllTargetFilesFromPatch, getTargetFileFromPatch, isNewFilePatch, } from './patch-files.js';
 export { withPatchDirectoryLock } from './patch-lock.js';
-export { extractAffectedFiles, extractOrder, isNewFileInPatch, parseHunksForFile, } from './patch-parse.js';
-export { applyPatchToContent, extractNewFileContent, extractNewFileContentFromDiff, } from './patch-transform.js';
+export { extractAffectedFiles, extractOrder, isNewFileInPatch } from './patch-parse.js';
+export { applyPatchToContent, extractNewFileContent } from './patch-transform.js';
 /**
  * Applies a single patch.
  * @param patch - Patch info

package/dist/src/core/patch-lint-reexports.d.ts

@@ -2,8 +2,5 @@
  * Public re-exports for {@link ./patch-lint.ts}. Split out so the
  * orchestrator stays within the ESLint `max-lines` budget.
  */
-export { runCheckJs } from './patch-lint-checkjs.js';
-export { buildPatchQueueContext, collectNewFileCreatorsByPath, type ExtractedSpecifier, extractImportSpecifiers, extractImportSpecifiersWithLines, findForwardImportIgnoreLines, FORWARD_IMPORT_IGNORE_MARKER, isForwardImportableFile, lintPatchQueue, lintPatchQueueDuplicateCreations, lintPatchQueueForwardImports, type PatchQueueContext, type PatchQueueEntry, } from './patch-lint-cross.js';
+export { buildPatchQueueContext, collectNewFileCreatorsByPath, extractImportSpecifiers, extractImportSpecifiersWithLines, findForwardImportIgnoreLines, FORWARD_IMPORT_IGNORE_MARKER, isForwardImportableFile, lintPatchQueue, lintPatchQueueDuplicateCreations, lintPatchQueueForwardImports, type PatchQueueContext, type PatchQueueEntry, } from './patch-lint-cross.js';
 export { buildModifiedFileAdditionsFromDiff, detectNewFilesInDiff } from './patch-lint-diff.js';
-export { type JsDocCheck, type JsDocIssue, validateExportJsDoc } from './patch-lint-jsdoc.js';
-export { resolvePatchOwnedChromeScripts, resolvePatchOwnedSysMjs } from './patch-lint-ownership.js';

package/dist/src/core/patch-lint-reexports.js

@@ -3,9 +3,6 @@
  * Public re-exports for {@link ./patch-lint.ts}. Split out so the
  * orchestrator stays within the ESLint `max-lines` budget.
  */
-export { runCheckJs } from './patch-lint-checkjs.js';
 export { buildPatchQueueContext, collectNewFileCreatorsByPath, extractImportSpecifiers, extractImportSpecifiersWithLines, findForwardImportIgnoreLines, FORWARD_IMPORT_IGNORE_MARKER, isForwardImportableFile, lintPatchQueue, lintPatchQueueDuplicateCreations, lintPatchQueueForwardImports, } from './patch-lint-cross.js';
 export { buildModifiedFileAdditionsFromDiff, detectNewFilesInDiff } from './patch-lint-diff.js';
-export { validateExportJsDoc } from './patch-lint-jsdoc.js';
-export { resolvePatchOwnedChromeScripts, resolvePatchOwnedSysMjs } from './patch-lint-ownership.js';
 //# sourceMappingURL=patch-lint-reexports.js.map

package/dist/src/core/patch-manifest.d.ts

@@ -4,9 +4,8 @@
  * Callers should continue to import from this module; the internal split
  * is an implementation detail.
  */
-export type { PatchManifestConsistencyIssue } from './patch-manifest-consistency.js';
 export { rebuildPatchesManifest, validatePatchesManifestConsistency, } from './patch-manifest-consistency.js';
-export { addPatchToManifest, loadPatchesManifest, PatchDeleteRollbackError, PATCHES_MANIFEST, type PatchRenameEntry, removePatchFileAndManifest, removePatchFromManifest, renumberPatchesInManifest, savePatchesManifest, } from './patch-manifest-io.js';
+export { addPatchToManifest, loadPatchesManifest, PATCHES_MANIFEST, type PatchRenameEntry, removePatchFileAndManifest, renumberPatchesInManifest, savePatchesManifest, } from './patch-manifest-io.js';
 export { checkVersionCompatibility, findPatchesAffectingFile, getClaimedFiles, stampPatchVersions, validatePatchIntegrity, } from './patch-manifest-query.js';
 export { resolvePatchIdentifier } from './patch-manifest-resolve.js';
 export { validatePatchesManifest } from './patch-manifest-validate.js';

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

@@ -6,7 +6,7 @@
  * is an implementation detail.
  */
 export { rebuildPatchesManifest, validatePatchesManifestConsistency, } from './patch-manifest-consistency.js';
-export { addPatchToManifest, loadPatchesManifest, PatchDeleteRollbackError, PATCHES_MANIFEST, removePatchFileAndManifest, removePatchFromManifest, renumberPatchesInManifest, savePatchesManifest, } from './patch-manifest-io.js';
+export { addPatchToManifest, loadPatchesManifest, PATCHES_MANIFEST, removePatchFileAndManifest, renumberPatchesInManifest, savePatchesManifest, } from './patch-manifest-io.js';
 export { checkVersionCompatibility, findPatchesAffectingFile, getClaimedFiles, stampPatchVersions, validatePatchIntegrity, } from './patch-manifest-query.js';
 export { resolvePatchIdentifier } from './patch-manifest-resolve.js';
 export { validatePatchesManifest } from './patch-manifest-validate.js';

package/dist/src/core/signal-critical.d.ts

@@ -29,11 +29,6 @@
  * persist pair," not "postpone exit indefinitely."
  */
 export declare function runInSignalCriticalSection<T>(label: string, fn: () => Promise<T>): Promise<T>;
-/**
- * Returns true while any critical section is currently running. Used by the
- * bin entry point's signal handler to decide whether to await before exit.
- */
-export declare function hasActiveCriticalSection(): boolean;
 /**
  * Waits for every active critical section to complete or for `timeoutMs` to
  * elapse, whichever comes first. Never rejects: a section that throws still
@@ -41,9 +36,3 @@ export declare function hasActiveCriticalSection(): boolean;
  * cleans up in `finally`.
  */
 export declare function waitForActiveCriticalSections(timeoutMs: number): Promise<void>;
-/**
- * Test-only helper: clears the critical-section registry. Production code
- * must never call this — it voids the exit-ordering guarantee for any
- * section still in flight.
- */
-export declare function resetCriticalSectionsForTests(): void;

package/dist/src/core/signal-critical.js

@@ -47,13 +47,6 @@ export async function runInSignalCriticalSection(label, fn) {
         resolver();
     }
 }
-/**
- * Returns true while any critical section is currently running. Used by the
- * bin entry point's signal handler to decide whether to await before exit.
- */
-export function hasActiveCriticalSection() {
-    return activeSections.size > 0;
-}
 /**
  * Waits for every active critical section to complete or for `timeoutMs` to
  * elapse, whichever comes first. Never rejects: a section that throws still
@@ -69,12 +62,4 @@ export async function waitForActiveCriticalSections(timeoutMs) {
         new Promise((resolve) => setTimeout(resolve, timeoutMs)),
     ]);
 }
-/**
- * Test-only helper: clears the critical-section registry. Production code
- * must never call this — it voids the exit-ordering guarantee for any
- * section still in flight.
- */
-export function resetCriticalSectionsForTests() {
-    activeSections.clear();
-}
 //# sourceMappingURL=signal-critical.js.map

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

@@ -1,7 +1,7 @@
 /**
  * Wire targets barrel — re-exports all wiring target modules.
  */
-export { addDestroyAST, addDestroyToBrowserInit, legacyAddDestroy } from './wire-destroy.js';
-export { addDomFragment, addDomFragmentTokenized, legacyAddDomFragment, } from './wire-dom-fragment.js';
-export { addInitAST, addInitToBrowserInit, legacyAddInit } from './wire-init.js';
-export { addSubscriptAST, addSubscriptToBrowserMain, legacyAddSubscript, } from './wire-subscript.js';
+export { addDestroyToBrowserInit } from './wire-destroy.js';
+export { addDomFragment } from './wire-dom-fragment.js';
+export { addInitToBrowserInit } from './wire-init.js';
+export { addSubscriptToBrowserMain } from './wire-subscript.js';

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

@@ -2,8 +2,8 @@
 /**
  * Wire targets barrel — re-exports all wiring target modules.
  */
-export { addDestroyAST, addDestroyToBrowserInit, legacyAddDestroy } from './wire-destroy.js';
-export { addDomFragment, addDomFragmentTokenized, legacyAddDomFragment, } from './wire-dom-fragment.js';
-export { addInitAST, addInitToBrowserInit, legacyAddInit } from './wire-init.js';
-export { addSubscriptAST, addSubscriptToBrowserMain, legacyAddSubscript, } from './wire-subscript.js';
+export { addDestroyToBrowserInit } from './wire-destroy.js';
+export { addDomFragment } from './wire-dom-fragment.js';
+export { addInitToBrowserInit } from './wire-init.js';
+export { addSubscriptToBrowserMain } from './wire-subscript.js';
 //# sourceMappingURL=wire-targets.js.map

package/dist/src/utils/logger.d.ts

@@ -3,11 +3,6 @@
  * @param enabled - Whether to enable verbose output
  */
 export declare function setVerbose(enabled: boolean): void;
-/**
- * Checks if verbose mode is enabled.
- * @returns True if verbose mode is enabled
- */
-export declare function isVerbose(): boolean;
 /**
  * Displays a verbose/debug message (only shown if verbose mode is enabled).
  * @param message - Message to display

package/dist/src/utils/logger.js

@@ -14,7 +14,7 @@ export function setVerbose(enabled) {
  * Checks if verbose mode is enabled.
  * @returns True if verbose mode is enabled
  */
-export function isVerbose() {
+function isVerbose() {
     return verboseMode;
 }
 /**
@@ -22,7 +22,7 @@ export function isVerbose() {
  * @param message - Message to display
  */
 export function verbose(message) {
-    if (verboseMode) {
+    if (isVerbose()) {
         p.log.info(`[debug] ${message}`);
     }
 }

package/dist/src/utils/package-root.d.ts

@@ -14,8 +14,6 @@ interface PackageMetadata {
  * within a process.
  */
 export declare function getPackageRoot(): string;
-/** Clears the cached package root for testing. */
-export declare function resetPackageRootCacheForTests(): void;
 /** @internal */
 export declare function isFireForgePackageMetadata(pkg: PackageMetadata): boolean;
 /** Reads the current package version from the repository root package manifest. */

package/dist/src/utils/package-root.js

@@ -53,10 +53,6 @@ export function getPackageRoot() {
         current = parent;
     }
 }
-/** Clears the cached package root for testing. */
-export function resetPackageRootCacheForTests() {
-    cachedPackageRoot = undefined;
-}
 /** @internal */
 export function isFireForgePackageMetadata(pkg) {
     if (typeof pkg.bin !== 'object' || pkg.bin === null || Array.isArray(pkg.bin)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hominis/fireforge",
-  "version": "0.19.3",
+  "version": "0.19.4",
   "description": "FireForge — a build tool for customizing Firefox",
   "type": "module",
   "main": "./dist/src/index.js",