@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,125 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/** Path to customElements.js within the engine source tree */
-export const CUSTOM_ELEMENTS_JS = 'toolkit/content/customElements.js';
-import { normalizePathSlashes } from '../utils/paths.js';
-/** Path to jar.mn within the engine source tree (toolkit global) */
-export const JAR_MN = 'toolkit/content/jar.mn';
-/**
- * Upstream home of the MozLitElement widget sources.
- *
- * The trailing slash is not included: `build-audit-transforms.ts` needs
- * `${WIDGETS_DIR}/` and its ordered prefix table depends on that slash, so
- * appending it at the one site that wants it keeps the others correct.
- */
-export const WIDGETS_DIR = 'toolkit/content/widgets';
-/** Chrome URL prefix under which a component's `.mjs` files deploy. */
-export const CHROME_ELEMENTS_URL_PREFIX = 'chrome://global/content/elements/';
-/** Default Fluent localization directory for toolkit global components, relative to engine root */
-export const FTL_DIR = 'toolkit/locales/en-US/toolkit/global';
-/**
- * Engine-relative root every browser-chrome / xpcshell test scaffold lives
- * under, trailing slash included. A `--test-dir` override must stay below
- * it so the `browser/base/moz.build` manifest registration keeps working.
- */
-export const BROWSER_TEST_SCAFFOLD_ROOT = 'browser/base/content/test/';
-/**
- * Suffix for the per-binary xpcshell scaffold parent directory. Components
- * created with `furnace create --with-tests --xpcshell` land at
- * `browser/base/content/test/<binaryName>${XPCSHELL_TEST_DIR_SUFFIX}/<component>/`.
- * Centralised so `create` / `remove` / `rename` / `validate` all agree on the
- * path template.
- */
-const XPCSHELL_TEST_DIR_SUFFIX = '-xpcshell';
-/**
- * Returns the engine-relative directory that holds xpcshell scaffolds for
- * a given binary. Matches the form `create-xpcshell.ts` writes and the
- * path `remove.ts` / `rename.ts` / `validate.ts` must clean up.
- */
-export function xpcshellTestParentDir(binaryName) {
-    return `${BROWSER_TEST_SCAFFOLD_ROOT}${binaryName}${XPCSHELL_TEST_DIR_SUFFIX}`;
-}
-/**
- * Resolves the engine-relative directory a browser-chrome scaffold is
- * written to: the `--test-dir` override when given, else
- * `browser/base/content/test/<binaryName>`. The scaffolder and the
- * dry-run / success formatters resolve through this one function, so the
- * printed plan cannot disagree with the files that land on disk.
- */
-export function resolveBrowserChromeTestDir(binaryName, override) {
-    return override ?? `${BROWSER_TEST_SCAFFOLD_ROOT}${binaryName}`;
-}
-/**
- * Resolves the engine-relative directory an xpcshell scaffold is written
- * to. A `--test-dir` override names the final directory (no per-component
- * segment is appended). The default is
- * `browser/base/content/test/<binaryName>-xpcshell/<componentName>`.
- */
-export function resolveXpcshellTestDir(binaryName, componentName, override) {
-    return override ?? `${xpcshellTestParentDir(binaryName)}/${componentName}`;
-}
-/** File extensions that constitute a Furnace component's source files. */
-const COMPONENT_FILE_EXTENSIONS = ['.mjs', '.css', '.ftl'];
-/** Returns true when `fileName` has one of the standard component file extensions. */
-export function isComponentSourceFile(fileName) {
-    return COMPONENT_FILE_EXTENSIONS.some((ext) => fileName.endsWith(ext));
-}
-/**
- * Resolves the FTL base path, preferring the user-configured value from
- * `furnace.json` over the built-in default.
- */
-export function resolveFtlDir(configuredPath) {
-    return configuredPath ?? FTL_DIR;
-}
-/**
- * Resolves the chrome sub-path that `document.l10n` / `insertFTLIfNeeded`
- * expects for a given `ftlBasePath`. Strips the mandatory `locales/<LOCALE>/`
- * segment. For the default `toolkit/locales/en-US/toolkit/global` this yields
- * `toolkit/global`.
- *
- * Returns `undefined` when no `locales/<LOCALE>/` segment is present. Callers
- * must treat that as "cannot confidently locate the locale jar.mn entry" and
- * degrade gracefully rather than inventing a path.
- */
-export function resolveFtlChromeSubPath(ftlBasePath) {
-    const path = normalizePathSlashes(ftlBasePath ?? FTL_DIR);
-    const match = /^(.*?)\/locales\/[^/]+\/(.+?)\/?$/.exec(path);
-    if (!match?.[2])
-        return undefined;
-    return match[2];
-}
-/**
- * Returns the engine-relative locale jar.mn that owns the FTL tree for a
- * given `ftlBasePath`. For the default toolkit tree this yields
- * `toolkit/locales/jar.mn`.
- *
- * Returns `undefined` when the path does not contain a `locales/` segment.
- * Callers must treat that as "cannot locate" and degrade gracefully.
- */
-export function resolveFtlLocaleJarMnPath(ftlBasePath) {
-    const path = normalizePathSlashes(ftlBasePath ?? FTL_DIR);
-    const match = /^(.*?)\/locales\/[^/]+\//.exec(path);
-    if (!match?.[1])
-        return undefined;
-    return `${match[1]}/locales/jar.mn`;
-}
-/**
- * Converts a kebab-case tag name to PascalCase class name.
- * e.g. "moz-sidebar-panel" → "MozSidebarPanel"
- */
-export function tagNameToClassName(tagName) {
-    return tagName
-        .split('-')
-        .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
-        .join('');
-}
-/**
- * Strips a known component prefix from a tag name to produce a concise
- * display name. Falls back to the full tag name when the prefix doesn't
- * match, so callers never receive an empty string.
- */
-export function stripComponentPrefix(tagName, componentPrefix) {
-    if (componentPrefix && tagName.startsWith(componentPrefix)) {
-        return tagName.slice(componentPrefix.length);
-    }
-    return tagName;
-}

package/dist/src/core/furnace-css-fragments.d.ts

@@ -1,96 +0,0 @@
-/**
- * Shared CSS fragments for Furnace widgets.
- *
- * Shadow-DOM isolation forces each widget stylesheet to carry its own copy
- * of genuinely shared CSS (keyframes, resets), and hand-syncing those copies
- * drifts. Instead, a workspace stylesheet declares an include directive
- * (a CSS block comment on its own line):
- *
- *     @fireforge-include shared-anims.css
- *
- * naming a fragment file in `components/shared/`. `furnace deploy` expands
- * the fragment into the *deployed* copy only (the workspace source stays
- * DRY), fencing the expansion between the directive line and a matching
- * `@fireforge-end-include` marker so re-deploys can refresh it idempotently.
- *
- * Drift contract: the apply fast-path and `furnace validate` compare the
- * *expanded* workspace source against the engine copy, so editing a fragment
- * surfaces as ordinary component drift and the next deploy refreshes every
- * consuming widget.
- */
-import type { ValidationIssue } from '../types/furnace.js';
-export { SHARED_FRAGMENTS_DIR } from './furnace-config.js';
-/**
- * Reads a shared fragment as the exact body an expansion inlines: the
- * trailing newline is dropped so the fenced block ends on the end marker.
- * One definition, so every consumer (expansion, validation, the stale
- * includer probe) compares the same bytes.
- */
-export declare function readFragmentSource(sharedDir: string, name: string): Promise<string>;
-/** Returns the fragment names referenced by `@fireforge-include` directives. */
-export declare function listFragmentIncludes(css: string): string[];
-/**
- * Collapses fenced fragment expansions back to their bare directives.
- * Inverse of {@link expandCssFragments}. Used to compare a deployed file
- * against its workspace source and to re-expand idempotently.
- */
-export declare function stripExpandedFragments(css: string): string;
-/**
- * Marks the lines of a stylesheet that belong to a fenced fragment
- * expansion: the directive, the inlined body and the end marker. Index `i`
- * is line `i + 1` of `css`. Fences are found exactly as
- * {@link stripExpandedFragments} finds them, so a bare directive or an
- * unterminated fence marks nothing. The patch-size metric reads this
- * off a file's post-image, because a hunk can start inside a span and
- * carry no directive of its own.
- */
-export declare function expandedFragmentLineMask(css: string): boolean[];
-/**
- * Expands every `@fireforge-include` directive in `css` with the current
- * content of its fragment file from `sharedDir`, fencing each expansion
- * with an end marker. Existing expansions are stripped first, so the
- * operation is idempotent and refreshes stale content.
- *
- * @param css - Stylesheet source (workspace or previously expanded)
- * @param sharedDir - Absolute path to the shared fragments directory
- * @returns Expanded stylesheet and the fragment names it consumed
- * @throws FurnaceError when a fragment is missing or itself contains an
- *   include directive (nesting is not supported)
- */
-export declare function expandCssFragments(css: string, sharedDir: string): Promise<{
-    expanded: string;
-    includes: string[];
-}>;
-/**
- * Extracts the fenced expansion bodies of a previously expanded stylesheet,
- * keyed by fragment name. Used by validate to compare a deployed expansion
- * against the current fragment source without re-deploying.
- */
-export declare function extractExpandedFragmentBodies(css: string): Map<string, string>;
-/**
- * Deploys one component file: CSS sources carrying include directives are
- * written as their fragment-expanded form. Everything else is a plain
- * copy. Extracted here so `applyCustomComponent` stays inside the
- * per-file line budget.
- *
- * @returns True when fragment expansion was applied
- */
-export declare function deployFileWithFragments(src: string, dest: string, sharedDir: string): Promise<boolean>;
-/**
- * Builds the dry-run description suffix for a component file copy,
- * naming the fragments an expansion would inline. Empty for plain copies.
- */
-export declare function describeFragmentExpansion(src: string): Promise<string>;
-/**
- * Validates fragment usage for one custom component: every directive must
- * name an existing fragment (`missing-fragment`, error), and a deployed
- * stylesheet's fenced expansion must match the current fragment source
- * (`stale-fragment-expansion`, warning → redeploy refreshes it).
- *
- * @param componentDir - Workspace directory of the component
- * @param tagName - Component tag name for issue attribution
- * @param sharedDir - Shared fragments directory
- * @param engineTargetDir - Deployed directory in the engine. Optional, and
- *   pre-deploy validation skips the staleness check.
- */
-export declare function validateCssFragments(componentDir: string, tagName: string, sharedDir: string, engineTargetDir?: string): Promise<ValidationIssue[]>;

package/dist/src/core/furnace-css-fragments.js

@@ -1,279 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Shared CSS fragments for Furnace widgets.
- *
- * Shadow-DOM isolation forces each widget stylesheet to carry its own copy
- * of genuinely shared CSS (keyframes, resets), and hand-syncing those copies
- * drifts. Instead, a workspace stylesheet declares an include directive
- * (a CSS block comment on its own line):
- *
- *     @fireforge-include shared-anims.css
- *
- * naming a fragment file in `components/shared/`. `furnace deploy` expands
- * the fragment into the *deployed* copy only (the workspace source stays
- * DRY), fencing the expansion between the directive line and a matching
- * `@fireforge-end-include` marker so re-deploys can refresh it idempotently.
- *
- * Drift contract: the apply fast-path and `furnace validate` compare the
- * *expanded* workspace source against the engine copy, so editing a fragment
- * surfaces as ordinary component drift and the next deploy refreshes every
- * consuming widget.
- */
-import { readdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { FurnaceError } from '../errors/furnace.js';
-import { copyFile, pathExists, readText, writeText } from '../utils/fs.js';
-export { SHARED_FRAGMENTS_DIR } from './furnace-config.js';
-// Local copy of the directory name for message text. Importing the
-// binding for value use keeps a single source of truth.
-import { SHARED_FRAGMENTS_DIR } from './furnace-config.js';
-const INCLUDE_PATTERN = /^\s*\/\*\s*@fireforge-include\s+([\w./-]+)\s*\*\/\s*$/;
-const END_INCLUDE_PATTERN = /^\s*\/\*\s*@fireforge-end-include\s+([\w./-]+)\s*\*\/\s*$/;
-/**
- * Reads a shared fragment as the exact body an expansion inlines: the
- * trailing newline is dropped so the fenced block ends on the end marker.
- * One definition, so every consumer (expansion, validation, the stale
- * includer probe) compares the same bytes.
- */
-export async function readFragmentSource(sharedDir, name) {
-    return (await readText(join(sharedDir, name))).replace(/\n$/, '');
-}
-/** Returns the fragment names referenced by `@fireforge-include` directives. */
-export function listFragmentIncludes(css) {
-    const names = [];
-    for (const line of css.split('\n')) {
-        const m = INCLUDE_PATTERN.exec(line);
-        if (m?.[1] && !names.includes(m[1]))
-            names.push(m[1]);
-    }
-    return names;
-}
-/**
- * Collapses fenced fragment expansions back to their bare directives.
- * Inverse of {@link expandCssFragments}. Used to compare a deployed file
- * against its workspace source and to re-expand idempotently.
- */
-export function stripExpandedFragments(css) {
-    const lines = css.split('\n');
-    const out = [];
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i] ?? '';
-        out.push(line);
-        const inc = INCLUDE_PATTERN.exec(line);
-        if (!inc?.[1])
-            continue;
-        // A bare directive (workspace file) has no fence to strip. Only skip
-        // the expansion body when a matching end marker actually follows.
-        // Otherwise an unterminated fence would silently eat the rest of the
-        // file.
-        let endIndex = -1;
-        for (let j = i + 1; j < lines.length; j++) {
-            if (END_INCLUDE_PATTERN.exec(lines[j] ?? '')?.[1] === inc[1]) {
-                endIndex = j;
-                break;
-            }
-        }
-        if (endIndex !== -1)
-            i = endIndex;
-    }
-    return out.join('\n');
-}
-/**
- * Marks the lines of a stylesheet that belong to a fenced fragment
- * expansion: the directive, the inlined body and the end marker. Index `i`
- * is line `i + 1` of `css`. Fences are found exactly as
- * {@link stripExpandedFragments} finds them, so a bare directive or an
- * unterminated fence marks nothing. The patch-size metric reads this
- * off a file's post-image, because a hunk can start inside a span and
- * carry no directive of its own.
- */
-export function expandedFragmentLineMask(css) {
-    const lines = css.split('\n');
-    const mask = lines.map(() => false);
-    for (let i = 0; i < lines.length; i++) {
-        const inc = INCLUDE_PATTERN.exec(lines[i] ?? '');
-        if (!inc?.[1])
-            continue;
-        for (let j = i + 1; j < lines.length; j++) {
-            if (END_INCLUDE_PATTERN.exec(lines[j] ?? '')?.[1] !== inc[1])
-                continue;
-            mask.fill(true, i, j + 1);
-            i = j;
-            break;
-        }
-    }
-    return mask;
-}
-/**
- * Expands every `@fireforge-include` directive in `css` with the current
- * content of its fragment file from `sharedDir`, fencing each expansion
- * with an end marker. Existing expansions are stripped first, so the
- * operation is idempotent and refreshes stale content.
- *
- * @param css - Stylesheet source (workspace or previously expanded)
- * @param sharedDir - Absolute path to the shared fragments directory
- * @returns Expanded stylesheet and the fragment names it consumed
- * @throws FurnaceError when a fragment is missing or itself contains an
- *   include directive (nesting is not supported)
- */
-export async function expandCssFragments(css, sharedDir) {
-    const stripped = stripExpandedFragments(css);
-    const includes = listFragmentIncludes(stripped);
-    if (includes.length === 0)
-        return { expanded: stripped, includes };
-    const fragments = new Map();
-    for (const name of includes) {
-        const fragmentPath = join(sharedDir, name);
-        if (!(await pathExists(fragmentPath))) {
-            throw new FurnaceError(`CSS fragment "${name}" not found in components/${SHARED_FRAGMENTS_DIR}/. ` +
-                'Create the fragment file or remove the @fireforge-include directive.');
-        }
-        const content = await readFragmentSource(sharedDir, name);
-        if (listFragmentIncludes(content).length > 0) {
-            throw new FurnaceError(`CSS fragment "${name}" contains an @fireforge-include directive of its own; ` +
-                'nested fragment includes are not supported.');
-        }
-        fragments.set(name, content);
-    }
-    const out = [];
-    for (const line of stripped.split('\n')) {
-        out.push(line);
-        const inc = INCLUDE_PATTERN.exec(line);
-        if (inc?.[1]) {
-            out.push(fragments.get(inc[1]) ?? '');
-            out.push(`/* @fireforge-end-include ${inc[1]} */`);
-        }
-    }
-    return { expanded: out.join('\n'), includes };
-}
-/**
- * Extracts the fenced expansion bodies of a previously expanded stylesheet,
- * keyed by fragment name. Used by validate to compare a deployed expansion
- * against the current fragment source without re-deploying.
- */
-export function extractExpandedFragmentBodies(css) {
-    const bodies = new Map();
-    const lines = css.split('\n');
-    let current = null;
-    let buffer = [];
-    for (const line of lines) {
-        if (current !== null) {
-            if (END_INCLUDE_PATTERN.exec(line)?.[1] === current) {
-                bodies.set(current, buffer.join('\n'));
-                current = null;
-                buffer = [];
-                continue;
-            }
-            buffer.push(line);
-            continue;
-        }
-        const inc = INCLUDE_PATTERN.exec(line);
-        if (inc?.[1]) {
-            current = inc[1];
-        }
-    }
-    return bodies;
-}
-/**
- * Deploys one component file: CSS sources carrying include directives are
- * written as their fragment-expanded form. Everything else is a plain
- * copy. Extracted here so `applyCustomComponent` stays inside the
- * per-file line budget.
- *
- * @returns True when fragment expansion was applied
- */
-export async function deployFileWithFragments(src, dest, sharedDir) {
-    if (src.endsWith('.css')) {
-        const content = await readText(src);
-        if (listFragmentIncludes(content).length > 0) {
-            const { expanded } = await expandCssFragments(content, sharedDir);
-            await writeText(dest, expanded);
-            return true;
-        }
-    }
-    await copyFile(src, dest);
-    return false;
-}
-/**
- * Builds the dry-run description suffix for a component file copy,
- * naming the fragments an expansion would inline. Empty for plain copies.
- */
-export async function describeFragmentExpansion(src) {
-    if (!src.endsWith('.css'))
-        return '';
-    const includes = listFragmentIncludes(await readText(src));
-    if (includes.length === 0)
-        return '';
-    return ` (expanding fragment${includes.length === 1 ? '' : 's'}: ${includes.join(', ')})`;
-}
-/**
- * Validates fragment usage for one custom component: every directive must
- * name an existing fragment (`missing-fragment`, error), and a deployed
- * stylesheet's fenced expansion must match the current fragment source
- * (`stale-fragment-expansion`, warning → redeploy refreshes it).
- *
- * @param componentDir - Workspace directory of the component
- * @param tagName - Component tag name for issue attribution
- * @param sharedDir - Shared fragments directory
- * @param engineTargetDir - Deployed directory in the engine. Optional, and
- *   pre-deploy validation skips the staleness check.
- */
-export async function validateCssFragments(componentDir, tagName, sharedDir, engineTargetDir) {
-    const issues = [];
-    if (!(await pathExists(componentDir)))
-        return issues;
-    // Graceful degradation like the other validators: an unreadable
-    // component directory must not cascade into a validation crash.
-    let entries;
-    try {
-        entries = await readdir(componentDir);
-    }
-    catch {
-        // An unreadable component directory contributes no fragment issues.
-        // Return what has been collected so far rather than failing validation.
-        return issues;
-    }
-    for (const fileName of entries) {
-        if (!fileName.endsWith('.css'))
-            continue;
-        const source = await readText(join(componentDir, fileName));
-        const includes = listFragmentIncludes(source);
-        if (includes.length === 0)
-            continue;
-        let deployedBodies = null;
-        if (engineTargetDir) {
-            const destPath = join(engineTargetDir, fileName);
-            if (await pathExists(destPath)) {
-                deployedBodies = extractExpandedFragmentBodies(await readText(destPath));
-            }
-        }
-        for (const include of includes) {
-            const fragmentPath = join(sharedDir, include);
-            if (!(await pathExists(fragmentPath))) {
-                issues.push({
-                    component: tagName,
-                    severity: 'error',
-                    check: 'missing-fragment',
-                    message: `${fileName} includes CSS fragment "${include}", but components/${SHARED_FRAGMENTS_DIR}/${include} does not exist. ` +
-                        'Create the fragment or remove the @fireforge-include directive.',
-                });
-                continue;
-            }
-            if (deployedBodies === null)
-                continue;
-            const fragmentContent = await readFragmentSource(sharedDir, include);
-            const deployed = deployedBodies.get(include);
-            if (deployed === undefined || deployed !== fragmentContent) {
-                issues.push({
-                    component: tagName,
-                    severity: 'warning',
-                    check: 'stale-fragment-expansion',
-                    message: deployed === undefined
-                        ? `Deployed ${fileName} has no expansion for fragment "${include}". Run "fireforge furnace deploy ${tagName}".`
-                        : `Deployed ${fileName} carries a stale expansion of fragment "${include}" — the fragment source changed since the last deploy. Run "fireforge furnace deploy ${tagName}".`,
-                });
-            }
-        }
-    }
-    return issues;
-}

package/dist/src/core/furnace-deploy-owner.d.ts

@@ -1,29 +0,0 @@
-/**
- * `furnace deploy --owner <patch>`: refuse a deploy that would overwrite a
- * deployed file another patch owns.
- *
- * Deploy copies a whole component folder. Two sessions editing different
- * files of one folder, owned by different patches, cannot deploy apart:
- * the first deploy ships the other's half-done edit into the engine copy
- * its patch owns. Naming the patch being exported lets deploy judge every
- * file it is about to replace before any is written, across every named
- * component, and refuse when one belongs to a patch other than the named
- * one. Without `--owner` the same overwrites stay advisory warnings.
- */
-import type { FurnaceConfig } from '../types/furnace.js';
-/**
- * Refuses the deploy when a file it would overwrite is owned by a patch
- * other than `owner`. Runs before any component is applied. A file the
- * owner shares with another patch is the owner's to deploy.
- *
- * @param args.root - Project root
- * @param args.config - Furnace configuration
- * @param args.names - The named components (empty for a deploy of all)
- * @param args.owner - The `--owner` patch identifier
- */
-export declare function assertDeployOverwritesOwnedBy(args: {
-    root: string;
-    config: FurnaceConfig;
-    names: readonly string[];
-    owner: string;
-}): Promise<void>;

package/dist/src/core/furnace-deploy-owner.js

@@ -1,116 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `furnace deploy --owner <patch>`: refuse a deploy that would overwrite a
- * deployed file another patch owns.
- *
- * Deploy copies a whole component folder. Two sessions editing different
- * files of one folder, owned by different patches, cannot deploy apart:
- * the first deploy ships the other's half-done edit into the engine copy
- * its patch owns. Naming the patch being exported lets deploy judge every
- * file it is about to replace before any is written, across every named
- * component, and refuse when one belongs to a patch other than the named
- * one. Without `--owner` the same overwrites stay advisory warnings.
- */
-import { join } from 'node:path';
-import { FurnaceError } from '../errors/furnace.js';
-import { pathExists } from '../utils/fs.js';
-import { getProjectPaths } from './config.js';
-import { probePatchOwnedOverwrites, } from './furnace-apply-overwrite-warn.js';
-import { getFurnacePaths } from './furnace-config.js';
-import { resolveFtlDir } from './furnace-constants.js';
-import { formatPatchNotFoundError } from './patch-identifier-suggest.js';
-import { loadPatchesManifest, resolvePatchIdentifier } from './patch-manifest.js';
-import { buildPatchClaims } from './status-classify.js';
-/**
- * Resolves `--owner` to a patch filename in the queue, refusing an unknown
- * patch or a project with no queue.
- *
- * @param root - Project root
- * @param owner - The patch identifier as given (filename, order or name)
- * @returns The owner's filename and the queue's file claims
- */
-async function resolveOwner(root, owner) {
-    const manifest = await loadPatchesManifest(getProjectPaths(root).patches);
-    if (!manifest || manifest.patches.length === 0) {
-        throw new FurnaceError(`--owner ${owner}: the patch queue is empty or missing.`, owner);
-    }
-    const match = resolvePatchIdentifier(owner, manifest.patches);
-    if (!match) {
-        throw new FurnaceError(`--owner: ${formatPatchNotFoundError(owner, manifest.patches)}`, owner);
-    }
-    return { filename: match.filename, claims: buildPatchClaims(manifest.patches) };
-}
-/** The overrides and custom components a deploy of `names` (all when empty) applies. */
-function componentsInScope(config, names) {
-    const all = [...Object.keys(config.overrides), ...Object.keys(config.custom)];
-    if (names.length === 0)
-        return all;
-    return [...new Set(names)].filter((name) => all.includes(name));
-}
-function formatForeignOverwrites(owner, foreign) {
-    const lines = foreign.map((entry) => `  - ${entry.file} (${entry.component}): owned by ${entry.owners.join(', ')}`);
-    const owners = [...new Set(foreign.flatMap((entry) => entry.owners))].join(', ');
-    return [
-        `Deploy refused (--owner ${owner}): it would overwrite ${foreign.length} deployed file(s) ` +
-            `that differ from the components/ source and are owned by another patch:`,
-        ...lines,
-        `Nothing was written. Those component sources carry edits for ${owners}, not ${owner}. ` +
-            'Park that work or export that patch first, then deploy again, or deploy without ' +
-            '--owner to overwrite the files anyway.',
-    ].join('\n');
-}
-/** The patch-owned files one component's apply would overwrite. */
-async function probeComponent(root, config, name, patchClaims) {
-    const ftlDir = resolveFtlDir(config.ftlBasePath);
-    const override = config.overrides[name];
-    if (override !== undefined) {
-        const componentDir = join(getFurnacePaths(root).overridesDir, name);
-        // A missing override folder copies nothing; apply reports it.
-        if (!(await pathExists(componentDir)))
-            return [];
-        return probePatchOwnedOverwrites({
-            type: 'override',
-            engineDir: getProjectPaths(root).engine,
-            name,
-            componentDir,
-            config: override,
-            ftlDir,
-            patchClaims,
-        });
-    }
-    const custom = config.custom[name];
-    if (custom === undefined)
-        return [];
-    return probePatchOwnedOverwrites({
-        type: 'custom',
-        root,
-        name,
-        config: custom,
-        ftlDir,
-        patchClaims,
-    });
-}
-/**
- * Refuses the deploy when a file it would overwrite is owned by a patch
- * other than `owner`. Runs before any component is applied. A file the
- * owner shares with another patch is the owner's to deploy.
- *
- * @param args.root - Project root
- * @param args.config - Furnace configuration
- * @param args.names - The named components (empty for a deploy of all)
- * @param args.owner - The `--owner` patch identifier
- */
-export async function assertDeployOverwritesOwnedBy(args) {
-    const { root, config, names } = args;
-    const { filename, claims } = await resolveOwner(root, args.owner);
-    const foreign = [];
-    for (const name of componentsInScope(config, names)) {
-        const found = await probeComponent(root, config, name, claims);
-        foreign.push(...found.filter((entry) => !entry.owners.includes(filename)));
-    }
-    if (foreign.length > 0) {
-        throw new FurnaceError(formatForeignOverwrites(filename, foreign), undefined, undefined, {
-            omitValidateAdvice: true,
-        });
-    }
-}

package/dist/src/core/furnace-dir-entry.d.ts

@@ -1,20 +0,0 @@
-/**
- * The minimal `readdir(..., { withFileTypes: true })` entry shape the furnace
- * apply path needs, plus the single predicate that decides whether an entry is
- * a copy candidate. Kept in its own leaf module so both `furnace-apply-helpers`
- * and its dry-run mirror can share one definition without importing each other.
- */
-/** Structural subset of `Dirent` used by the furnace apply/dry-run walkers. */
-export interface DirectoryEntry {
-    isFile(): boolean;
-    isSymbolicLink?(): boolean;
-    name: string;
-}
-/**
- * True for a plain-file directory entry. Symlinks and directories are
- * never copy candidates.
- *
- * @param entry - Directory entry to classify
- * @returns True when the entry is a regular file
- */
-export declare function isRegularFile(entry: DirectoryEntry): boolean;