@hominis/fireforge 0.50.0 → 0.51.0

package/dist/src/core/config-validate-token-scales.js

@@ -1,9 +1,23 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
  * Validation for `fireforge.json#patchLint.tokenScales`.
+ *
+ * Unknown keys are refused: a misspelt `allowInCalc` or `minFiles` would
+ * otherwise loosen or drop a scale without a word.
  */
 import { ConfigError } from '../errors/config.js';
 import { parseObject } from '../utils/parse.js';
+const SCALE_KEYS = [
+    'properties',
+    'prefix',
+    'allowLiterals',
+    'allow',
+    'allowInCalc',
+    'offsetCap',
+    'exclude',
+    'minFiles',
+];
+const PREFIX_PATTERN = /^--[\w-]+$/;
 function parseNames(raw, label, required) {
     if (raw === undefined && !required)
         return undefined;
@@ -14,6 +28,21 @@ function parseNames(raw, label, required) {
     }
     return raw;
 }
+function parsePrefix(raw, label) {
+    const prefixes = Array.isArray(raw) ? raw : [raw];
+    if (prefixes.length === 0 ||
+        prefixes.some((prefix) => typeof prefix !== 'string' || !PREFIX_PATTERN.test(prefix))) {
+        throw new ConfigError(`Config field "${label}.prefix" must be a custom-property prefix such as "--mybrowser-space-", or a non-empty list of them`);
+    }
+    return Array.isArray(raw) ? prefixes : raw;
+}
+function parseNumber(raw, label, integer) {
+    const valid = typeof raw === 'number' && Number.isFinite(raw) && (integer ? Number.isInteger(raw) : true);
+    if (!valid || raw < (integer ? 1 : 0)) {
+        throw new ConfigError(`Config field "${label}" must be ${integer ? 'a positive integer' : 'a non-negative number'}`);
+    }
+    return raw;
+}
 function parseTokenScale(raw, label) {
     let rec;
     try {
@@ -22,12 +51,13 @@ function parseTokenScale(raw, label) {
     catch {
         throw new ConfigError(`Config field "${label}" must be an object`);
     }
-    const properties = parseNames(rec.raw('properties'), `${label}.properties`, true) ?? [];
-    const prefix = rec.raw('prefix');
-    if (typeof prefix !== 'string' || !/^--[\w-]+$/.test(prefix)) {
-        throw new ConfigError(`Config field "${label}.prefix" must be a custom-property prefix such as "--mybrowser-space-"`);
+    for (const key of Object.keys(raw)) {
+        if (!SCALE_KEYS.includes(key)) {
+            throw new ConfigError(`Config field "${label}" has unknown key "${key}"`);
+        }
     }
-    const scale = { properties, prefix };
+    const properties = parseNames(rec.raw('properties'), `${label}.properties`, true) ?? [];
+    const scale = { properties, prefix: parsePrefix(rec.raw('prefix'), label) };
     const allowLiterals = parseNames(rec.raw('allowLiterals'), `${label}.allowLiterals`, false);
     if (allowLiterals !== undefined)
         scale.allowLiterals = allowLiterals;
@@ -39,6 +69,18 @@ function parseTokenScale(raw, label) {
         }
         scale.allow = allow;
     }
+    const allowInCalc = parseNames(rec.raw('allowInCalc'), `${label}.allowInCalc`, false);
+    if (allowInCalc !== undefined)
+        scale.allowInCalc = allowInCalc;
+    const offsetCap = rec.raw('offsetCap');
+    if (offsetCap !== undefined)
+        scale.offsetCap = parseNumber(offsetCap, `${label}.offsetCap`, false);
+    const exclude = parseNames(rec.raw('exclude'), `${label}.exclude`, false);
+    if (exclude !== undefined)
+        scale.exclude = exclude;
+    const minFiles = rec.raw('minFiles');
+    if (minFiles !== undefined)
+        scale.minFiles = parseNumber(minFiles, `${label}.minFiles`, true);
     return scale;
 }
 /** Parses and validates `patchLint.tokenScales`. */

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

@@ -471,6 +471,12 @@ function parseTypecheckBlock(rec) {
     if (undefinedIdentifiers !== undefined) {
         out.undefinedIdentifiers = undefinedIdentifiers;
     }
+    const litTypes = rec.raw('litTypes');
+    if (litTypes !== undefined && typeof litTypes !== 'boolean') {
+        throw new ConfigError('Config field "typecheck.litTypes" must be a boolean');
+    }
+    if (litTypes !== undefined)
+        out.litTypes = litTypes;
     return out;
 }
 /**

package/dist/src/core/coverage-extend.js

@@ -13,7 +13,7 @@
  */
 import { toError } from '../utils/errors.js';
 import { verbose } from '../utils/logger.js';
-import { collectStagingInputs, createCoverageRecord, findChangedInputs, hashEngineFile, isUnderPath, narrowAnchor, normalizeRequestPath, readEngineContentState, refreshAnchor, } from './coverage-records.js';
+import { collectStagingInputs, createCoverageRecord, findChangedInputs, hashEngineFile, isUnderPath, narrowAnchor, normalizeRequestPath, readEngineContentState, refreshAnchor, widenWithRestagedManifests, } from './coverage-records.js';
 export { hashEngineFile } from './coverage-records.js';
 /** Filename of the generated mozconfig, relative to the engine directory. */
 const MOZCONFIG_FILENAME = 'mozconfig';
@@ -96,7 +96,7 @@ export async function planCoverageRetention(engineDir, previous, requested) {
     if (previous === undefined)
         return emptyPlan();
     const coverage = previous.testPackagingCoverage ?? 'full';
-    const rebuilt = requested.map(normalizeRequestPath).filter((path) => path !== '');
+    const rebuilt = await widenWithRestagedManifests(engineDir, requested.map(normalizeRequestPath).filter((path) => path !== ''));
     let state;
     try {
         state = await readEngineContentState(engineDir);

package/dist/src/core/coverage-records.d.ts

@@ -67,6 +67,17 @@ export declare function findChangedInputs(state: EngineContentState, anchor: Cov
  * cannot be read or the anchor cannot be compared.
  */
 export declare function refreshAnchor<T extends CoverageAnchor>(state: EngineContentState, anchor: T, rebuilt: readonly string[]): Promise<T | undefined>;
+/**
+ * The request paths a scoped build restages, widened by the test manifests
+ * of every requested file: packaging one file of a manifest re-processes
+ * the manifest itself, so a manifest that gained an entry for that file is
+ * restaged too, and must not count as a changed input of the manifest's
+ * other files afterwards.
+ *
+ * @param engineDir - Path to the engine directory
+ * @param requested - Normalized request paths of the build
+ */
+export declare function widenWithRestagedManifests(engineDir: string, requested: readonly string[]): Promise<string[]>;
 /**
  * Engine-relative paths a manifest names outside its own directory. Bare
  * names stay inside it. `!/` and `/` prefixes are engine-root relative, as

package/dist/src/core/coverage-records.js

@@ -217,6 +217,40 @@ async function findManifestDirectory(engineDir, dir) {
             return undefined;
     }
 }
+/**
+ * The request paths a scoped build restages, widened by the test manifests
+ * of every requested file: packaging one file of a manifest re-processes
+ * the manifest itself, so a manifest that gained an entry for that file is
+ * restaged too, and must not count as a changed input of the manifest's
+ * other files afterwards.
+ *
+ * @param engineDir - Path to the engine directory
+ * @param requested - Normalized request paths of the build
+ */
+export async function widenWithRestagedManifests(engineDir, requested) {
+    const widened = new Set(requested);
+    for (const path of requested) {
+        if (!TEST_FILE_PATTERN.test(posix.basename(path)))
+            continue;
+        const dir = await findManifestDirectory(engineDir, posix.dirname(path));
+        if (dir === undefined)
+            continue;
+        let entries;
+        try {
+            entries = await readdir(join(engineDir, dir));
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (TEST_MANIFEST_BASENAMES.has(entry))
+                widened.add(dir === '' ? entry : `${dir}/${entry}`);
+        }
+    }
+    return [...widened];
+}
+/** A test implementation file (`browser_*.js`, `test_*.js`, …), not a directory. */
+const TEST_FILE_PATTERN = /^(?:browser|test)_.*\.m?js$/;
 /** Test manifests at or beneath `dir`, bounded by {@link MAX_WALK_ENTRIES}. */
 async function findManifestsBeneath(engineDir, dir) {
     const manifests = [];

package/dist/src/core/engine-session-lock.d.ts

@@ -1,3 +1,4 @@
+import type { LockMode } from './file-lock.js';
 import { type LockStatusSnapshot } from './file-lock.js';
 export interface EngineSessionLockOptions {
     /**
@@ -7,6 +8,11 @@ export interface EngineSessionLockOptions {
      * fail-fast behaviour.
      */
     waitLockSeconds?: number | undefined;
+    /**
+     * `shared` lets build-less test runs overlap each other; see
+     * `file-lock-shared.ts`. Every other caller holds the lock exclusively.
+     */
+    mode?: LockMode | undefined;
 }
 /**
  * Formats the notice printed when the wait budget is extended because the

package/dist/src/core/engine-session-lock.js

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { InconclusiveVerdictError } from '../errors/base.js';
 import { toError } from '../utils/errors.js';
 import { info, warn } from '../utils/logger.js';
+import { MAX_WAIT_LOCK_SECONDS } from '../utils/options.js';
 import { sleep } from '../utils/sleep.js';
 import { formatLockQueuePosition, readLockStatus, withFileLock, } from './file-lock.js';
 import { git } from './git-base.js';
@@ -14,7 +15,7 @@ const ENGINE_SESSION_LOCK_PATH = join('.fireforge', 'engine-session.lock');
  * never gets one longer than the largest wait they could have asked for.
  */
 const WAIT_EXTENSION_FACTOR = 4;
-const MAX_WAIT_LOCK_MS = 3600 * 1000;
+const MAX_WAIT_LOCK_MS = MAX_WAIT_LOCK_SECONDS * 1000;
 /**
  * Formats the periodic operator-facing waiting line printed while `--wait-lock`
  * polls a contended engine session lock. The holder identification comes from
@@ -66,6 +67,7 @@ export async function withEngineSessionLock(projectRoot, command, operation, opt
     }
     const { waitLockSeconds } = options;
     return withFileLock(join(projectRoot, ENGINE_SESSION_LOCK_PATH), operation, {
+        ...(options.mode === 'shared' ? { mode: 'shared' } : {}),
         timeoutMs: waitLockSeconds !== undefined ? waitLockSeconds * 1000 : 1000,
         ...(waitLockSeconds !== undefined
             ? {
@@ -121,8 +123,13 @@ export async function readEngineSessionLockStatus(projectRoot) {
  * Pure, so the wording is unit-testable without a lock on disk.
  */
 export function formatEngineSessionLockStatus(snapshot, holderCpuSeconds) {
+    const shared = snapshot.sharedHolders !== undefined && snapshot.sharedHolders > 0
+        ? `Shared holders: ${snapshot.sharedHolders} build-less test run(s) under a shared lock.`
+        : undefined;
     if (!snapshot.held) {
-        return ['Engine session lock: free (no FireForge engine-mutating command is running).'];
+        return shared === undefined
+            ? ['Engine session lock: free (no FireForge engine-mutating command is running).']
+            : ['Engine session lock: no exclusive holder.', shared];
     }
     const elapsed = snapshot.heldForMs === undefined
         ? 'unknown duration'
@@ -135,6 +142,7 @@ export function formatEngineSessionLockStatus(snapshot, holderCpuSeconds) {
     const lines = [
         `Engine session lock: ${identity}, for ${elapsed}.`,
         `Queue depth: ${snapshot.queueDepth} waiter(s).`,
+        ...(shared === undefined ? [] : [shared]),
     ];
     // Liveness answers "does the process exist". It does not answer "is it
     // getting anywhere". A holder alive for minutes having used a fraction of

package/dist/src/core/file-lock-shared.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Shared holds on a FireForge directory lock.
+ *
+ * Every lock used to be exclusive, so two build-less `fireforge test` runs
+ * on one objdir, each with its own profile and (under auto ports) its own
+ * ports, still waited for each other: the gate's browser tiers ran strictly
+ * serially on a 14-core host. A shared hold lets such runs overlap while
+ * anything that writes (a build, a re-export, a test run that builds)
+ * still holds the lock alone.
+ *
+ * The scheme reuses the exclusive lock as a turnstile, so arrival order and
+ * stale-holder reaping come from the machinery that already exists:
+ *
+ *  - A shared holder takes the exclusive lock in the ordinary way, records
+ *    itself under `<lock>.shared/<uuid>/` (an owner record like the lock's
+ *    own), and releases the exclusive lock at once.
+ *  - An exclusive holder takes the exclusive lock, then waits until no live
+ *    shared holder is left. While it waits it already holds the turnstile,
+ *    so no new shared holder can slip in ahead of it: a writer queued
+ *    behind readers is served once they finish, never starved by newcomers.
+ *
+ * A shared holder whose process died is reaped by the same PID-first
+ * liveness check the exclusive lock uses.
+ */
+/** How a caller holds a lock. */
+export type LockMode = 'exclusive' | 'shared';
+/** The directory holding a lock's shared-holder records. */
+export declare function sharedHoldersDir(lockPath: string): string;
+/**
+ * Counts the live shared holders of a lock, reaping any whose process is
+ * gone. A missing directory means none.
+ *
+ * @param lockPath - The lock directory
+ * @param options - `reap: false` only counts (status reads)
+ */
+export declare function countLiveSharedHolders(lockPath: string, options?: {
+    reap?: boolean;
+}): Promise<number>;
+/** A registered shared hold. */
+export interface SharedHold {
+    /** Removes the hold. Never throws. */
+    release(): Promise<void>;
+}
+/**
+ * Records a shared hold. Call while holding the lock's exclusive turnstile.
+ *
+ * @param lockPath - The lock directory
+ * @param metadata - Owner metadata lines (`command=…`)
+ */
+export declare function registerSharedHold(lockPath: string, metadata: readonly string[] | undefined): Promise<SharedHold>;
+/**
+ * Removes every shared hold this process registered, for the signal path.
+ * Never throws.
+ *
+ * @returns The holder paths removed
+ */
+export declare function releaseSharedHoldsForSignal(): Promise<string[]>;

package/dist/src/core/file-lock-shared.js

@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Shared holds on a FireForge directory lock.
+ *
+ * Every lock used to be exclusive, so two build-less `fireforge test` runs
+ * on one objdir, each with its own profile and (under auto ports) its own
+ * ports, still waited for each other: the gate's browser tiers ran strictly
+ * serially on a 14-core host. A shared hold lets such runs overlap while
+ * anything that writes (a build, a re-export, a test run that builds)
+ * still holds the lock alone.
+ *
+ * The scheme reuses the exclusive lock as a turnstile, so arrival order and
+ * stale-holder reaping come from the machinery that already exists:
+ *
+ *  - A shared holder takes the exclusive lock in the ordinary way, records
+ *    itself under `<lock>.shared/<uuid>/` (an owner record like the lock's
+ *    own), and releases the exclusive lock at once.
+ *  - An exclusive holder takes the exclusive lock, then waits until no live
+ *    shared holder is left. While it waits it already holds the turnstile,
+ *    so no new shared holder can slip in ahead of it: a writer queued
+ *    behind readers is served once they finish, never starved by newcomers.
+ *
+ * A shared holder whose process died is reaped by the same PID-first
+ * liveness check the exclusive lock uses.
+ */
+import { randomUUID } from 'node:crypto';
+import { mkdir, readdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { getNodeErrorCode, toError } from '../utils/errors.js';
+import { verbose } from '../utils/logger.js';
+import { isLockOwnerAlive, readLockOwner, writeLockOwner } from './file-lock-owner.js';
+/** The directory holding a lock's shared-holder records. */
+export function sharedHoldersDir(lockPath) {
+    return `${lockPath}.shared`;
+}
+/** Holder directories this process registered, for the signal sweep. */
+const heldShares = new Set();
+/**
+ * Counts the live shared holders of a lock, reaping any whose process is
+ * gone. A missing directory means none.
+ *
+ * @param lockPath - The lock directory
+ * @param options - `reap: false` only counts (status reads)
+ */
+export async function countLiveSharedHolders(lockPath, options = {}) {
+    const dir = sharedHoldersDir(lockPath);
+    let entries;
+    try {
+        entries = await readdir(dir);
+    }
+    catch (error) {
+        if (getNodeErrorCode(error) === 'ENOENT')
+            return 0;
+        if (options.reap === false)
+            return 0;
+        throw toError(error);
+    }
+    let live = 0;
+    for (const entry of entries) {
+        const holder = join(dir, entry);
+        const owner = await readLockOwner(holder);
+        if (owner.present && isLockOwnerAlive(owner)) {
+            live += 1;
+            continue;
+        }
+        // A record still being written has no owner yet; only an owner that
+        // names a dead process is reaped, so a racing registration survives.
+        if (owner.present && options.reap !== false) {
+            verbose(`Reaping shared hold ${holder}: PID ${owner.pid} is gone.`);
+            await rm(holder, { recursive: true, force: true });
+        }
+    }
+    return live;
+}
+/**
+ * Records a shared hold. Call while holding the lock's exclusive turnstile.
+ *
+ * @param lockPath - The lock directory
+ * @param metadata - Owner metadata lines (`command=…`)
+ */
+export async function registerSharedHold(lockPath, metadata) {
+    const holder = join(sharedHoldersDir(lockPath), randomUUID());
+    await mkdir(holder, { recursive: true });
+    await writeLockOwner(holder, randomUUID(), [...(metadata ?? []), 'mode=shared']);
+    heldShares.add(holder);
+    return {
+        async release() {
+            heldShares.delete(holder);
+            try {
+                await rm(holder, { recursive: true, force: true });
+            }
+            catch (error) {
+                verbose(`Could not remove shared hold ${holder}: ${toError(error).message}`);
+            }
+        },
+    };
+}
+/**
+ * Removes every shared hold this process registered, for the signal path.
+ * Never throws.
+ *
+ * @returns The holder paths removed
+ */
+export async function releaseSharedHoldsForSignal() {
+    const removed = [];
+    for (const holder of [...heldShares]) {
+        heldShares.delete(holder);
+        try {
+            await rm(holder, { recursive: true, force: true });
+            removed.push(holder);
+        }
+        catch {
+            // Shutdown path: nothing to do.
+        }
+    }
+    return removed;
+}

package/dist/src/core/file-lock.d.ts

@@ -1,7 +1,9 @@
 import { LOCK_PID_FILE } from './file-lock-owner.js';
 import { type LockQueueState } from './file-lock-queue.js';
+import { type LockMode } from './file-lock-shared.js';
 export { LOCK_PID_FILE };
 export { formatLockQueuePosition, type LockQueueState } from './file-lock-queue.js';
+export type { LockMode } from './file-lock-shared.js';
 /**
  * Snapshot of the current lock holder handed to {@link FileLockOptions.onWaitProgress}.
  * `metadata` carries the pid file's human-diagnostic lines (line 3 onward,
@@ -84,6 +86,11 @@ export interface FileLockOptions {
     onStaleLockMessage?: (ageMs: number) => string | undefined;
     /** Extra owner-file lines for human diagnostics. Lock mechanics ignore them. */
     ownerMetadata?: readonly string[];
+    /**
+     * `exclusive` (default) or `shared`. Shared holders overlap each other and
+     * exclude exclusive ones; see `file-lock-shared.ts`.
+     */
+    mode?: LockMode | undefined;
 }
 /** Derives the sibling lock-directory path used to guard a file-based resource. */
 export declare function createSiblingLockPath(filePath: string, suffix?: string): string;
@@ -97,6 +104,8 @@ export interface LockStatusSnapshot {
     /** Milliseconds since the lock directory was created, when held. */
     heldForMs?: number | undefined;
     queueDepth: number;
+    /** Live shared holders (build-less test runs under a shared lock). */
+    sharedHolders?: number | undefined;
 }
 /**
  * Inspects a lock without acquiring it. Read-only and fail-open: a missing

package/dist/src/core/file-lock.js

@@ -9,6 +9,7 @@ import { verbose, warn } from '../utils/logger.js';
 import { sleep } from '../utils/sleep.js';
 import { isLockOwnerAlive, LOCK_PID_FILE, readLockOwner, writeLockOwner, } from './file-lock-owner.js';
 import { readLockQueue, registerWaiter, } from './file-lock-queue.js';
+import { countLiveSharedHolders, registerSharedHold, releaseSharedHoldsForSignal, } from './file-lock-shared.js';
 export { LOCK_PID_FILE };
 export { formatLockQueuePosition } from './file-lock-queue.js';
 const DEFAULT_LOCK_TIMEOUT_MS = 30_000;
@@ -38,6 +39,8 @@ export function createSiblingLockPath(filePath, suffix = '.fireforge.lock') {
  */
 export async function readLockStatus(lockPath) {
     const queue = await readLockQueue(lockPath);
+    const shared = await countLiveSharedHolders(lockPath, { reap: false });
+    const sharedPart = shared > 0 ? { sharedHolders: shared } : {};
     let heldForMs;
     try {
         // Clamped: filesystem mtime resolution can round a just-created lock
@@ -46,13 +49,13 @@ export async function readLockStatus(lockPath) {
         heldForMs = Math.max(0, Date.now() - (await stat(lockPath)).mtimeMs);
     }
     catch {
-        return { held: false, queueDepth: queue.depth };
+        return { held: false, queueDepth: queue.depth, ...sharedPart };
     }
     const owner = await readLockOwner(lockPath);
     const holder = owner.present
         ? { pid: owner.pid, alive: isLockOwnerAlive(owner), metadata: owner.metadata }
         : undefined;
-    return { held: true, holder, heldForMs, queueDepth: queue.depth };
+    return { held: true, holder, heldForMs, queueDepth: queue.depth, ...sharedPart };
 }
 /**
  * Reads the contended lock's owner and queue in one go. One probe per cycle
@@ -334,6 +337,7 @@ export async function forceReleaseHeldLocksForSignal() {
             removed.push(lockPath);
         }
     }
+    removed.push(...(await releaseSharedHoldsForSignal()));
     return removed;
 }
 /** Runs an async operation while holding a directory lock, with stale-lock recovery. */
@@ -467,8 +471,36 @@ export async function withFileLock(lockPath, operation, options = {}) {
     // `writeLockOwner` removes the just-created directory before throwing.
     const ownerToken = randomUUID();
     await writeLockOwner(lockPath, ownerToken, options.ownerMetadata);
+    return runWhileHeld(lockPath, ownerToken, operation, options, {
+        deadline: Math.max(deadline, Date.now() + pollMs),
+        pollMs,
+    });
+}
+/**
+ * Runs `operation` once the turnstile is ours: as a shared holder (turnstile
+ * released at once), or exclusively once every shared holder has drained.
+ */
+async function runWhileHeld(lockPath, ownerToken, operation, options, drain) {
+    if (options.mode === 'shared') {
+        // The exclusive lock was only the turnstile: record the shared hold and
+        // let the next waiter in. See file-lock-shared.ts.
+        let hold;
+        try {
+            hold = await registerSharedHold(lockPath, options.ownerMetadata);
+        }
+        finally {
+            await releaseLock(lockPath, ownerToken);
+        }
+        try {
+            return await operation();
+        }
+        finally {
+            await hold.release();
+        }
+    }
     heldLocks.add(lockPath);
     try {
+        await waitForSharedHoldersToDrain(lockPath, drain.deadline, drain.pollMs);
         return await operation();
     }
     finally {
@@ -476,3 +508,27 @@ export async function withFileLock(lockPath, operation, options = {}) {
         await releaseLock(lockPath, ownerToken);
     }
 }
+/**
+ * Holds an exclusive acquisition until every live shared holder has gone.
+ * The turnstile is already ours, so no new shared holder can join meanwhile.
+ *
+ * @throws LockContentionError when shared holders outlast the budget
+ */
+async function waitForSharedHoldersToDrain(lockPath, deadline, pollMs) {
+    let announced = false;
+    for (;;) {
+        const live = await countLiveSharedHolders(lockPath);
+        if (live === 0)
+            return;
+        if (Date.now() >= deadline) {
+            throw new LockContentionError(`Timed out waiting for file lock ${lockPath}: ${live} shared holder(s) (build-less ` +
+                'test runs under a shared lock) still hold it. Wait for them to finish, or retry ' +
+                'with a larger --wait-lock.');
+        }
+        if (!announced) {
+            verbose(`Waiting for ${live} shared holder(s) of ${lockPath} to finish.`);
+            announced = true;
+        }
+        await sleep(Math.max(pollMs, 100));
+    }
+}

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

@@ -17,7 +17,8 @@ import { topologicalSortCustom } from './furnace-graph-utils.js';
 import { resolveFurnaceMarkerComment } from './furnace-marker.js';
 import { recordFurnaceRollbackFailure } from './furnace-operation.js';
 import { assertFurnaceEngineDirReady } from './furnace-precondition.js';
-import { addJarMnEntries, removeCustomElementRegistration, removeJarMnEntries, } from './furnace-registration.js';
+import { addJarMnEntries, removeCustomElementRegistration } from './furnace-registration.js';
+import { removeJarMnFileEntries } from './furnace-registration-jar-inplace.js';
 import { createRollbackJournal, restoreRollbackJournalOrThrow, snapshotFile, } from './furnace-rollback.js';
 import { blockingStepErrors, hasBlockingStepErrors } from './furnace-step-errors.js';
 import { runPostApplyConsistencyChecks } from './furnace-validate-registration.js';
@@ -132,8 +133,8 @@ async function applyOverrideBatch(ctx) {
 /**
  * After undeploying deleted files, the in-engine jar.mn and
  * customElements.js still carry entries for the removed files. Re-sync them
- * by removing all of `name`'s jar.mn entries and re-adding only those that
- * still exist in the workspace. If the .mjs itself was deleted, also drop
+ * by removing only the deleted files' jar.mn lines in place and adding any
+ * live file that has none. If the .mjs itself was deleted, also drop
  * the customElements.js registration. Snapshots are taken under the same
  * journal so the undo path is symmetric with apply.
  */
@@ -144,18 +145,17 @@ async function reconcileCustomRegistrationAfterUndeploy(args) {
     const deletedRegistrationFiles = deletedFiles.filter((f) => f.endsWith('.mjs') || f.endsWith('.css'));
     if (deletedRegistrationFiles.length === 0)
         return;
-    // jar.mn re-sync. addJarMnEntries is idempotent on duplicates but does not
-    // drop stale entries, so we need a remove-then-add cycle. The journal
-    // snapshot before each mutation gives us a clean rollback target.
+    // jar.mn re-sync: drop only the deleted files' lines, so the rest of the
+    // widget's block keeps its order and the owning patch carries no reorder
+    // hunks. addJarMnEntries is idempotent, so the add pass inserts only a
+    // live file that has no line yet. The journal snapshot before the
+    // mutation gives us a clean rollback target.
     if (rollbackJournal) {
         await snapshotFile(rollbackJournal, join(engineDir, JAR_MN));
     }
-    await removeJarMnEntries(engineDir, name);
+    await removeJarMnFileEntries(engineDir, name, deletedRegistrationFiles);
     const liveJarFiles = Object.keys(currentChecksums).filter((f) => f.endsWith('.mjs') || f.endsWith('.css'));
     if (liveJarFiles.length > 0) {
-        // applyCustomComponent has already added live entries, and the remove
-        // above dropped them too, so re-add now to leave jar.mn in the correct
-        // state.
         await addJarMnEntries(engineDir, name, liveJarFiles);
     }
     filesAffected.push(JAR_MN);

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

@@ -1,9 +1,16 @@
 import { type FurnaceOptInCheck, type FurnaceValidationException } from '../types/furnace.js';
 /**
- * Parses `validationExceptions[]`: `{ component, check, reason }` objects,
- * no other keys, every field a non-empty string, and no two entries for the
- * same component and check.
+ * Parses `validationExceptions[]`: `{ component, check, tag?, reason }`
+ * objects, no other keys, every field a non-empty string, and no two
+ * entries for the same component, check and tag.
  */
 export declare function parseValidationExceptions(raw: unknown): FurnaceValidationException[];
+/**
+ * Parses `tokenSiblingSheets`: an object from a sheet glob to a non-empty
+ * list of partner paths or globs.
+ */
+export declare function parseTokenSiblingSheets(raw: unknown): Record<string, string[]>;
+/** Parses `minComponents`: a positive integer. */
+export declare function parseMinComponents(raw: unknown): number;
 /** Parses `optInChecks[]`: names from {@link FURNACE_OPT_IN_CHECKS}. */
 export declare function parseOptInChecks(raw: unknown): FurnaceOptInCheck[];