@hominis/fireforge 0.49.2 → 0.51.0

package/dist/src/core/objdir-install-manifests.js

@@ -0,0 +1,226 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Reads the objdir's mozpack install manifests to tell how an engine source
+ * reaches the runtime a test runs against.
+ *
+ * mozbuild installs packaged files from manifests under
+ * `obj-*\/_build_manifests/install/` and `obj-*\/faster/install_*`. Each
+ * line after the version is a `\x1f`-separated entry: type 1 installs a
+ * symlink to an absolute source, 2 copies it, 7 preprocesses it, and 5/6
+ * are the pattern forms of 1/2 (`base`, `pattern`, `dest dir`). In a
+ * non-Windows dev build most chrome and test files are type-1 symlinks back
+ * into `engine/`, so an edit to such a file is already what the runtime
+ * reads. `_test_files` is rewritten and installed by `mach test` itself on
+ * every dispatch, so test files are restaged when a run starts.
+ *
+ * Every classification is conservative: an entry whose install base is
+ * unknown, a symlink that does not resolve to the edited source, or an
+ * unreadable manifest leaves the path classified as packaged.
+ */
+import { lstat, readdir, readFile, realpath } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { toError } from '../utils/errors.js';
+import { verbose } from '../utils/logger.js';
+import { normalizePathSlashes } from '../utils/paths.js';
+import { escapeRegex } from '../utils/regex.js';
+/** Install-manifest field separator. */
+const FIELD_SEPARATOR = '\x1f';
+/** mozpack entry types that install a symlink. */
+const SYMLINK_TYPE = '1';
+const PATTERN_SYMLINK_TYPE = '5';
+const PATTERN_COPY_TYPE = '6';
+/** Entry types with no source file (existence markers, inline content). */
+const SOURCELESS_TYPES = new Set(['3', '4', '8']);
+/** The manifest `mach test` writes and installs at every dispatch. */
+const DISPATCH_MANIFEST = '_test_files';
+/** Converts a mozpack pattern (`*`, `**`, `?`) to an anchored RegExp. */
+function patternToRegExp(pattern) {
+    if (pattern.split('/').includes('..'))
+        return undefined;
+    let source = '';
+    for (let i = 0; i < pattern.length; i += 1) {
+        const char = pattern[i] ?? '';
+        if (pattern.startsWith('**/', i)) {
+            source += '(?:.*/)?';
+            i += 2;
+        }
+        else if (pattern.startsWith('**', i)) {
+            source += '.*';
+            i += 1;
+        }
+        else if (char === '*')
+            source += '[^/]*';
+        else if (char === '?')
+            source += '[^/]';
+        else
+            source += escapeRegex(char);
+    }
+    return new RegExp(`^${source}$`);
+}
+function engineRelative(roots, absolute) {
+    const normalized = normalizePathSlashes(absolute);
+    for (const root of roots) {
+        if (normalized.startsWith(`${root}/`))
+            return normalized.slice(root.length + 1);
+    }
+    return undefined;
+}
+/** Install base (objdir-relative) of a `_build_manifests/install/<name>` manifest. */
+function buildManifestBase(name) {
+    if (name === DISPATCH_MANIFEST || name === '_tests')
+        return '_tests';
+    const dist = /^dist_(.+)$/.exec(name);
+    return dist ? `dist/${dist[1] ?? ''}` : undefined;
+}
+/** `faster/install_*` manifest name → install base, from `faster/Makefile`. */
+async function fasterManifestBases(objDirPath) {
+    const bases = new Map();
+    const makefile = await readFile(join(objDirPath, 'faster', 'Makefile'), 'utf8').catch(() => '');
+    const line = /^INSTALL_MANIFESTS\s*=(.*)$/m.exec(makefile)?.[1] ?? '';
+    for (const base of line.trim().split(/\s+/).filter(Boolean)) {
+        bases.set(`install_${base.replaceAll('/', '_')}`, base);
+    }
+    // `mach build faster` installs a merged copy of the per-directory
+    // manifests, rooted at dist/bin.
+    bases.set('unified_install_dist_bin', 'dist/bin');
+    return bases;
+}
+function parseManifest(index, content, installRoot, atDispatch) {
+    for (const line of content.split('\n').slice(1)) {
+        const fields = line.split(FIELD_SEPARATOR);
+        const [type = '', dest = '', source = ''] = fields;
+        if (SOURCELESS_TYPES.has(type) || source === '')
+            continue;
+        const base = engineRelative(index.engineRoots, source);
+        if (base === undefined)
+            continue;
+        if (type === PATTERN_SYMLINK_TYPE || type === PATTERN_COPY_TYPE) {
+            const pattern = patternToRegExp(fields[3] ?? '');
+            const destDir = fields[4];
+            if (pattern === undefined)
+                continue;
+            index.patterns.push({
+                symlink: type === PATTERN_SYMLINK_TYPE,
+                base,
+                pattern,
+                destDir: installRoot === undefined || destDir === undefined
+                    ? undefined
+                    : join(installRoot, destDir),
+                atDispatch,
+            });
+            continue;
+        }
+        const entries = index.explicit.get(base) ?? [];
+        entries.push({
+            symlink: type === SYMLINK_TYPE,
+            dest: installRoot === undefined ? undefined : join(installRoot, dest),
+            atDispatch,
+        });
+        index.explicit.set(base, entries);
+    }
+}
+async function readManifests(dir, baseFor, index, objDirPath) {
+    let names;
+    try {
+        names = await readdir(dir);
+    }
+    catch {
+        return false;
+    }
+    for (const name of names) {
+        if (name.startsWith('.') || name.endsWith('.track') || name === 'Makefile')
+            continue;
+        const content = await readFile(join(dir, name), 'utf8').catch(() => undefined);
+        if (content === undefined)
+            continue;
+        const base = baseFor(name);
+        parseManifest(index, content, base === undefined ? undefined : join(objDirPath, base), name === DISPATCH_MANIFEST);
+    }
+    return true;
+}
+/**
+ * Loads every install manifest of `objDir`. Undefined when neither manifest
+ * directory is readable, i.e. nothing can be classified.
+ *
+ * @param engineDir - Absolute engine directory
+ * @param objDir - Objdir name under the engine directory
+ */
+export async function loadInstallManifestIndex(engineDir, objDir) {
+    const objDirPath = join(engineDir, objDir);
+    const roots = [normalizePathSlashes(resolve(engineDir))];
+    const real = await realpath(engineDir).catch(() => undefined);
+    if (real !== undefined && !roots.includes(normalizePathSlashes(real))) {
+        roots.push(normalizePathSlashes(real));
+    }
+    const index = { explicit: new Map(), patterns: [], engineRoots: roots };
+    try {
+        const fasterBases = await fasterManifestBases(objDirPath);
+        const readBuild = await readManifests(join(objDirPath, '_build_manifests', 'install'), buildManifestBase, index, objDirPath);
+        const readFaster = await readManifests(join(objDirPath, 'faster'), (name) => fasterBases.get(name), index, objDirPath);
+        return readBuild || readFaster ? index : undefined;
+    }
+    catch (error) {
+        verbose(`Install manifests unreadable under ${objDir}: ${toError(error).message}`);
+        return undefined;
+    }
+}
+/** True when `dest` is a symlink resolving to the same file as `source`. */
+async function isSymlinkTo(dest, source) {
+    if (dest === undefined)
+        return false;
+    try {
+        if (!(await lstat(dest)).isSymbolicLink())
+            return false;
+        return (await realpath(dest)) === (await realpath(source));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Classifies how `relPath` reaches the runtime. See {@link RuntimeDelivery}.
+ *
+ * @param index - Index from {@link loadInstallManifestIndex}
+ * @param engineDir - Absolute engine directory
+ * @param relPath - Engine-relative POSIX path
+ */
+export async function classifyRuntimeDelivery(index, engineDir, relPath) {
+    const entries = [...(index.explicit.get(relPath) ?? [])];
+    for (const pattern of index.patterns) {
+        if (!relPath.startsWith(`${pattern.base}/`))
+            continue;
+        const rest = relPath.slice(pattern.base.length + 1);
+        if (!pattern.pattern.test(rest))
+            continue;
+        entries.push({
+            symlink: pattern.symlink,
+            dest: pattern.destDir === undefined ? undefined : join(pattern.destDir, rest),
+            atDispatch: pattern.atDispatch,
+        });
+    }
+    if (entries.length === 0)
+        return 'unlisted';
+    if (entries.every((entry) => entry.atDispatch))
+        return 'at-dispatch';
+    const source = join(engineDir, relPath);
+    for (const entry of entries) {
+        if (entry.atDispatch)
+            continue;
+        if (!entry.symlink || !(await isSymlinkTo(entry.dest, source)))
+            return 'packaged';
+    }
+    return 'live';
+}
+/**
+ * True when any install-manifest entry installs something from at or
+ * beneath the engine-relative directory `dir`, or a pattern entry's base
+ * contains it.
+ */
+export function installsFromDirectory(index, dir) {
+    const prefix = dir.replace(/\/+$/, '');
+    const under = (path) => path === prefix || path.startsWith(`${prefix}/`);
+    for (const source of index.explicit.keys())
+        if (under(source))
+            return true;
+    return index.patterns.some((pattern) => under(pattern.base) || prefix.startsWith(`${pattern.base}/`));
+}

package/dist/src/core/park-store.d.ts

@@ -0,0 +1,63 @@
+/** One parked file: both sides, null meaning absent. */
+export interface ParkedFile {
+    /** Engine-relative path. */
+    path: string;
+    /** The file as the session left it. */
+    before: string | null;
+    /** The file the park wrote in its place. */
+    after: string | null;
+}
+/** The record of one park. */
+export interface ParkRecord {
+    label: string;
+    /** The patch whose files were parked. */
+    patch: string;
+    createdAt: string;
+    /** `baseline` parks every drifted hunk, `hunks` only those a diff named. */
+    mode: 'baseline' | 'hunks';
+    files: ParkedFile[];
+}
+/** What `park.json` holds: the record without file contents. */
+interface ParkIndex extends Omit<ParkRecord, 'files'> {
+    files: {
+        path: string;
+        before: boolean;
+        after: boolean;
+    }[];
+}
+/** The outcome of restoring one file. */
+export type RestoreOutcome = 'restored' | 'unchanged' | 'merged' | 'conflict';
+/** Writes a park; refuses to overwrite an existing label. */
+export declare function writePark(projectRoot: string, record: ParkRecord): Promise<string>;
+/** Reads a park back, contents included. */
+export declare function readPark(projectRoot: string, label: string): Promise<ParkRecord>;
+/** Every park of the project, oldest first. */
+export declare function listParks(projectRoot: string): Promise<ParkIndex[]>;
+/** Deletes a park. */
+export declare function dropPark(projectRoot: string, label: string): Promise<void>;
+/** Reads an engine file, null when absent. */
+export declare function readEngineFile(engineDir: string, path: string): Promise<string | null>;
+/** Writes an engine file, removing it for null. */
+export declare function writeEngineFile(engineDir: string, path: string, content: string | null): Promise<void>;
+/**
+ * Three-way merges `ours` and `theirs` over `base` with `git merge-file`.
+ * Conflicts come back as marker blocks.
+ */
+export declare function mergeThreeWay(ours: string, base: string, theirs: string, path: string): Promise<{
+    content: string;
+    conflicts: number;
+}>;
+/**
+ * What restoring one parked file writes: `before` when the file is still
+ * as the park left it, nothing when it already matches `before`, and a
+ * three-way merge otherwise. Absence only merges with absence.
+ */
+export declare function planRestore(file: ParkedFile, now: string | null): Promise<{
+    outcome: RestoreOutcome;
+    content: string | null;
+}>;
+/** Message ids a Fluent file's lines declare (`id = …`, `-term = …`). */
+export declare function fluentIds(lines: readonly string[]): string[];
+/** Lines `before` has that `after` lacks, as a multiset difference. */
+export declare function removedLines(before: string | null, after: string | null): string[];
+export {};

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

@@ -0,0 +1,216 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Storage and merge logic behind `fireforge park`.
+ *
+ * Several sessions edit the same Hominis files on one engine, and a peer's
+ * `re-export --refuse-foreign-drift` refuses while another session's hunks
+ * sit in its patch's files. Setting those hunks aside meant reversing each
+ * one by hand. A park records, for every file of one patch that drifted:
+ *
+ *  - `before`: the file as the session left it (what the park takes away),
+ *  - `after`: what the park writes in its place (the queue-applied
+ *    baseline, or the working tree minus the named hunks).
+ *
+ * Restoring is a three-way merge of the file as it is now (ours) with
+ * `before` (theirs) over `after` (base), so the owner's commit in between
+ * is kept and the parked hunks come back on top of it.
+ *
+ * A park lives under `.fireforge/park/<label>/`: `park.json` plus one copy
+ * of each side per file. Absent files are recorded as absent, never as
+ * empty.
+ */
+import { mkdtemp, readdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { InvalidArgumentError } from '../errors/base.js';
+import { getNodeErrorCode } from '../utils/errors.js';
+import { ensureDir, pathExists, readJson, readText, removeFile, writeJson, writeText, } from '../utils/fs.js';
+import { exec } from '../utils/process.js';
+import { FIREFORGE_DIR } from './config-paths.js';
+const LABEL_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+/** The directory holding every park of a project. */
+function parkRoot(projectRoot) {
+    return join(projectRoot, FIREFORGE_DIR, 'park');
+}
+/** Refuses a label that is not a plain file-name segment. */
+function assertParkLabel(label) {
+    if (!LABEL_PATTERN.test(label)) {
+        throw new InvalidArgumentError(`Park label "${label}" must be letters, digits, ".", "_" or "-", starting with a letter or digit.`, '--label');
+    }
+}
+function sideDir(dir, side) {
+    return join(dir, side);
+}
+/** Writes a park; refuses to overwrite an existing label. */
+export async function writePark(projectRoot, record) {
+    assertParkLabel(record.label);
+    const dir = join(parkRoot(projectRoot), record.label);
+    if (await pathExists(dir)) {
+        throw new InvalidArgumentError(`A park named "${record.label}" already exists. Restore or drop it first, or pass another --label.`, '--label');
+    }
+    for (const file of record.files) {
+        for (const side of ['before', 'after']) {
+            const content = file[side];
+            if (content === null)
+                continue;
+            const target = join(sideDir(dir, side), file.path);
+            await ensureDir(dirname(target));
+            await writeText(target, content);
+        }
+    }
+    const index = {
+        label: record.label,
+        patch: record.patch,
+        createdAt: record.createdAt,
+        mode: record.mode,
+        files: record.files.map((file) => ({
+            path: file.path,
+            before: file.before !== null,
+            after: file.after !== null,
+        })),
+    };
+    await writeJson(join(dir, 'park.json'), index);
+    return dir;
+}
+/** Reads a park back, contents included. */
+export async function readPark(projectRoot, label) {
+    assertParkLabel(label);
+    const dir = join(parkRoot(projectRoot), label);
+    if (!(await pathExists(join(dir, 'park.json')))) {
+        throw new InvalidArgumentError(`No park named "${label}". List them with "fireforge park --list".`, label);
+    }
+    const index = await readJson(join(dir, 'park.json'));
+    const files = [];
+    for (const entry of index.files) {
+        files.push({
+            path: entry.path,
+            before: entry.before ? await readText(join(sideDir(dir, 'before'), entry.path)) : null,
+            after: entry.after ? await readText(join(sideDir(dir, 'after'), entry.path)) : null,
+        });
+    }
+    return { ...index, files };
+}
+/** Every park of the project, oldest first. */
+export async function listParks(projectRoot) {
+    let names;
+    try {
+        names = (await readdir(parkRoot(projectRoot), { withFileTypes: true }))
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+    }
+    catch (error) {
+        if (getNodeErrorCode(error) === 'ENOENT')
+            return [];
+        throw error;
+    }
+    const parks = [];
+    for (const name of names) {
+        const path = join(parkRoot(projectRoot), name, 'park.json');
+        if (await pathExists(path))
+            parks.push(await readJson(path));
+    }
+    return parks.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+/** Deletes a park. */
+export async function dropPark(projectRoot, label) {
+    assertParkLabel(label);
+    const dir = join(parkRoot(projectRoot), label);
+    if (!(await pathExists(dir))) {
+        throw new InvalidArgumentError(`No park named "${label}".`, label);
+    }
+    await rm(dir, { recursive: true, force: true });
+}
+/** Reads an engine file, null when absent. */
+export async function readEngineFile(engineDir, path) {
+    const full = join(engineDir, path);
+    return (await pathExists(full)) ? await readText(full) : null;
+}
+/** Writes an engine file, removing it for null. */
+export async function writeEngineFile(engineDir, path, content) {
+    const full = join(engineDir, path);
+    if (content === null) {
+        if (await pathExists(full))
+            await removeFile(full);
+        return;
+    }
+    await ensureDir(dirname(full));
+    await writeText(full, content);
+}
+/**
+ * Three-way merges `ours` and `theirs` over `base` with `git merge-file`.
+ * Conflicts come back as marker blocks.
+ */
+export async function mergeThreeWay(ours, base, theirs, path) {
+    const scratch = await mkdtemp(join(tmpdir(), 'fireforge-park-'));
+    try {
+        const files = {
+            ours: join(scratch, 'ours'),
+            base: join(scratch, 'base'),
+            theirs: join(scratch, 'theirs'),
+        };
+        await writeFile(files.ours, ours);
+        await writeFile(files.base, base);
+        await writeFile(files.theirs, theirs);
+        const result = await exec('git', [
+            'merge-file',
+            '-p',
+            '-L',
+            `${path} (now)`,
+            '-L',
+            `${path} (parked from)`,
+            '-L',
+            `${path} (parked)`,
+            files.ours,
+            files.base,
+            files.theirs,
+        ]);
+        if (result.exitCode < 0 || result.exitCode > 127) {
+            throw new Error(`git merge-file failed for ${path}: ${result.stderr.trim()}`);
+        }
+        return { content: result.stdout, conflicts: result.exitCode };
+    }
+    finally {
+        await rm(scratch, { recursive: true, force: true });
+    }
+}
+/**
+ * What restoring one parked file writes: `before` when the file is still
+ * as the park left it, nothing when it already matches `before`, and a
+ * three-way merge otherwise. Absence only merges with absence.
+ */
+export async function planRestore(file, now) {
+    if (now === file.after)
+        return { outcome: 'restored', content: file.before };
+    if (now === file.before)
+        return { outcome: 'unchanged', content: now };
+    if (now === null || file.before === null || file.after === null) {
+        return { outcome: 'conflict', content: now };
+    }
+    const merged = await mergeThreeWay(now, file.after, file.before, file.path);
+    return { outcome: merged.conflicts > 0 ? 'conflict' : 'merged', content: merged.content };
+}
+/** Message ids a Fluent file's lines declare (`id = …`, `-term = …`). */
+export function fluentIds(lines) {
+    const ids = [];
+    for (const line of lines) {
+        const match = /^(-?[A-Za-z][\w-]*)\s*=/.exec(line);
+        if (match?.[1] !== undefined)
+            ids.push(match[1]);
+    }
+    return ids;
+}
+/** Lines `before` has that `after` lacks, as a multiset difference. */
+export function removedLines(before, after) {
+    const remaining = new Map();
+    for (const line of (after ?? '').split('\n'))
+        remaining.set(line, (remaining.get(line) ?? 0) + 1);
+    const removed = [];
+    for (const line of (before ?? '').split('\n')) {
+        const count = remaining.get(line) ?? 0;
+        if (count > 0)
+            remaining.set(line, count - 1);
+        else
+            removed.push(line);
+    }
+    return removed;
+}

package/dist/src/core/patch-export-update.d.ts

@@ -12,6 +12,8 @@ export interface UpdatePatchPolicyGate {
     config: FireForgeConfig;
     command: string;
     forceUnsafe?: boolean;
+    /** Restricts enforcement to these rows' findings (see `enforcePatchPolicy`). */
+    scope?: readonly string[];
 }
 export interface UpdatePatchAndMetadataOptions {
     /** Patch directory holding the body and `patches.json`. */
@@ -22,6 +24,8 @@ export interface UpdatePatchAndMetadataOptions {
     newContent: string;
     /** Manifest-row fields to merge into the patch's metadata. */
     updates: Partial<PatchMetadata>;
+    /** Manifest-row fields to delete, e.g. a staged block left empty. */
+    unset?: readonly (keyof PatchMetadata)[] | undefined;
     /** Hook run under the lock after the mutation succeeds. */
     onCommitted?: UpdatePatchCommittedHook | undefined;
     /** Policy gate run against the under-lock projected manifest. */
@@ -47,3 +51,5 @@ export interface UpdatePatchAndMetadataOptions {
  *   already byte-identical to the new content.
  */
 export declare function updatePatchAndMetadata(options: UpdatePatchAndMetadataOptions): Promise<boolean>;
+/** A copy of `row` without `fields`. */
+export declare function withoutFields(row: PatchMetadata, fields: readonly (keyof PatchMetadata)[]): PatchMetadata;

package/dist/src/core/patch-export-update.js

@@ -25,7 +25,7 @@ import { buildProjectedManifest, enforcePatchPolicy } from './patch-policy.js';
  *   already byte-identical to the new content.
  */
 export async function updatePatchAndMetadata(options) {
-    const { patchesDir, filename, newContent, updates, onCommitted, policyGate, lockOptions = {}, } = options;
+    const { patchesDir, filename, newContent, updates, unset = [], onCommitted, policyGate, lockOptions = {}, } = options;
     return withPatchDirectoryLock(patchesDir, async () => {
         const manifest = await loadPatchesManifestForWrite(patchesDir);
         if (!manifest) {
@@ -41,13 +41,14 @@ export async function updatePatchAndMetadata(options) {
         }
         const originalContent = await readText(patchPath);
         const existingPatch = manifest.patches[patchIndex];
-        manifest.patches[patchIndex] = { ...existingPatch, ...updates };
+        manifest.patches[patchIndex] = withoutFields({ ...existingPatch, ...updates }, unset);
         if (policyGate !== undefined) {
             enforcePatchPolicy({
                 config: policyGate.config,
                 manifest: buildProjectedManifest(manifest, manifest.patches),
                 command: policyGate.command,
                 forceUnsafe: policyGate.forceUnsafe === true,
+                ...(policyGate.scope !== undefined ? { scope: policyGate.scope } : {}),
             });
         }
         const normalized = newContent;
@@ -58,7 +59,7 @@ export async function updatePatchAndMetadata(options) {
                 await writeText(patchPath, normalized);
                 patchWritten = true;
             }
-            await mutatePatchRowsInManifest(patchesDir, [filename], () => ({ set: updates }));
+            await mutatePatchRowsInManifest(patchesDir, [filename], () => ({ set: updates, unset }));
         }
         catch (error) {
             if (patchWritten) {
@@ -83,3 +84,12 @@ export async function updatePatchAndMetadata(options) {
         return bodyChanged;
     }, lockOptions);
 }
+/** A copy of `row` without `fields`. */
+export function withoutFields(row, fields) {
+    if (fields.length === 0)
+        return row;
+    const copy = { ...row };
+    for (const field of fields)
+        Reflect.deleteProperty(copy, field);
+    return copy;
+}

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

@@ -18,9 +18,10 @@ export declare function buildPlanExportInput(input: PlanExportInput): PlanExport
 /**
  * Gets the next patch number for a new patch.
  * @param patchesDir - Path to the patches directory
+ * @param reserved - Orders held by `patch reserve`, skipped
  * @returns Next patch number (e.g., "005" for 4 existing patches)
  */
-export declare function getNextPatchNumber(patchesDir: string): Promise<string>;
+export declare function getNextPatchNumber(patchesDir: string, reserved?: ReadonlySet<number>): Promise<string>;
 /**
  * Sanitizes a human-readable name into a filename slug.
  *
@@ -59,7 +60,7 @@ export declare function patchNameSlug(name: string, category: string): string;
  * @param name - Human-readable name
  * @returns Filename like "001-ui-sidebar.patch"
  */
-export declare function getNextPatchFilename(patchesDir: string, category: PatchCategory, name: string): Promise<string>;
+export declare function getNextPatchFilename(patchesDir: string, category: PatchCategory, name: string, reserved?: ReadonlySet<number>): Promise<string>;
 export interface CommitExportedPatchInput {
     patchesDir: string;
     category: PatchCategory;