@pugi/cli 0.1.0-alpha.9 → 0.1.0-beta.2

package/dist/core/context/watcher.js

@@ -0,0 +1,342 @@
+/**
+ * chokidar-based filewatch - α6.5 Phase 1 (three-tier context).
+ *
+ * The REPL needs a live signal when files change so the operator's
+ * agent can re-read a stale file, and so the status bar can surface a
+ * "file changed" badge. chokidar wraps fsevents / inotify / kqueue so
+ * the cross-platform surface stays sane.
+ *
+ * Design choices:
+ *
+ *   1. **Ignore-aware**: every watched path is filtered through the
+ *      same `PugiIgnore` matcher the skeleton walker uses. We pass the
+ *      matcher into chokidar's `ignored` option so `node_modules/`,
+ *      `dist/`, `.git/`, and secret files are never watched at all -
+ *      this matters because chokidar's resource bound is the number
+ *      of watched paths, not the number of total files in the repo.
+ *
+ *   2. **Throttle**: chokidar can fire dozens of `change` events when
+ *      a code formatter rewrites a directory. We batch events in a
+ *      `THROTTLE_WINDOW_MS` window and emit a single aggregated event
+ *      so the REPL system line / status bar do not flicker.
+ *
+ *   3. **Watch cap**: per spec, the watcher caps watched paths at
+ *      `MAX_WATCHED_PATHS`. Once the count crosses the cap we close
+ *      the watcher and fall back to "no live updates this session" -
+ *      better to silently lose the badge than to consume thousands of
+ *      file descriptors. The fallback path emits one warning event so
+ *      the operator knows live updates are off.
+ *
+ *   4. **Lifecycle**: `start()` is async (chokidar's `ready` event)
+ *      so the caller can `await` the initial scan. `close()` is also
+ *      async (chokidar's close is async). The watcher is reusable
+ *      across multiple `start` / `close` pairs, but Phase 1 expects
+ *      one-watcher-per-REPL-session.
+ *
+ *   5. **Testability**: the chokidar handle is injectable via the
+ *      `watchFactory` option. Production wires `chokidar.watch`;
+ *      tests pass a fake emitter that lets the spec drive `add` /
+ *      `change` / `unlink` events synchronously.
+ */
+import { EventEmitter } from 'node:events';
+import chokidar from 'chokidar';
+/** Per-spec watch-path cap. */
+export const MAX_WATCHED_PATHS = 10_000;
+/** Batching window for the change throttle. */
+export const THROTTLE_WINDOW_MS = 250;
+/**
+ * Number of `add` events between cap-check re-evaluations. The ready
+ * handler triggers the FIRST cap check, but a `git checkout` of a
+ * giant subtree post-ready can blow past the cap without ever
+ * re-evaluating. Sample every N adds so the cap fires within a
+ * bounded window even on post-ready growth. Cheap: one Map
+ * iteration per N adds. triple-review P2 (PR #380).
+ */
+export const CAP_CHECK_ADD_INTERVAL = 1_000;
+/**
+ * Concrete watcher. Construct, then `await start()`. Subscribe via
+ * `.on('batch', cb)`. `await close()` to tear down.
+ */
+export class PugiWatcher extends EventEmitter {
+    cwd;
+    ignore;
+    maxWatchedPaths;
+    throttleWindowMs;
+    now;
+    watchFactory;
+    setTimeoutImpl;
+    clearTimeoutImpl;
+    handle = null;
+    buffer = [];
+    windowStart = null;
+    timer = null;
+    closed = false;
+    capExceededEmitted = false;
+    capCheckTimer = null;
+    /**
+     * Counter of `add` events received since the last cap-check sample.
+     * When it crosses CAP_CHECK_ADD_INTERVAL we schedule another check.
+     * Resets on every cap-check run. triple-review P2 (PR #380).
+     */
+    addsSinceLastCapCheck = 0;
+    constructor(options) {
+        super();
+        this.cwd = options.cwd;
+        this.ignore = options.ignore;
+        this.maxWatchedPaths = options.maxWatchedPaths ?? MAX_WATCHED_PATHS;
+        this.throttleWindowMs = options.throttleWindowMs ?? THROTTLE_WINDOW_MS;
+        this.now = options.now ?? (() => Date.now());
+        this.watchFactory = options.watchFactory ?? defaultWatchFactory;
+        this.setTimeoutImpl = options.setTimeoutImpl ?? ((fn, ms) => setTimeout(fn, ms));
+        this.clearTimeoutImpl = options.clearTimeoutImpl ?? ((h) => clearTimeout(h));
+        // Default no-op error listener - Node's EventEmitter.emit('error', ...)
+        // THROWS synchronously when no listener is registered. Production
+        // bootstrap awaits start() before constructing ReplSession, so there
+        // is no listener on the watcher at the moment chokidar may surface
+        // an error during the initial scan. The default listener swallows
+        // the event so emit() does not crash the CLI; any real consumer
+        // that subscribes later receives the events as normal because
+        // EventEmitter delivers to every registered listener, not just one.
+        // Codex P1 (PR #380).
+        this.on('error', () => {
+            /* defensive no-op so emit('error') never throws */
+        });
+    }
+    /**
+     * Open the chokidar handle and wait for the `ready` event. Resolves
+     * once the initial scan completes. Rejects when the underlying
+     * watcher errors out before `ready`.
+     */
+    async start() {
+        if (this.handle)
+            return;
+        if (this.closed) {
+            throw new Error('PugiWatcher: cannot start a closed watcher');
+        }
+        const opts = {
+            // chokidar does not tell the predicate whether the path is a
+            // file or a directory, so we ask the matcher both ways. If
+            // either form matches, the path is excluded. This catches
+            // gitignore-style dir patterns (`node_modules/`) that would
+            // otherwise only match descendants, leaving the dir itself
+            // visible to chokidar's recursion.
+            ignored: (path) => this.ignore.isIgnored(path) || this.ignore.isIgnored(path, true),
+            ignoreInitial: true,
+            persistent: true,
+            // Disable polling - we want fsevents / inotify / kqueue speed.
+            usePolling: false,
+            // Aggregate events so we get one `change` per save, not three.
+            awaitWriteFinish: {
+                stabilityThreshold: 50,
+                pollInterval: 25,
+            },
+            // Keep the depth shallow at the chokidar layer too - even after
+            // ignore filtering, a multi-million file dir could exhaust file
+            // descriptors. The skeleton walker has its own depth cap; this
+            // one is a safety net.
+            depth: 12,
+        };
+        const watcher = this.watchFactory(this.cwd, opts);
+        this.handle = watcher;
+        return new Promise((resolveReady, rejectReady) => {
+            let settled = false;
+            watcher.on('ready', () => {
+                if (settled)
+                    return;
+                settled = true;
+                this.emit('ready');
+                this.scheduleCapCheck();
+                resolveReady();
+            });
+            watcher.on('error', (err) => {
+                const error = err instanceof Error ? err : new Error(String(err));
+                this.emit('error', error);
+                if (!settled) {
+                    settled = true;
+                    rejectReady(error);
+                }
+            });
+            watcher.on('add', (path) => {
+                this.queue('add', path);
+                // Re-evaluate the cap every CAP_CHECK_ADD_INTERVAL adds so a
+                // post-ready burst (e.g. `git checkout` of a giant subtree)
+                // does not silently blow past the watched-paths cap. The
+                // ready-time check is preserved; this is the missing follow-up
+                // sampler the comment promised. triple-review P2 (PR #380).
+                this.addsSinceLastCapCheck += 1;
+                if (this.addsSinceLastCapCheck >= CAP_CHECK_ADD_INTERVAL) {
+                    this.addsSinceLastCapCheck = 0;
+                    this.scheduleCapCheck();
+                }
+            });
+            watcher.on('change', (path) => this.queue('change', path));
+            watcher.on('unlink', (path) => this.queue('unlink', path));
+        });
+    }
+    /** Close the underlying watcher and clear the throttle timer. */
+    async close() {
+        this.closed = true;
+        if (this.timer !== null) {
+            this.clearTimeoutImpl(this.timer);
+            this.timer = null;
+        }
+        if (this.capCheckTimer !== null) {
+            this.clearTimeoutImpl(this.capCheckTimer);
+            this.capCheckTimer = null;
+        }
+        if (this.handle) {
+            try {
+                await this.handle.close();
+            }
+            catch {
+                /* idempotent - chokidar may already be closed */
+            }
+            this.handle = null;
+        }
+        this.buffer = [];
+        this.windowStart = null;
+    }
+    /**
+     * Force-flush any pending events. Exposed primarily for tests that
+     * want to assert the batched payload without waiting for the
+     * timeout. Production code can also use this on REPL teardown so
+     * pending events are surfaced before close.
+     */
+    flush() {
+        if (this.buffer.length === 0)
+            return;
+        if (this.timer !== null) {
+            this.clearTimeoutImpl(this.timer);
+            this.timer = null;
+        }
+        const events = this.buffer;
+        this.buffer = [];
+        const start = this.windowStart ?? this.now();
+        const end = this.now();
+        this.windowStart = null;
+        this.emit('batch', {
+            events: dedupeBatch(events),
+            windowStartEpochMs: start,
+            windowEndEpochMs: end,
+        });
+    }
+    /** Test surface - returns the current pending buffer. */
+    pendingCount() {
+        return this.buffer.length;
+    }
+    /* ------------------------------------------------------------ */
+    /* Internals                                                    */
+    /* ------------------------------------------------------------ */
+    queue(kind, path) {
+        if (this.closed)
+            return;
+        // Defensive double-check: even if chokidar's `ignored` predicate
+        // accepted the path, the matcher gets the last word. Same dir-aware
+        // double-call as the predicate above.
+        if (this.ignore.isIgnored(path) || this.ignore.isIgnored(path, true))
+            return;
+        const atEpochMs = this.now();
+        const event = {
+            path: relPathPosix(this.cwd, path),
+            absPath: path,
+            kind,
+            atEpochMs,
+        };
+        if (this.windowStart === null)
+            this.windowStart = atEpochMs;
+        this.buffer.push(event);
+        if (this.timer === null) {
+            this.timer = this.setTimeoutImpl(() => this.flush(), this.throttleWindowMs);
+        }
+    }
+    /**
+     * Lazy cap check - chokidar reports its watched paths via
+     * `getWatched()`. We sample once on ready, and again every
+     * CAP_CHECK_ADD_INTERVAL `add` events thereafter (e.g. a `git
+     * checkout` of a giant subtree post-ready). The cost is one Map
+     * iteration; the payoff is silent fallback when an operator targets
+     * a giant repo. Guarded against double-scheduling so the add-handler
+     * cannot stack multiple timers.
+     */
+    scheduleCapCheck() {
+        if (this.closed || this.capExceededEmitted)
+            return;
+        if (this.capCheckTimer !== null)
+            return;
+        this.capCheckTimer = this.setTimeoutImpl(() => this.runCapCheck(), 100);
+    }
+    runCapCheck() {
+        this.capCheckTimer = null;
+        if (this.closed || this.capExceededEmitted || !this.handle)
+            return;
+        try {
+            const watched = this.handle.getWatched();
+            let count = 0;
+            for (const entries of Object.values(watched)) {
+                count += entries.length;
+            }
+            if (count > this.maxWatchedPaths) {
+                this.capExceededEmitted = true;
+                this.emit('capExceeded', {
+                    watchedCount: count,
+                    cap: this.maxWatchedPaths,
+                });
+                // Stop watching so we do not consume more file descriptors.
+                void this.close();
+            }
+        }
+        catch {
+            /* chokidar threw on getWatched - safe to ignore, cap check is best-effort */
+        }
+    }
+}
+/* ------------------------------------------------------------------ */
+/* Helpers                                                            */
+/* ------------------------------------------------------------------ */
+/**
+ * Convert an absolute path to a repo-relative POSIX path. chokidar
+ * already uses forward slashes on Windows because it normalises
+ * internally, but we run the same fix unconditionally so the contract
+ * is platform-agnostic.
+ */
+function relPathPosix(cwd, abs) {
+    // chokidar may report paths already relative to cwd. Normalise both
+    // sides to forward slashes for the prefix compare.
+    const cwdPosix = cwd.replace(/\\/g, '/');
+    const absPosix = abs.replace(/\\/g, '/');
+    if (absPosix.startsWith(`${cwdPosix}/`)) {
+        return absPosix.slice(cwdPosix.length + 1);
+    }
+    if (absPosix === cwdPosix)
+        return '';
+    return absPosix;
+}
+/**
+ * Collapse consecutive (path, kind) duplicates inside a batch. We
+ * keep the FIRST occurrence so the order is "first-touch first".
+ * Different kinds for the same path are preserved (`add` then
+ * `change`) - the model wants both signals.
+ */
+function dedupeBatch(events) {
+    const seen = new Set();
+    const out = [];
+    for (const event of events) {
+        const key = `${event.kind}:${event.path}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(event);
+    }
+    return out;
+}
+/**
+ * Production chokidar factory. Returns the real `FSWatcher` cast to
+ * the minimal interface so the watcher class never directly imports
+ * chokidar types beyond `WatchOptions`. The cast is safe - chokidar's
+ * `FSWatcher` is a superset of `ChokidarLike`.
+ */
+function defaultWatchFactory(cwd, opts) {
+    const watcher = chokidar.watch(cwd, opts);
+    return watcher;
+}
+//# sourceMappingURL=watcher.js.map

package/dist/core/context/working-set.js

@@ -0,0 +1,165 @@
+/**
+ * Tier 1 working-set tracker - α6.5 Phase 1 (three-tier context).
+ *
+ * The model context window is finite. Tier 0 (repo skeleton, ~5KB) is
+ * always loaded; Tier 2 (RAG, Anvil-side, deferred to α6.5b) answers
+ * queries on demand. Tier 1 - the working set - lives between them: the
+ * subset of files the agent has touched THIS session, bounded so a
+ * long REPL session does not unbounded-grow the system prompt.
+ *
+ * Design choices:
+ *
+ *   1. **LRU semantics**: the most-recently-touched file stays in the
+ *      window; the oldest is evicted when the cap is hit. We use a
+ *      `Map` so insertion order doubles as recency order (delete +
+ *      re-set bubbles the entry to the tail).
+ *
+ *   2. **Source tracking**: every `track()` call records the source -
+ *      `read` (agent fetched the file), `edit` (agent modified it),
+ *      `write` (agent created it). The source seeds future heuristics
+ *      (e.g. always pin edited files near the cap, never evict files
+ *      written this session) but Phase 1 keeps the policy simple:
+ *      pure LRU.
+ *
+ *   3. **No persistence**: working set is in-memory only. A REPL
+ *      restart rebuilds from scratch (and from `/resume` SessionStore
+ *      replay if/when we wire that). Per α6.5 spec: "node:sqlite NOT
+ *      needed for this sprint."
+ *
+ *   4. **Path normalisation**: we resolve every path to an absolute
+ *      form on insert so two `track()` calls with `./foo.ts` and
+ *      `/abs/cwd/foo.ts` collapse to one entry.
+ *
+ *   5. **Defensive cap**: `MAX_WORKING_SET = 50` per spec. We hold the
+ *      cap as a configurable option so tests can dial it down to
+ *      exercise eviction without 51 fixture files.
+ */
+import { resolve } from 'node:path';
+/** Spec-mandated default cap. Mirrors the doc string in the α6.5 sprint plan. */
+export const DEFAULT_WORKING_SET_CAPACITY = 50;
+export class WorkingSet {
+    entries = new Map();
+    capacity;
+    now;
+    constructor(options = {}) {
+        this.capacity = options.capacity ?? DEFAULT_WORKING_SET_CAPACITY;
+        if (!Number.isInteger(this.capacity) || this.capacity <= 0) {
+            throw new Error(`WorkingSet capacity must be a positive integer, got ${options.capacity}`);
+        }
+        this.now = options.now ?? (() => Date.now());
+    }
+    /**
+     * Record that the agent touched `path`. The path is normalised to an
+     * absolute form so duplicate calls with different relative paths
+     * collapse. Returns the entry as stored.
+     *
+     * LRU bump: an existing entry is deleted and re-inserted so insertion
+     * order tracks recency. The oldest entry is evicted when the
+     * insertion would breach `capacity`.
+     */
+    track(path, source, sizeBytes = 0) {
+        const absPath = resolve(path);
+        const previous = this.entries.get(absPath);
+        const touchCount = previous ? previous.touchCount + 1 : 1;
+        // Prefer the new size when the caller supplies one; otherwise keep
+        // the previous reading so we do not "forget" the file's footprint
+        // just because the second track() call did not stat the file.
+        const nextSize = sizeBytes > 0
+            ? sizeBytes
+            : (previous?.sizeBytes ?? 0);
+        const entry = Object.freeze({
+            absPath,
+            source,
+            touchedAtEpochMs: this.now(),
+            touchCount,
+            sizeBytes: nextSize,
+        });
+        // Delete first so re-insert lands at the tail (most-recent).
+        if (previous)
+            this.entries.delete(absPath);
+        this.entries.set(absPath, entry);
+        this.evictExcess();
+        return entry;
+    }
+    /**
+     * Drop a single path from the set. Returns `true` when the entry
+     * existed. Used by the file watcher's `unlink` event - a removed
+     * file is no longer in the working set.
+     */
+    forget(path) {
+        const absPath = resolve(path);
+        return this.entries.delete(absPath);
+    }
+    /** Clear the entire set - used by `/clear` slash + REPL teardown. */
+    clear() {
+        this.entries.clear();
+    }
+    /** True when the path is currently retained. */
+    has(path) {
+        return this.entries.has(resolve(path));
+    }
+    /** Live count - O(1). */
+    size() {
+        return this.entries.size;
+    }
+    /** Configured cap - surfaced so `/context` can render `12/50`. */
+    capacityLimit() {
+        return this.capacity;
+    }
+    /**
+     * Snapshot of the set ordered MOST RECENT first. Suitable for
+     * direct injection into the agent's system prompt; the oldest
+     * entries are the least relevant and trail the list so the model's
+     * recency bias works in our favour.
+     */
+    forSerialization() {
+        // `Map` iterates in insertion order = LRU order with oldest first.
+        // We want recency-first so reverse.
+        const all = Array.from(this.entries.values());
+        all.reverse();
+        return all;
+    }
+    /** Aggregate summary used by `/context` slash + status bar. */
+    summary() {
+        let totalSize = 0;
+        let oldest = null;
+        for (const entry of this.entries.values()) {
+            totalSize += entry.sizeBytes;
+            if (oldest === null || entry.touchedAtEpochMs < oldest) {
+                oldest = entry.touchedAtEpochMs;
+            }
+        }
+        return {
+            count: this.entries.size,
+            capacity: this.capacity,
+            totalSizeBytes: totalSize,
+            oldestTouchedAtEpochMs: oldest,
+        };
+    }
+    /**
+     * Public LRU eviction trigger - called automatically on every
+     * `track()` but exposed so callers (tests, future memory-pressure
+     * hook) can force a sweep without inserting a sentinel entry.
+     * Returns the count of evicted entries.
+     */
+    evict() {
+        return this.evictExcess();
+    }
+    /**
+     * Walk the head of the insertion-ordered map (oldest first) and
+     * delete entries until size <= capacity. Returns the number of
+     * entries dropped.
+     */
+    evictExcess() {
+        let removed = 0;
+        while (this.entries.size > this.capacity) {
+            const oldestKey = this.entries.keys().next().value;
+            if (oldestKey === undefined)
+                break;
+            this.entries.delete(oldestKey);
+            removed += 1;
+        }
+        return removed;
+    }
+}
+//# sourceMappingURL=working-set.js.map

package/dist/core/edits/dispatch.js

@@ -0,0 +1,185 @@
+/**
+ * Diff dispatch — α6.6 escalation Phase 1.
+ *
+ * Reads a raw model response containing one or more SEARCH/REPLACE
+ * envelopes, normalises them through `marker-parser`, and routes each
+ * parsed edit to the correct applicator:
+ *
+ *   - `layer-a` → applyLayerA
+ *   - `layer-b` → applyLayerB
+ *   - `layer-c` → applyLayerC
+ *   - `layer-d` → throws LayerDDeferredError, surfaced as a clean
+ *                 dispatch failure (Layer D ships in α6.6b)
+ *
+ * Per-edit results are aggregated into `DispatchResult[]` so callers
+ * can render the full apply transcript even when some edits failed.
+ * Order is preserved across the response.
+ *
+ * Crash recovery hook: when a SessionStore-style appendEvent callback
+ * is supplied, the dispatcher records the INTENT (parsed edit) BEFORE
+ * calling the applicator. The matching `applied` event lands AFTER
+ * the writeFile. A crash between the two leaves a recoverable trail —
+ * the operator (or `pugi resume`) sees the intent and can re-attempt.
+ *
+ * The dispatcher is intentionally side-effect-light: no logging, no
+ * stdout writes, no exit-code mutation. The CLI integration layer in
+ * `cli.ts` owns operator-facing rendering; the dispatcher returns
+ * structured data and lets the caller decide UX.
+ */
+import { LayerDDeferredError, applyLayerD } from './layer-d-ast.js';
+import { applyLayerA } from './layer-a-apply.js';
+import { applyLayerB } from './layer-b-apply.js';
+import { applyLayerC } from './layer-c-apply.js';
+import { MarkerParseError, parseMarkers, } from './marker-parser.js';
+/**
+ * Parse `raw` into edits and apply each in order. Aggregate results,
+ * preserving order. Never throws — parse failures surface as a single
+ * synthetic DispatchResult with `ok: false, layer: 'layer-a', reason:
+ * 'marker_parse_error'`. Applicator failures are recorded per-edit.
+ */
+export async function dispatchEdit(raw, opts) {
+    const family = resolveFamily(opts.modelTag);
+    let parsed;
+    try {
+        parsed = parseMarkers(raw, family);
+    }
+    catch (error) {
+        if (error instanceof MarkerParseError) {
+            const result = {
+                layer: 'layer-a',
+                file: '',
+                ok: false,
+                bytesWritten: 0,
+                reason: 'marker_parse_error',
+                detail: `${error.message}${error.atLine ? ` (line ${error.atLine})` : ''} — modelHint=${error.modelHint}`,
+            };
+            opts.onResult?.(result);
+            return [result];
+        }
+        throw error;
+    }
+    if (parsed.length === 0) {
+        // Empty parse but no error == no markers in the payload. This is
+        // not necessarily a failure (the model may have answered with
+        // prose only); surface a single neutral result so the caller can
+        // render "no edits proposed".
+        return [];
+    }
+    const out = [];
+    for (const edit of parsed) {
+        const intent = makeIntent(edit);
+        opts.onIntent?.(intent);
+        const result = await applyOne(edit, opts);
+        out.push(result);
+        opts.onResult?.(result);
+    }
+    return out;
+}
+/**
+ * Public helper exposed for the marker parser tests + CLI surface that
+ * may want to know the resolved family without re-running the auto
+ * detector.
+ */
+export function resolveFamily(modelTag) {
+    if (!modelTag)
+        return 'auto';
+    const tag = modelTag.toLowerCase();
+    if (tag.startsWith('claude') || tag.startsWith('anthropic/'))
+        return 'anthropic';
+    if (tag.startsWith('gemini') || tag.startsWith('xai/') || tag.startsWith('grok'))
+        return 'gemini';
+    if (tag.startsWith('gpt') || tag.startsWith('o1') || tag.startsWith('openai/'))
+        return 'openai';
+    return 'auto';
+}
+function makeIntent(edit) {
+    switch (edit.kind) {
+        case 'layer-a':
+            return {
+                layer: 'layer-a',
+                file: edit.edit.file,
+                intentSummary: `Layer A: ${edit.edit.file} (oldString ${edit.edit.oldString.length} bytes)`,
+            };
+        case 'layer-b':
+            return {
+                layer: 'layer-b',
+                file: edit.edit.file,
+                intentSummary: `Layer B: ${edit.edit.file} (${edit.edit.edits.length} sub-edits)`,
+            };
+        case 'layer-c':
+            return {
+                layer: 'layer-c',
+                file: edit.edit.file,
+                intentSummary: `Layer C: ${edit.edit.file} (rewrite, ${edit.edit.newContents.length} bytes, baseSha ${edit.edit.baseSha256.slice(0, 12)})`,
+            };
+        case 'layer-d':
+            return {
+                layer: 'layer-d',
+                file: edit.edit.file,
+                intentSummary: `Layer D: ${edit.edit.file} op=${edit.edit.operation}`,
+            };
+    }
+}
+async function applyOne(edit, opts) {
+    const applyOpts = { cwd: opts.cwd, dryRun: opts.dryRun };
+    switch (edit.kind) {
+        case 'layer-a': {
+            const r = await applyLayerA(edit.edit, applyOpts);
+            return toResult('layer-a', edit.edit.file, r);
+        }
+        case 'layer-b': {
+            const r = await applyLayerB(edit.edit, applyOpts);
+            return {
+                ...toResult('layer-b', edit.edit.file, r),
+                appliedCount: r.appliedCount,
+            };
+        }
+        case 'layer-c': {
+            const r = await applyLayerC(edit.edit, applyOpts);
+            return {
+                ...toResult('layer-c', edit.edit.file, r),
+                expectedSha256: r.expectedSha256,
+                actualSha256: r.actualSha256,
+            };
+        }
+        case 'layer-d': {
+            try {
+                const r = await applyLayerD(edit.edit, applyOpts);
+                return toResult('layer-d', edit.edit.file, r);
+            }
+            catch (error) {
+                if (error instanceof LayerDDeferredError) {
+                    return {
+                        layer: 'layer-d',
+                        file: edit.edit.file,
+                        ok: false,
+                        bytesWritten: 0,
+                        reason: 'layer_d_deferred',
+                        detail: error.message,
+                    };
+                }
+                return {
+                    layer: 'layer-d',
+                    file: edit.edit.file,
+                    ok: false,
+                    bytesWritten: 0,
+                    reason: 'apply_error',
+                    detail: error instanceof Error ? error.message : String(error),
+                };
+            }
+        }
+    }
+}
+function toResult(layer, file, r) {
+    return {
+        layer,
+        file,
+        ok: r.ok,
+        bytesWritten: r.bytesWritten,
+        reason: r.reason,
+        detail: r.detail,
+        matchCount: r.matchCount,
+        absPath: r.absPath,
+    };
+}
+//# sourceMappingURL=dispatch.js.map