@hominis/fireforge 0.30.1 → 0.32.0

package/dist/src/commands/patch/patch-context.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Shared preamble for the patch subcommands: every mutation command starts
+ * by loading the project paths and the patches manifest and (for the
+ * single-patch commands) resolving the operator-supplied identifier. The
+ * sequence and its error wording were previously copied into each command;
+ * this module is the single source for both.
+ */
+import type { PatchesManifest, PatchMetadata } from '../../types/commands/index.js';
+import type { ProjectPaths } from '../../types/config.js';
+/** Resolved project paths plus the non-empty patches manifest. */
+export interface PatchQueueContext {
+    /** Project paths resolved from the project root. */
+    paths: ProjectPaths;
+    /** The loaded manifest; guaranteed to contain at least one patch. */
+    manifest: PatchesManifest;
+}
+/**
+ * Loads the project paths and the patches manifest, throwing the shared
+ * command-preamble errors when the patches directory is missing or the
+ * manifest has no patches.
+ *
+ * @param projectRoot - Root directory of the project
+ * @param options - Optional overrides for the preamble error wording
+ * @param options.missingDirMessage - Replacement for the default
+ *   "Patches directory not found." error (e.g. `patch delete` appends
+ *   "No patches to delete.")
+ * @returns The resolved paths and the non-empty manifest
+ */
+export declare function requirePatchQueue(projectRoot: string, options?: {
+    missingDirMessage?: string;
+}): Promise<PatchQueueContext>;
+/**
+ * Resolves an operator-supplied patch identifier (order number, filename,
+ * or unique name fragment) against the manifest, throwing the shared
+ * not-found error with suggestions when no patch matches.
+ *
+ * @param identifier - Identifier as passed on the command line
+ * @param patches - Manifest rows to resolve against
+ * @returns The matching manifest row
+ */
+export declare function requirePatchTarget(identifier: string, patches: PatchMetadata[]): PatchMetadata;

package/dist/src/commands/patch/patch-context.js

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Shared preamble for the patch subcommands: every mutation command starts
+ * by loading the project paths and the patches manifest and (for the
+ * single-patch commands) resolving the operator-supplied identifier. The
+ * sequence and its error wording were previously copied into each command;
+ * this module is the single source for both.
+ */
+import { getProjectPaths } from '../../core/config.js';
+import { formatPatchNotFoundError } from '../../core/patch-identifier-suggest.js';
+import { loadPatchesManifest, resolvePatchIdentifier } from '../../core/patch-manifest.js';
+import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
+import { pathExists } from '../../utils/fs.js';
+/**
+ * Loads the project paths and the patches manifest, throwing the shared
+ * command-preamble errors when the patches directory is missing or the
+ * manifest has no patches.
+ *
+ * @param projectRoot - Root directory of the project
+ * @param options - Optional overrides for the preamble error wording
+ * @param options.missingDirMessage - Replacement for the default
+ *   "Patches directory not found." error (e.g. `patch delete` appends
+ *   "No patches to delete.")
+ * @returns The resolved paths and the non-empty manifest
+ */
+export async function requirePatchQueue(projectRoot, options = {}) {
+    const paths = getProjectPaths(projectRoot);
+    if (!(await pathExists(paths.patches))) {
+        throw new GeneralError(options.missingDirMessage ?? 'Patches directory not found.');
+    }
+    const manifest = await loadPatchesManifest(paths.patches);
+    if (!manifest || manifest.patches.length === 0) {
+        throw new GeneralError('No patches in manifest.');
+    }
+    return { paths, manifest };
+}
+/**
+ * Resolves an operator-supplied patch identifier (order number, filename,
+ * or unique name fragment) against the manifest, throwing the shared
+ * not-found error with suggestions when no patch matches.
+ *
+ * @param identifier - Identifier as passed on the command line
+ * @param patches - Manifest rows to resolve against
+ * @returns The matching manifest row
+ */
+export function requirePatchTarget(identifier, patches) {
+    const target = resolvePatchIdentifier(identifier, patches);
+    if (!target) {
+        throw new InvalidArgumentError(formatPatchNotFoundError(identifier, patches), identifier);
+    }
+    return target;
+}
+//# sourceMappingURL=patch-context.js.map

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

@@ -18,18 +18,18 @@
  */
 import { rename as fsRename } from 'node:fs/promises';
 import { join } from 'node:path';
-import { getProjectPaths, loadConfig } from '../../core/config.js';
+import { loadConfig } from '../../core/config.js';
 import { appendHistory, confirmDestructive } from '../../core/destructive.js';
 import { sanitizeName } from '../../core/patch-export.js';
-import { formatPatchNotFoundError } from '../../core/patch-identifier-suggest.js';
 import { withPatchDirectoryLock } from '../../core/patch-lock.js';
-import { loadPatchesManifest, resolvePatchIdentifier, savePatchesManifest, } from '../../core/patch-manifest.js';
+import { loadPatchesManifest, rewriteStagedDependencyOwners, savePatchesManifest, } from '../../core/patch-manifest.js';
 import { buildProjectedManifest, enforcePatchPolicy } from '../../core/patch-policy.js';
 import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
 import { toError } from '../../utils/errors.js';
 import { pathExists } from '../../utils/fs.js';
 import { info, intro, outro, warn } from '../../utils/logger.js';
 import { pickDefined } from '../../utils/options.js';
+import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
 /**
  * Pulls the ordinal-string + category prefix out of a patch filename so
  * the rename keeps the existing ordinal padding verbatim. Returning the
@@ -85,6 +85,11 @@ async function commitRenameUnderLock(input) {
                 name: newName,
                 ...(descriptionChanging ? { description: newDescription ?? '' } : {}),
             };
+            // Staged-dependency owners on other patches reference the old
+            // filename; remap them so forward-import declarations survive the
+            // rename instead of dangling.
+            const ownerLookup = (old) => old === target.filename ? newFilename : undefined;
+            fresh.patches = fresh.patches.map((p) => rewriteStagedDependencyOwners(p, ownerLookup));
         }
         else {
             fresh.patches[idx] = {
@@ -151,19 +156,9 @@ export async function patchRenameCommand(projectRoot, identifier, options = {})
     if (options.to === undefined || options.to.trim() === '') {
         throw new InvalidArgumentError('Specify --to <new-name>. The new name is sanitised into the filename slug the same way `export --name` is.', 'patch rename');
     }
-    const paths = getProjectPaths(projectRoot);
     const config = await loadConfig(projectRoot);
-    if (!(await pathExists(paths.patches))) {
-        throw new GeneralError('Patches directory not found.');
-    }
-    const manifest = await loadPatchesManifest(paths.patches);
-    if (!manifest || manifest.patches.length === 0) {
-        throw new GeneralError('No patches in manifest.');
-    }
-    const target = resolvePatchIdentifier(identifier, manifest.patches);
-    if (!target) {
-        throw new InvalidArgumentError(formatPatchNotFoundError(identifier, manifest.patches), identifier);
-    }
+    const { paths, manifest } = await requirePatchQueue(projectRoot);
+    const target = requirePatchTarget(identifier, manifest.patches);
     const split = splitPatchFilename(target.filename);
     if (!split) {
         throw new GeneralError(`Cannot rename ${target.filename}: filename does not match the expected {ordinal}-{category}-{slug}.patch convention. Re-export the patch instead.`);

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

@@ -10,8 +10,6 @@
 import { Command } from 'commander';
 import type { CommandContext } from '../../types/cli.js';
 import type { PatchMetadata, PatchReorderOptions } from '../../types/commands/index.js';
-/** Zero-pads an ordinal number to the given width. */
-export declare function padOrder(value: number, width: number): string;
 /** Builds a new patch filename by replacing the numeric prefix with `newOrder`. */
 export declare function rebuildFilenameForOrder(existing: PatchMetadata, newOrder: number): string;
 /**

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

@@ -9,21 +9,20 @@
  * before any bytes move.
  */
 import { Option } from 'commander';
-import { getProjectPaths, loadConfig } from '../../core/config.js';
+import { loadConfig } from '../../core/config.js';
 import { appendHistory, confirmDestructive, } from '../../core/destructive.js';
-import { formatPatchNotFoundError } from '../../core/patch-identifier-suggest.js';
 import { buildPatchQueueContext, lintPatchQueue, } from '../../core/patch-lint.js';
 import { withPatchDirectoryLock } from '../../core/patch-lock.js';
-import { loadPatchesManifest, renumberPatchesInManifest, resolvePatchIdentifier, } from '../../core/patch-manifest.js';
+import { loadPatchesManifest, renumberPatchesInManifest, resolvePatchIdentifier, rewriteStagedDependencyOwners, } from '../../core/patch-manifest.js';
 import { applyRenameMapToManifest, enforcePatchPolicy } from '../../core/patch-policy.js';
 import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
 import { toError } from '../../utils/errors.js';
-import { pathExists } from '../../utils/fs.js';
 import { info, intro, outro, warn } from '../../utils/logger.js';
 import { pickDefined } from '../../utils/options.js';
 import { parsePositiveIntegerFlag } from '../../utils/validation.js';
+import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
 /** Zero-pads an ordinal number to the given width. */
-export function padOrder(value, width) {
+function padOrder(value, width) {
     return String(value).padStart(width, '0');
 }
 /** Builds a new patch filename by replacing the numeric prefix with `newOrder`. */
@@ -123,12 +122,22 @@ function renameMapsEqual(left, right) {
  * can run against the projected state without touching disk.
  */
 function projectReorder(base, renameMap) {
+    const ownerLookup = (oldFilename) => renameMap.get(oldFilename)?.newFilename;
     const projectedEntries = base.entries.map((entry) => {
+        // Project staged-dependency owner references through the rename map on
+        // every entry — owners point at *other* patches' filenames, so a
+        // projection that skips non-renamed entries would lint against stale
+        // owners and report false forward-import regressions.
+        const metadata = entry.metadata
+            ? rewriteStagedDependencyOwners(entry.metadata, ownerLookup)
+            : entry.metadata;
         const rename = renameMap.get(entry.filename);
-        if (!rename)
-            return entry;
+        if (!rename) {
+            return metadata === entry.metadata ? entry : { ...entry, metadata };
+        }
         return {
             ...entry,
+            metadata,
             filename: rename.newFilename,
             order: rename.newOrder,
         };
@@ -268,19 +277,9 @@ export async function patchReorderCommand(projectRoot, identifier, options = {})
     if (specifiedTargets > 1) {
         throw new InvalidArgumentError('--to, --before, and --after are mutually exclusive.', 'patch reorder');
     }
-    const paths = getProjectPaths(projectRoot);
     const config = await loadConfig(projectRoot);
-    if (!(await pathExists(paths.patches))) {
-        throw new GeneralError('Patches directory not found.');
-    }
-    const manifest = await loadPatchesManifest(paths.patches);
-    if (!manifest || manifest.patches.length === 0) {
-        throw new GeneralError('No patches in manifest.');
-    }
-    const target = resolvePatchIdentifier(identifier, manifest.patches);
-    if (!target) {
-        throw new InvalidArgumentError(formatPatchNotFoundError(identifier, manifest.patches), identifier);
-    }
+    const { paths, manifest } = await requirePatchQueue(projectRoot);
+    const target = requirePatchTarget(identifier, manifest.patches);
     const { destinationOrder, anchorFilename } = resolveDestination(target, manifest.patches, options);
     const renameMap = computeRenameMap(manifest.patches, target, destinationOrder);
     if (renameMap.size === 0) {

package/dist/src/commands/patch/split-plan.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Planning helpers for `fireforge patch split`: ownership guards, diff
+ * construction from the worktree, staged-dependency owner-rewrite
+ * discovery, cross-patch lint projection, and policy-manifest projection.
+ * Split out of `split.ts` to keep both files within the per-file line
+ * budget; consumed only by the split command.
+ */
+import { type ConflictReport } from '../../core/destructive.js';
+import { buildProjectedManifest } from '../../core/patch-policy.js';
+import type { PatchCategory, PatchMetadata } from '../../types/commands/index.js';
+import type { FireForgeConfig } from '../../types/config.js';
+import { type PlacementPlan } from '../export-flow.js';
+/** Everything the commit step needs, computed and confirmed up front. */
+export interface SplitPlan {
+    source: PatchMetadata;
+    movedFiles: string[];
+    remainingFiles: string[];
+    movedDiff: string;
+    remainingDiff: string;
+    placement: PlacementPlan;
+    /** Effective placement flags (with the after-source default applied). */
+    placementOptions: {
+        order?: number;
+        before?: string;
+        after?: string;
+    };
+    category: PatchCategory;
+    name: string;
+    description: string;
+    /** Patches (by current filename) whose staged-dependency owners re-point to the new patch. */
+    ownerRewrites: string[];
+}
+/**
+ *
+ */
+export declare function assertSourceOwnsFiles(source: PatchMetadata, files: readonly string[]): void;
+/**
+ *
+ */
+export declare function buildSplitDiff(engineDir: string, files: readonly string[], label: string, sourceFilename: string): Promise<string>;
+/**
+ * Finds patches declaring a staged-dependency forward-import whose `owner`
+ * is the source patch and whose `creates` path moves to the new patch.
+ */
+export declare function findOwnerRewriteHolders(patches: readonly PatchMetadata[], sourceFilename: string, movedSet: ReadonlySet<string>): string[];
+/** Rewrites split-affected owners on one manifest row. */
+export declare function rewriteSplitOwners(patch: PatchMetadata, sourceFilename: string, movedSet: ReadonlySet<string>, newFilename: string): PatchMetadata;
+/**
+ * Projects the full split (renumber + shrunken source + synthetic new
+ * patch + owner rewrites) through cross-patch lint, reporting only the
+ * regressions the split itself would introduce.
+ */
+export declare function runProjectedSplitLint(patchesDir: string, plan: SplitPlan): Promise<ConflictReport | null>;
+/** Builds the projected manifest for policy enforcement. */
+export declare function projectSplitManifest(manifest: {
+    version: 1;
+    patches: PatchMetadata[];
+}, plan: SplitPlan, newMetadata: PatchMetadata): ReturnType<typeof buildProjectedManifest>;
+/**
+ *
+ */
+export declare function buildNewPatchMetadata(plan: SplitPlan, config: FireForgeConfig): PatchMetadata;
+/**
+ *
+ */
+export declare function buildSplitSummary(plan: SplitPlan): string[];

package/dist/src/commands/patch/split-plan.js

@@ -0,0 +1,178 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Planning helpers for `fireforge patch split`: ownership guards, diff
+ * construction from the worktree, staged-dependency owner-rewrite
+ * discovery, cross-patch lint projection, and policy-manifest projection.
+ * Split out of `split.ts` to keep both files within the per-file line
+ * budget; consumed only by the split command.
+ */
+import { join } from 'node:path';
+import { getDiffForFilesAgainstHead } from '../../core/git-diff.js';
+import { computeProjectedLintRegressions } from '../../core/lint-projection.js';
+import { extractAffectedFiles } from '../../core/patch-apply.js';
+import { buildModifiedFileAdditionsFromDiff, buildPatchQueueContext, detectNewFilesInDiff, lintPatchQueue, } from '../../core/patch-lint.js';
+import { rewriteStagedDependencyOwners } from '../../core/patch-manifest.js';
+import { applyRenameMapToManifest, buildProjectedManifest } from '../../core/patch-policy.js';
+import { buildPatchSourceMetadata } from '../../core/patch-source-metadata.js';
+import { extractNewFileContentFromDiff } from '../../core/patch-transform.js';
+import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
+import { pathExists } from '../../utils/fs.js';
+import { warn } from '../../utils/logger.js';
+/**
+ *
+ */
+export function assertSourceOwnsFiles(source, files) {
+    const owned = new Set(source.filesAffected);
+    const missing = files.filter((file) => !owned.has(file));
+    if (missing.length > 0) {
+        throw new InvalidArgumentError(`${source.filename} does not currently own ${missing.length} requested file(s): ${missing.join(', ')}. ` +
+            'Run "fireforge status --ownership" to inspect current ownership.', '--files');
+    }
+}
+/**
+ *
+ */
+export async function buildSplitDiff(engineDir, files, label, sourceFilename) {
+    for (const file of files) {
+        if (!(await pathExists(join(engineDir, file)))) {
+            throw new GeneralError(`Cannot split ${sourceFilename}: ${label} file is missing from the engine worktree: ${file}. ` +
+                'Run "fireforge import" (or restore the file) so the worktree reflects the patch content first.');
+        }
+    }
+    const diff = await getDiffForFilesAgainstHead(engineDir, [...files]);
+    if (!diff.trim()) {
+        throw new GeneralError(`Cannot split ${sourceFilename}: the ${label} file set produces an empty diff against HEAD. ` +
+            'The worktree must currently carry the patch content (run "fireforge import" first).');
+    }
+    const actual = new Set(extractAffectedFiles(diff));
+    const noHunks = files.filter((file) => !actual.has(file));
+    if (noHunks.length > 0) {
+        throw new GeneralError(`Cannot split ${sourceFilename}: ${noHunks.length} ${label} file(s) produced no diff hunks ` +
+            `(${noHunks.join(', ')}). The worktree does not carry their patch content.`);
+    }
+    return diff;
+}
+/**
+ * Finds patches declaring a staged-dependency forward-import whose `owner`
+ * is the source patch and whose `creates` path moves to the new patch.
+ */
+export function findOwnerRewriteHolders(patches, sourceFilename, movedSet) {
+    return patches
+        .filter((patch) => (patch.stagedDependencies?.forwardImports ?? []).some((fi) => fi.owner === sourceFilename && movedSet.has(fi.creates)))
+        .map((patch) => patch.filename);
+}
+/** Rewrites split-affected owners on one manifest row. */
+export function rewriteSplitOwners(patch, sourceFilename, movedSet, newFilename) {
+    const forwardImports = patch.stagedDependencies?.forwardImports;
+    if (!forwardImports?.some((fi) => fi.owner === sourceFilename && movedSet.has(fi.creates))) {
+        return patch;
+    }
+    return {
+        ...patch,
+        stagedDependencies: {
+            ...patch.stagedDependencies,
+            forwardImports: forwardImports.map((fi) => fi.owner === sourceFilename && movedSet.has(fi.creates) ? { ...fi, owner: newFilename } : fi),
+        },
+    };
+}
+function buildEntryProjection(diff) {
+    const newFiles = new Map();
+    for (const path of detectNewFilesInDiff(diff)) {
+        newFiles.set(path, extractNewFileContentFromDiff(diff, path));
+    }
+    return { diff, newFiles, modifiedFileAdditions: buildModifiedFileAdditionsFromDiff(diff) };
+}
+/**
+ * Projects the full split (renumber + shrunken source + synthetic new
+ * patch + owner rewrites) through cross-patch lint, reporting only the
+ * regressions the split itself would introduce.
+ */
+export async function runProjectedSplitLint(patchesDir, plan) {
+    const movedSet = new Set(plan.movedFiles);
+    const ownerLookup = (old) => plan.placement.renameMap.get(old)?.newFilename;
+    const baseCtx = await buildPatchQueueContext(patchesDir);
+    const projectedEntries = baseCtx.entries.map((entry) => {
+        let metadata = entry.metadata;
+        if (metadata) {
+            metadata = rewriteStagedDependencyOwners(metadata, ownerLookup);
+            metadata = rewriteSplitOwners(metadata, plan.source.filename, movedSet, plan.placement.newFilename);
+        }
+        const rename = plan.placement.renameMap.get(entry.filename);
+        const base = rename
+            ? { ...entry, metadata, filename: rename.newFilename, order: rename.newOrder }
+            : { ...entry, metadata };
+        if (entry.filename !== plan.source.filename)
+            return base;
+        return { ...base, ...buildEntryProjection(plan.remainingDiff) };
+    });
+    projectedEntries.push({
+        filename: plan.placement.newFilename,
+        order: plan.placement.insertionOrder,
+        metadata: null,
+        ...buildEntryProjection(plan.movedDiff),
+    });
+    projectedEntries.sort((a, b) => a.order - b.order || a.filename.localeCompare(b.filename));
+    const baselineIssues = lintPatchQueue(baseCtx).filter((i) => i.severity === 'error');
+    const projectedIssues = lintPatchQueue({ entries: projectedEntries }).filter((i) => i.severity === 'error');
+    const regressions = computeProjectedLintRegressions(baselineIssues, projectedIssues);
+    if (baselineIssues.length > 0 && regressions.length === 0) {
+        warn(`Note: projected queue still has ${baselineIssues.length} pre-existing cross-patch ` +
+            'error(s) unrelated to this split. Run "fireforge verify" to list them.');
+    }
+    if (regressions.length === 0)
+        return null;
+    return {
+        reason: `split would introduce ${regressions.length} cross-patch lint error(s)`,
+        details: regressions.map((i) => `[${i.check}] ${i.file}: ${i.message}`),
+    };
+}
+/** Builds the projected manifest for policy enforcement. */
+export function projectSplitManifest(manifest, plan, newMetadata) {
+    const movedSet = new Set(plan.movedFiles);
+    const renamed = applyRenameMapToManifest(manifest, plan.placement.renameMap);
+    const effectiveSourceFilename = plan.placement.renameMap.get(plan.source.filename)?.newFilename ?? plan.source.filename;
+    const patched = renamed.patches.map((patch) => {
+        const withOwners = rewriteSplitOwners(patch, effectiveSourceFilename, movedSet, plan.placement.newFilename);
+        if (patch.filename !== effectiveSourceFilename)
+            return withOwners;
+        return { ...withOwners, filesAffected: plan.remainingFiles };
+    });
+    return buildProjectedManifest(renamed, [...patched, newMetadata]);
+}
+/**
+ *
+ */
+export function buildNewPatchMetadata(plan, config) {
+    return {
+        filename: plan.placement.newFilename,
+        order: plan.placement.insertionOrder,
+        category: plan.category,
+        name: plan.name,
+        description: plan.description,
+        createdAt: new Date().toISOString(),
+        ...buildPatchSourceMetadata(config.firefox),
+        filesAffected: plan.movedFiles,
+    };
+}
+/**
+ *
+ */
+export function buildSplitSummary(plan) {
+    const summary = [
+        `split ${plan.source.filename}`,
+        `moved files (${plan.movedFiles.length}): ${plan.movedFiles.join(', ')}`,
+        `source keeps (${plan.remainingFiles.length}): ${plan.remainingFiles.join(', ')}`,
+        `new patch: ${plan.placement.newFilename} (order ${plan.placement.insertionOrder})`,
+    ];
+    if (plan.placement.renameMap.size > 0) {
+        summary.push(`${plan.placement.renameMap.size} existing patch(es) renumbered to make room:`);
+        for (const [oldName, entry] of [...plan.placement.renameMap.entries()].sort((a, b) => a[1].newOrder - b[1].newOrder)) {
+            summary.push(`  ${oldName}  →  ${entry.newFilename}`);
+        }
+    }
+    if (plan.ownerRewrites.length > 0) {
+        summary.push(`staged-dependency owners re-pointed to the new patch in: ${plan.ownerRewrites.join(', ')}`);
+    }
+    return summary;
+}
+//# sourceMappingURL=split-plan.js.map

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

@@ -0,0 +1,30 @@
+/**
+ * `fireforge patch split <source> --files <p...> --name <n>` — moves files
+ * out of an existing patch into a brand-new patch as one transaction
+ * (field report A4).
+ *
+ * Before this command, splitting a patch whose files have inbound
+ * forward-imports required a precise manual order: re-point each
+ * staged-dependency owner at a not-yet-created patch, shrink the source
+ * via `re-export --files --allow-shrink`, then `export --order` — any
+ * other order refused or needed `--force-unsafe`. Split performs the
+ * shrink, the new-patch creation, and the dependent owner rewrites under
+ * one patch-directory lock with rollback, validating only the final
+ * projection.
+ *
+ * Preconditions match `re-export`: the engine worktree must currently
+ * reflect both patches' content, because both bodies are regenerated from
+ * the worktree.
+ */
+import { Command } from 'commander';
+import type { CommandContext } from '../../types/cli.js';
+import type { PatchSplitOptions } from '../../types/commands/index.js';
+/**
+ * Runs the `patch split` command: plans the split, lints the projection,
+ * confirms, and commits transactionally.
+ */
+export declare function patchSplitCommand(projectRoot: string, sourceId: string, options: PatchSplitOptions): Promise<void>;
+/**
+ * Registers the `patch split` subcommand on the `patch` parent.
+ */
+export declare function registerPatchSplit(parent: Command, context: CommandContext): void;