@hominis/fireforge 0.45.0 → 0.46.0

package/dist/src/core/token-category.js

@@ -20,8 +20,8 @@ function multiLineBlockNameMatches(blockLine, category) {
     return blockLine.replace(/^\s*\*\s*/, '').trim() === category;
 }
 /**
- * Body of the first `/* … *\/` comment on `line`, or `null` when the line
- * carries no closed block comment.
+ * Body of the first `/* … *\/` comment on `line`, or `undefined` when the
+ * line carries no closed block comment.
  *
  * Deliberately index arithmetic rather than a regex: every regex spelling of
  * "banner comment" this module used to carry was super-linear on a line that
@@ -32,10 +32,10 @@ function multiLineBlockNameMatches(blockLine, category) {
 function blockCommentBody(line) {
     const open = line.indexOf('/*');
     if (open === -1)
-        return null;
+        return undefined;
     const close = line.indexOf('*/', open + 2);
     if (close === -1)
-        return null;
+        return undefined;
     return line.slice(open + 2, close);
 }
 /**
@@ -49,14 +49,15 @@ function isSingleLineBannerLine(line) {
     return body !== undefined && body.length >= 2 && body.startsWith('=') && body.endsWith('=');
 }
 /**
- * Name declared by a single-line banner (`/* = Foo = *\/` → `Foo`), or `null`
- * when the line is not a named banner. The `=` runs on both sides are
- * required; a decorative all-`=` rule carries no name and yields `null`.
+ * Name declared by a single-line banner (`/* = Foo = *\/` → `Foo`), or
+ * `undefined` when the line is not a named banner. The `=` runs on both sides
+ * are required; a decorative all-`=` rule carries no name and yields
+ * `undefined`.
  */
 function singleLineBannerName(line) {
     const body = blockCommentBody(line);
-    if (body === null)
-        return null;
+    if (body === undefined)
+        return undefined;
     let start = 0;
     let end = body.length;
     while (start < end && /\s/.test(body[start] ?? ''))
@@ -65,16 +66,16 @@ function singleLineBannerName(line) {
     while (start < end && body[start] === '=')
         start++;
     if (start === leadingEqStart)
-        return null;
+        return undefined;
     while (end > start && /\s/.test(body[end - 1] ?? ''))
         end--;
     const trailingEqEnd = end;
     while (end > start && body[end - 1] === '=')
         end--;
     if (end === trailingEqEnd)
-        return null;
+        return undefined;
     const name = body.slice(start, end).trim();
-    return name.length > 0 ? name : null;
+    return name.length > 0 ? name : undefined;
 }
 /**
  * True when `lines` contain a category header (single-line or multi-line
@@ -84,8 +85,7 @@ function singleLineBannerName(line) {
  */
 export function categoryHeaderExists(lines, category) {
     const singleLinePattern = singleLineBannerPattern(category);
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i] ?? '';
+    for (const [i, line] of lines.entries()) {
         if (singleLinePattern.test(line)) {
             return true;
         }
@@ -115,29 +115,44 @@ export function categoryHeaderExists(lines, category) {
  * This helper exists as a pure inspector; it never throws on malformed
  * headers and silently skips shapes it cannot parse.
  */
+/**
+ * Category name declared by the banner STARTING at `index`, or `undefined`
+ * when that line opens no banner.
+ *
+ * The single reader for both banner shapes, so the inventory walk, the
+ * "available categories" error body and the section finder cannot drift on
+ * what counts as a header.
+ *
+ * @param lines - Tokens CSS split into lines
+ * @param index - 0-based line index to test
+ * @returns The declared category name, or undefined
+ */
+export function categoryBannerNameAt(lines, index) {
+    const line = lines[index] ?? '';
+    const extracted = singleLineBannerName(line);
+    if (extracted !== undefined)
+        return extracted;
+    if (/^\s*\/\*\s*=+/.test(line) && !/\*\//.test(line)) {
+        for (let j = index + 1; j < Math.min(index + 6, lines.length); j++) {
+            const blockLine = lines[j] ?? '';
+            if (/\*\//.test(blockLine))
+                break;
+            const trimmed = blockLine.replace(/^\s*\*\s*/, '').trim();
+            if (trimmed.length === 0)
+                continue;
+            if (/^=+$/.test(trimmed))
+                continue;
+            return trimmed;
+        }
+    }
+    return undefined;
+}
 function discoverCategoryHeaders(lines) {
     const categories = new Set();
     for (let i = 0; i < lines.length; i++) {
-        const line = lines[i] ?? '';
-        const extracted = singleLineBannerName(line);
-        if (extracted !== null) {
-            categories.add(extracted);
-            continue;
-        }
-        if (/^\s*\/\*\s*=+/.test(line) && !/\*\//.test(line)) {
-            for (let j = i + 1; j < Math.min(i + 6, lines.length); j++) {
-                const blockLine = lines[j] ?? '';
-                if (/\*\//.test(blockLine))
-                    break;
-                const trimmed = blockLine.replace(/^\s*\*\s*/, '').trim();
-                if (trimmed.length === 0)
-                    continue;
-                if (/^=+$/.test(trimmed))
-                    continue;
-                categories.add(trimmed);
-                break;
-            }
-        }
+        const name = categoryBannerNameAt(lines, i);
+        if (name !== undefined)
+            categories.add(name);
     }
     return [...categories];
 }
@@ -177,7 +192,7 @@ export async function assertTokenCategoryExists(engineDir, tokensCssPath, catego
  */
 export function declareCategoryBanner(lines, category, tokensCssPath) {
     const bounds = findBaseRootBounds(lines);
-    if (bounds === null) {
+    if (bounds === undefined) {
         throw new GeneralError(`Cannot create category "${category}": no :root block found in ${tokensCssPath}. ` +
             'Run "fireforge furnace init --force" to re-scaffold the tokens CSS file.');
     }
@@ -190,8 +205,7 @@ export function declareCategoryBanner(lines, category, tokensCssPath) {
 export function findCategorySection(lines, category, tokensCssPath) {
     const singleLinePattern = singleLineBannerPattern(category);
     let categoryLine = -1;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i] ?? '';
+    for (const [i, line] of lines.entries()) {
         // Check single-line format: /* = Category = */
         if (singleLinePattern.test(line)) {
             categoryLine = i;
@@ -245,16 +259,10 @@ export function findCategorySection(lines, category, tokensCssPath) {
     return { categoryLine, sectionEnd };
 }
 /** 0-based open/close line indices of the base `:root {` block. */
-function findBaseRootBounds(lines) {
-    let open = -1;
-    for (let i = 0; i < lines.length; i++) {
-        if (/:root\s*\{/.test(lines[i] ?? '')) {
-            open = i;
-            break;
-        }
-    }
+export function findBaseRootBounds(lines) {
+    const open = lines.findIndex((line) => /:root\s*\{/.test(line));
     if (open === -1)
-        return null;
+        return undefined;
     for (let i = open + 1; i < lines.length; i++) {
         if (/^\s*\}/.test(lines[i] ?? '')) {
             return { open, close: i };
@@ -263,7 +271,7 @@ function findBaseRootBounds(lines) {
     return { open, close: -1 };
 }
 /** Masks block-comment content per line so declarations inside comments never match. */
-function maskCommentLines(lines) {
+export function maskCommentLines(lines) {
     const masked = lines.join('\n').replace(/\/\*[\s\S]*?\*\//g, (m) => m.replace(/[^\n]/g, ' '));
     return masked.split('\n');
 }
@@ -276,7 +284,7 @@ function maskCommentLines(lines) {
  */
 export function findTokenDeclarationInRoot(lines, tokenName) {
     const bounds = findBaseRootBounds(lines);
-    if (bounds === null || bounds.close === -1)
+    if (bounds === undefined || bounds.close === -1)
         return undefined;
     const masked = maskCommentLines(lines);
     const declPattern = new RegExp(`^\\s*${escapeRegex(tokenName)}\\s*:`);

package/dist/src/core/token-dark-mode.js

@@ -87,13 +87,7 @@ export function stripBlockCommentsInLines(lines) {
  */
 export function findDarkRootInsertionIndex(lines) {
     const stripped = stripBlockCommentsInLines(lines);
-    let darkMediaLine = -1;
-    for (let i = 0; i < stripped.length; i++) {
-        if (/prefers-color-scheme:\s*dark/.test(stripped[i] ?? '')) {
-            darkMediaLine = i;
-            break;
-        }
-    }
+    const darkMediaLine = stripped.findIndex((line) => /prefers-color-scheme:\s*dark/.test(line));
     if (darkMediaLine === -1)
         return null;
     // Walk the comment-stripped lines after the @media header and find
@@ -172,13 +166,7 @@ export function findBlockCloseIndex(stripped, startLine) {
  */
 export function findDarkMediaCloseIndex(lines) {
     const stripped = stripBlockCommentsInLines(lines);
-    let darkMediaLine = -1;
-    for (let i = 0; i < stripped.length; i++) {
-        if (/prefers-color-scheme:\s*dark/.test(stripped[i] ?? '')) {
-            darkMediaLine = i;
-            break;
-        }
-    }
+    const darkMediaLine = stripped.findIndex((line) => /prefers-color-scheme:\s*dark/.test(line));
     if (darkMediaLine === -1)
         return -1;
     return findBlockCloseIndex(stripped, darkMediaLine);

package/dist/src/core/token-inventory.d.ts

@@ -0,0 +1,56 @@
+/** One token declaration inside the base `:root` block. */
+export interface TokenInventoryEntry {
+    /** Custom-property name, including the leading `--`. */
+    name: string;
+    /** 1-based line number in the tokens CSS file. */
+    line: number;
+    /** Declared value, trimmed, without the trailing `;`. */
+    value: string;
+}
+/**
+ * Tokens grouped under the banner that precedes them, in file order.
+ * `category` is null for declarations that sit above the first banner —
+ * a real state in a hand-edited file, and one the report must show rather
+ * than silently drop.
+ */
+export interface TokenCategoryInventory {
+    category: string | null;
+    tokens: TokenInventoryEntry[];
+}
+/** One block that declares a given token, with the value it declares. */
+export interface TokenBlockValue {
+    /**
+     * Selector trail of the declaring block, outermost first, joined with
+     * ` > ` — for example `:root` or
+     * `@media (prefers-color-scheme: dark) > :root`.
+     */
+    block: string;
+    value: string;
+    /** 1-based line number of the declaration. */
+    line: number;
+}
+/**
+ * Collects every base-`:root` token declaration grouped by the category
+ * banner above it, in document order.
+ *
+ * Only the base block is walked: the dark `@media` and `:root[variant]`
+ * companions mirror declarations rather than owning them, so listing them
+ * would report the same token two or three times under no category at all.
+ *
+ * @param lines - Tokens CSS split into lines
+ * @returns Categories in file order, each with its tokens in file order
+ */
+export declare function collectTokenInventory(lines: string[]): TokenCategoryInventory[];
+/**
+ * Every declaration of `tokenName`, in every block of the file, labelled by
+ * the selector trail of the block that declares it.
+ *
+ * Deliberately not restricted to the base `:root`: the question `token show`
+ * answers is "what does this token resolve to", and a token whose dark
+ * override differs from its base value is precisely the case worth seeing.
+ *
+ * @param lines - Tokens CSS split into lines
+ * @param tokenName - Custom-property name including the leading `--`
+ * @returns Declarations in file order
+ */
+export declare function collectTokenBlockValues(lines: string[], tokenName: string): TokenBlockValue[];

package/dist/src/core/token-inventory.js

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Read-only inventory of the tokens CSS file: which categories exist, which
+ * tokens each declares, and what a single token resolves to in every theme
+ * block that mentions it.
+ *
+ * `token add` requires `--category` and, until now, nothing reported the
+ * categories a project actually has — so the only way to name one correctly
+ * was to hand-parse a neighbouring `= Category =` banner out of the file.
+ * This module is that report. It deliberately reuses the banner and
+ * `:root`-bounds primitives from `token-category.ts` rather than parsing
+ * tokens CSS a second way: two readers that disagree on what a banner is
+ * would put `token list` and `token add` in different sections of the same
+ * file.
+ */
+import { categoryBannerNameAt, findBaseRootBounds, maskCommentLines } from './token-category.js';
+/** Matches a custom-property declaration and captures its name and value. */
+const DECLARATION_PATTERN = /^\s*(--[A-Za-z0-9_-]+)\s*:\s*([^;]*);?/;
+/**
+ * Collects every base-`:root` token declaration grouped by the category
+ * banner above it, in document order.
+ *
+ * Only the base block is walked: the dark `@media` and `:root[variant]`
+ * companions mirror declarations rather than owning them, so listing them
+ * would report the same token two or three times under no category at all.
+ *
+ * @param lines - Tokens CSS split into lines
+ * @returns Categories in file order, each with its tokens in file order
+ */
+export function collectTokenInventory(lines) {
+    const bounds = findBaseRootBounds(lines);
+    if (bounds === undefined || bounds.close === -1)
+        return [];
+    const masked = maskCommentLines(lines);
+    const groups = [];
+    let current;
+    for (let i = bounds.open + 1; i < bounds.close; i++) {
+        // Banners are read from the RAW lines: `maskCommentLines` blanks comment
+        // bodies, which is exactly what a banner is.
+        const banner = categoryBannerNameAt(lines, i);
+        if (banner !== undefined) {
+            current = { category: banner, tokens: [] };
+            groups.push(current);
+            continue;
+        }
+        const match = DECLARATION_PATTERN.exec(masked[i] ?? '');
+        if (!match?.[1])
+            continue;
+        if (current === undefined) {
+            current = { category: null, tokens: [] };
+            groups.push(current);
+        }
+        current.tokens.push({ name: match[1], line: i + 1, value: (match[2] ?? '').trim() });
+    }
+    // A banner with no declarations under it is still a category `token add
+    // --category` accepts, so empty groups are kept.
+    return groups;
+}
+/**
+ * Every declaration of `tokenName`, in every block of the file, labelled by
+ * the selector trail of the block that declares it.
+ *
+ * Deliberately not restricted to the base `:root`: the question `token show`
+ * answers is "what does this token resolve to", and a token whose dark
+ * override differs from its base value is precisely the case worth seeing.
+ *
+ * @param lines - Tokens CSS split into lines
+ * @param tokenName - Custom-property name including the leading `--`
+ * @returns Declarations in file order
+ */
+export function collectTokenBlockValues(lines, tokenName) {
+    const masked = maskCommentLines(lines);
+    const trail = [];
+    const found = [];
+    for (let i = 0; i < masked.length; i++) {
+        const line = masked[i] ?? '';
+        const match = DECLARATION_PATTERN.exec(line);
+        if (match?.[1] === tokenName) {
+            found.push({
+                block: trail.length > 0 ? trail.join(' > ') : '(file scope)',
+                value: (match[2] ?? '').trim(),
+                line: i + 1,
+            });
+        }
+        // Brace tracking after the declaration test, so a one-line block cannot
+        // swallow the declaration it opens on. Selector text is whatever
+        // precedes the `{`; an empty selector (a continuation line) still needs
+        // a stack entry or the closing `}` pops the wrong one.
+        for (const char of line) {
+            if (char === '{') {
+                trail.push(selectorBefore(line, trail.length));
+            }
+            else if (char === '}') {
+                trail.pop();
+            }
+        }
+    }
+    return found;
+}
+/**
+ * Selector text introducing the `depth`-th open brace on `line`. Falls back
+ * to a positional label so the trail stays well-formed on a minified or
+ * continuation line that opens a block with no visible selector.
+ */
+function selectorBefore(line, depth) {
+    const open = line.indexOf('{');
+    const text = open === -1 ? '' : line.slice(0, open).trim();
+    return text.length > 0 ? text : `(block ${String(depth + 1)})`;
+}

package/dist/src/core/token-manager.d.ts

@@ -10,7 +10,7 @@ export declare const TOKEN_MODES: readonly ["auto", "static", "override"];
 /** Dark mode behaviour for a token. */
 export type TokenMode = (typeof TOKEN_MODES)[number];
 /** Narrows an arbitrary string to a {@link TokenMode}. */
-export declare const isTokenMode: (value: string) => value is "override" | "auto" | "static";
+export declare const isTokenMode: (value: string) => value is "auto" | "override" | "static";
 /**
  * Options for adding a token.
  */

package/dist/src/core/token-manager.js

@@ -177,7 +177,7 @@ function evaluateBaseTokenIdempotency(lines, options, tokensCssPath) {
         ? 'remove the stray declaration first'
         : `pass --category "${existing.category}" to target the existing declaration, or remove it first`;
     throw new GeneralError(`Token "${options.tokenName}" is already declared outside category "${options.category}" ` +
-        `(${tokensCssPath}:${String(existing.line)}${sectionSuffix}). ` +
+        `(${tokensCssPath}:${existing.line}${sectionSuffix}). ` +
         `A token belongs to exactly one category — ${remedy}.`);
 }
 /**

package/dist/src/core/token-variant.js

@@ -32,29 +32,29 @@ const ATTRIBUTE_FRAGMENT_PATTERN = /^\[[a-zA-Z][a-zA-Z0-9_-]*(?:=(?:"[a-zA-Z0-9_
 const QUALIFIER_PATTERN = /^:[a-zA-Z][a-zA-Z0-9-]*(?:\(([^()]*)\))?$/;
 /**
  * Splits a run of consecutive attribute fragments into its groups, or
- * returns `null` when the run is not exactly that — a group that does not
+ * returns `undefined` when the run is not exactly that — a group that does not
  * open with `[`, an unclosed group, an empty run, or a group whose name or
  * value is not identifier-safe.
  *
  * @param run - The `[…][…]` text with no `:root` prefix
- * @returns The individual fragments, or null when the run is not valid
+ * @returns The individual fragments, or undefined when the run is not valid
  */
 function splitAttributeGroups(run) {
     const groups = [];
     let cursor = 0;
     while (cursor < run.length) {
         if (run[cursor] !== '[')
-            return null;
+            return undefined;
         const close = run.indexOf(']', cursor);
         if (close === -1)
-            return null;
+            return undefined;
         const group = run.slice(cursor, close + 1);
         if (!ATTRIBUTE_FRAGMENT_PATTERN.test(group))
-            return null;
+            return undefined;
         groups.push(group);
         cursor = close + 1;
     }
-    return groups.length > 0 ? groups : null;
+    return groups.length > 0 ? groups : undefined;
 }
 /** Rewrites `=value` / `='value'` to the double-quoted Mozilla convention. */
 function normalizeAttributeFragment(group) {
@@ -96,10 +96,10 @@ export function validateVariantSelector(raw) {
     // The parse must have consumed the WHOLE fragment: anything it declined to
     // read (a stray space, a trailing combinator) is text the matcher would
     // not see either, so accepting it would author a block nothing can find.
-    if (parts === null || `${parts.attributes}${parts.qualifier}` !== `:root${value}`)
+    if (parts === undefined || `${parts.attributes}${parts.qualifier}` !== `:root${value}`)
         return reject;
     const groups = splitAttributeGroups(parts.attributes.slice(':root'.length));
-    if (groups === null)
+    if (groups === undefined)
         return reject;
     let qualifier = '';
     if (parts.qualifier !== '') {
@@ -112,7 +112,7 @@ export function validateVariantSelector(raw) {
         }
         else {
             const innerGroups = splitAttributeGroups(inner);
-            if (innerGroups === null)
+            if (innerGroups === undefined)
                 return reject;
             const name = parts.qualifier.slice(0, parts.qualifier.indexOf('('));
             qualifier = `${name}(${innerGroups.map(normalizeAttributeFragment).join('')})`;
@@ -131,7 +131,7 @@ function canonicalSelector(selector) {
 }
 /**
  * Splits the `:root[…]` selector on `line` into its attribute run and any
- * trailing qualifier, or `null` when the line carries none.
+ * trailing qualifier, or `undefined` when the line carries none.
  *
  * Index arithmetic rather than `/:root\[[^{]*\]/`: `[^{]` also matches `]`,
  * so that pattern backtracks quadratically on a line repeating `:root[`
@@ -155,7 +155,7 @@ function canonicalSelector(selector) {
 function rootAttributeSelector(line) {
     const start = line.indexOf(':root[');
     if (start === -1)
-        return null;
+        return undefined;
     const brace = line.indexOf('{', start);
     const limit = brace === -1 ? line.length : brace;
     let cursor = start + ':root'.length;
@@ -168,13 +168,13 @@ function rootAttributeSelector(line) {
         end = cursor;
     }
     if (end === start + ':root'.length)
-        return null;
+        return undefined;
     return { attributes: line.slice(start, end), qualifier: line.slice(end, limit).trim() };
 }
 /**
  * Finds the top-level `:root<variant>` block whose attribute selector
  * matches `variant` (compared canonically). Returns the opening-brace and
- * closing-brace line indices, or `null` when no such block exists.
+ * closing-brace line indices, or `undefined` when no such block exists.
  *
  * Scans a comment-stripped mirror of `lines` so braces inside comments do
  * not offset the depth counter; the returned indices line up with the
@@ -189,10 +189,9 @@ function findVariantBlock(lines, variant) {
     const requested = rootAttributeSelector(`:root${variant} {`);
     const want = canonicalSelector(requested?.attributes ?? `:root${variant}`);
     const wantQualifier = canonicalSelector(requested?.qualifier ?? '');
-    for (let i = 0; i < stripped.length; i++) {
-        const line = stripped[i] ?? '';
+    for (const [i, line] of stripped.entries()) {
         const selector = rootAttributeSelector(line);
-        if (selector === null || canonicalSelector(selector.attributes) !== want)
+        if (selector === undefined || canonicalSelector(selector.attributes) !== want)
             continue;
         // An UNqualified request still matches a qualified block: that is the
         // 0.44.2 behaviour `variantBlockQualifier` exists to report, since
@@ -219,7 +218,7 @@ function findVariantBlock(lines, variant) {
             continue;
         return { open: openLine, close, qualifier: selector.qualifier };
     }
-    return null;
+    return undefined;
 }
 /**
  * Returns the line index at which a brand-new `:root<variant>` block should
@@ -229,8 +228,8 @@ function findVariantBlock(lines, variant) {
  */
 function findVariantBlockInsertionPoint(lines) {
     const stripped = stripBlockCommentsInLines(lines);
-    for (let i = 0; i < stripped.length; i++) {
-        if (/^\s*:root\s*\{/.test(stripped[i] ?? '')) {
+    for (const [i, line] of stripped.entries()) {
+        if (/^\s*:root\s*\{/.test(line)) {
             const close = findBlockCloseIndex(stripped, i);
             if (close !== -1)
                 return close + 1;
@@ -245,7 +244,7 @@ function findVariantBlockInsertionPoint(lines) {
  * the block, which is only wanted for the explicit `--variant` flow.
  */
 export function variantBlockExists(lines, variant) {
-    return findVariantBlock(lines, variant) !== null;
+    return findVariantBlock(lines, variant) !== undefined;
 }
 /**
  * The pseudo-class qualifier on the matched `:root<variant>` block, or
@@ -300,8 +299,8 @@ export function findVariantBlockDeclaration(lines, variant, tokenName) {
         .join('\n')
         .replace(/\/\*[\s\S]*?\*\//g, (match) => match.replace(/[^\n]/g, ' '))
         .split('\n');
-    for (let i = 0; i < stripped.length; i++) {
-        if ((stripped[i] ?? '').includes(`${tokenName}:`))
+    for (const [i, line] of stripped.entries()) {
+        if (line.includes(`${tokenName}:`))
             return { line: block.open + i + 1 };
     }
     return undefined;

package/dist/src/core/toolchain-preflight.js

@@ -121,7 +121,7 @@ export function formatMajorVersionHopNotice(previousVersion, newVersion) {
         return undefined;
     if (previousMajor === newMajor)
         return undefined;
-    return (`Firefox major version changed (${String(previousMajor)} → ${String(newMajor)}): ` +
+    return (`Firefox major version changed (${previousMajor} → ${newMajor}): ` +
         'upstream toolchain minimums (cbindgen, Rust, …) may have moved with it. ' +
         'Consider running "fireforge bootstrap" before the next build.');
 }

package/dist/src/core/tree-cow.d.ts

@@ -2,8 +2,6 @@
 export type CloneExecutor = (command: string, args: string[]) => Promise<void>;
 /** How this host can materialise a tree. */
 export type CowCapability = 'clonefile' | 'reflink' | 'none';
-/** Per-platform `cp` argv prefix for a CoW copy of one entry. */
-export declare function cowCopyArgs(capability: Exclude<CowCapability, 'none'>): string[];
 /**
  * Probes CoW support in `dir` by cloning a tiny probe file there.
  * Non-darwin/linux platforms report 'none' without probing.

package/dist/src/core/tree-cow.js

@@ -20,11 +20,11 @@ import { exec } from '../utils/process.js';
 const defaultExecutor = async (command, args) => {
     const result = await exec(command, args);
     if (result.exitCode !== 0) {
-        throw new Error(`${command} ${args.join(' ')} failed (exit ${String(result.exitCode)}): ${result.stderr}`);
+        throw new Error(`${command} ${args.join(' ')} failed (exit ${result.exitCode}): ${result.stderr}`);
     }
 };
 /** Per-platform `cp` argv prefix for a CoW copy of one entry. */
-export function cowCopyArgs(capability) {
+function cowCopyArgs(capability) {
     return capability === 'clonefile' ? ['-c', '-R', '-p'] : ['--reflink=always', '-a'];
 }
 /**

package/dist/src/core/tree-store.js

@@ -19,6 +19,7 @@ import { GeneralError } from '../errors/base.js';
 import { mapWithConcurrency } from '../utils/concurrency.js';
 import { getNodeErrorCode, isProcessAlive, toError } from '../utils/errors.js';
 import { pathExists, readJson, writeJson } from '../utils/fs.js';
+import { sha256Hex } from '../utils/hash.js';
 import { verbose, warn } from '../utils/logger.js';
 import { isObject } from '../utils/validation.js';
 import { getBuildBaselinePath } from './build-baseline.js';
@@ -128,7 +129,7 @@ export async function readTreeMarker(root) {
         const code = getNodeErrorCode(error);
         if (code === 'ENOENT' || code === 'ENOTDIR')
             return { kind: 'absent' };
-        verbose(`Unreadable tree marker at ${markerPath}: ${String(error)}`);
+        verbose(`Unreadable tree marker at ${markerPath}: ${toError(error).message}`);
         return { kind: 'corrupt', reason: `the marker could not be read (${toError(error).message})` };
     }
 }
@@ -178,9 +179,7 @@ export async function computePrimaryFingerprint(primaryRoot) {
     }
     let engineFingerprint;
     try {
-        engineFingerprint = createHash('sha256')
-            .update(await getAllDiff(engineDir))
-            .digest('hex');
+        engineFingerprint = sha256Hex(await getAllDiff(engineDir));
     }
     catch {
         engineFingerprint = null;
@@ -461,7 +460,7 @@ export async function removeTree(primaryRoot, name, options = {}) {
     ]) {
         const state = await inspectTreeLock(lockPath);
         if (state.kind === 'held') {
-            throw new GeneralError(`Refusing to remove tree "${name}": a live process (pid ${String(state.pid)}) holds ${lockPath}. ` +
+            throw new GeneralError(`Refusing to remove tree "${name}": a live process (pid ${state.pid}) holds ${lockPath}. ` +
                 'Wait for it to finish, then retry.');
         }
         if (state.kind === 'unknown' && options.force !== true) {

package/dist/src/core/typecheck.js

@@ -144,7 +144,7 @@ export async function runTypecheck(projectRoot, cfg) {
  */
 function resolveProjectExtraShim(cfg, projectPath) {
     const overrides = cfg.projectOverrides;
-    if (overrides && Object.prototype.hasOwnProperty.call(overrides, projectPath)) {
+    if (overrides && Object.hasOwn(overrides, projectPath)) {
         const value = overrides[projectPath];
         return value === null ? undefined : value;
     }
@@ -298,7 +298,7 @@ async function runTypecheckForProject(ts, projectRoot, projectPath, shimSource,
         }
         issues.push(diagnosticToIssue(ts, diag, absConfig, projectPath));
     }
-    verbose(`typecheck: ${projectPath} — analyzed ${String(parsed.fileNames.length)} file(s), found ${String(issues.length)} issue(s)`);
+    verbose(`typecheck: ${projectPath} — analyzed ${parsed.fileNames.length} file(s), found ${issues.length} issue(s)`);
     return {
         project: projectPath,
         issues,