mlx-bun 0.5.0 → 1.0.0

package/src/engine/generation-gateway.ts

@@ -0,0 +1,358 @@
+import { AdmissionPool } from "@mlx-bun/inference/execution/admission";
+import { cleanupFailure, disposeResources } from "@mlx-bun/inference/runtime/resources";
+import type { createRowSampling, MlxGatewayBinding, MlxBatchGroup } from "@mlx-bun/inference/execution";
+import type { GenerateOptions, GenerateStats } from "@mlx-bun/inference/generation";
+import type { RuntimeConfig } from "@mlx-bun/inference/runtime/config";
+import type { PromptResponseTrace } from "@mlx-bun/inference/runtime/trace";
+import type { KvCacheService, RequestStateCache } from "@mlx-bun/inference/state";
+import type { DisposableResource } from "@mlx-bun/inference/contracts/portable";
+import type { DeviceStepSampler, DeviceStepSamplerConfig } from "@mlx-bun/inference/sampling";
+import type { CompletionEngine, RequestShape, GenerationPlacement, Vision, OnToken } from "./completion";
+import { UnsupportedExecutionError } from "./completion";
+import { acquireReservation } from "./preparation";
+
+/** Async mutex: acquire() resolves to a release fn; releases run FIFO. */
+class AsyncMutex {
+  #tail: Promise<void> = Promise.resolve();
+  /** Holders + waiters. > 0 means somebody owns or wants the engine. */
+  #pending = 0;
+  get locked(): boolean {
+    return this.#pending > 0;
+  }
+  acquire(signal?: AbortSignal): Promise<() => void> {
+    if (signal?.aborted) return Promise.reject(signal.reason);
+    this.#pending++;
+    let release!: () => void;
+    const gate = new Promise<void>((r) => { release = r; });
+    const wait = this.#tail;
+    this.#tail = this.#tail.then(() => gate);
+    let released = false;
+    const unlock = () => {
+      if (released) return; // idempotent: a double release must not skew #pending
+      released = true;
+      this.#pending--;
+      release();
+    };
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const abort = () => {
+        if (settled) return;
+        settled = true;
+        signal?.removeEventListener("abort", abort);
+        // Release this waiter's gate, not its predecessor's. Later acquirers
+        // still wait for the active holder, preserving mutual exclusion.
+        unlock();
+        reject(signal!.reason);
+      };
+      signal?.addEventListener("abort", abort, { once: true });
+      wait.then(() => {
+        if (settled) return;
+        settled = true;
+        signal?.removeEventListener("abort", abort);
+        resolve(unlock);
+      });
+    });
+  }
+}
+
+export function disposeUnstartedRequest(options: GenerateOptions, vision?: Vision): void {
+  disposeResources([options.grammar, vision?.embeddings, vision?.imageMask,
+    vision?.multimodalMask, options.visionPixels].filter((resource) => resource != null));
+}
+
+/** After reservation, run() releases the request's media and pixels once on
+ * every path; a request that fails before submission releases only its grammar. */
+function disposeReservedUnstarted(options: GenerateOptions): void {
+  options.grammar?.dispose();
+}
+
+/** The app's one execution path: lone and concurrent requests use the same library
+ * scheduler. Exclusive leases protect mutations and managed jobs. */
+export class GenerationGateway implements CompletionEngine {
+  #closed = false;
+  readonly #runtime: RuntimeConfig;
+  readonly #binding: MlxGatewayBinding;
+  readonly #requests: AdmissionPool;
+  readonly #mutex = new AsyncMutex();
+  readonly #batch: number;
+  #scheduler: MlxBatchGroup | null = null;
+  #rowsSubmitted = 0;
+
+  #exclusiveWaiters = 0;
+  constructor(
+    binding: MlxGatewayBinding,
+    capacity: number,
+    private readonly opts: {
+      /** The loaded model's cache service: the scheduler's request state, and
+       * saved prefixes read ahead of admission. Borrowed; its owner closes it. */
+      cache?: RequestStateCache & Pick<KvCacheService, "prefetch" | "checkpointEveryTokens">;
+      adapterNamespace?: (adapters: string[]) => string;
+      /** Builds the per-row sampler for ordinary rows (binding-owned method and
+       * continuation rows sample through their binding). Default: makeStepSampler. */
+      samplerFactory?: (options: GenerateOptions, config: DeviceStepSamplerConfig) => DeviceStepSampler;
+    } = {},
+  ) {
+    this.#binding = binding;
+    this.#runtime = this.#binding.runtime;
+    this.opts = Object.freeze({ ...opts });
+    if (!Number.isSafeInteger(capacity) || capacity < 1) throw new Error("execution capacity must be a positive integer");
+    this.#batch = capacity;
+    this.#requests = new AdmissionPool(this.#batch);
+  }
+
+  /** Rows currently decoding in the batch (0 if no scheduler / idle). */
+  get activeRows(): number {
+    return this.#scheduler?.activeRows ?? 0;
+  }
+
+  /** Queued + mid-prefill rows waiting behind the batch (0 when idle). */
+  get pendingRows(): number {
+    return this.#scheduler?.pendingRows ?? 0;
+  }
+
+  get busy(): boolean {
+    return this.#requests.active > 0 || this.#requests.queued > 0 ||
+      this.#mutex.locked || this.activeRows > 0 || this.pendingRows > 0;
+  }
+
+  async close(): Promise<void> {
+    this.#closed = true;
+    this.#requests.close();
+    try { await this.#scheduler?.close(); }
+    finally { await this.onIdle(); }
+  }
+
+  /** Observe idleness. Call runWhenIdle for background work that must also
+   * acquire ownership atomically with the idle check. */
+  async onIdle(pollMs = 20): Promise<void> {
+    while (this.busy) await new Promise<void>((r) => setTimeout(r, pollMs));
+  }
+
+  /** Background work waits without requesting a batch drain. The final busy
+   * check and mutex acquisition have no await between them, so a foreground
+   * request cannot enter between the check and ownership registration. */
+  async runWhenIdle<T>(fn: () => Promise<T>, pollMs = 20): Promise<T> {
+    while (this.busy) await new Promise<void>(resolve => setTimeout(resolve, pollMs));
+    return this.runExclusive(fn);
+  }
+
+  get submittedRows(): number {
+    return this.#rowsSubmitted;
+  }
+
+  place(shape: RequestShape, options: GenerateOptions = {}): GenerationPlacement {
+    if (this.#closed) throw new Error("generation gateway is closed");
+    const frozenShape = Object.freeze(shape);
+    const execution = this.#binding.plan(frozenShape, options,
+      { checkpoints: this.opts.cache?.checkpointEveryTokens !== undefined });
+    if (execution.mechanism !== "continuous")
+      throw new UnsupportedExecutionError(this.#binding.config.modelType, execution.method, execution.reasons);
+    return Object.freeze({ shape: frozenShape, mechanism: "continuous", execution });
+  }
+
+  /** Shared by inference, preparation and managed GPU subprocesses. */
+  async acquireExecutionLease(
+    signal?: AbortSignal,
+    trace?: PromptResponseTrace,
+  ): Promise<DisposableResource> {
+    if (this.#closed) throw new Error("generation gateway is closed");
+    this.#exclusiveWaiters++;
+    const closeAdmission = trace?.begin("engine.admission_wait", { mechanism: "exclusive" });
+    const resume = () => {
+      this.#exclusiveWaiters--;
+      if (this.#exclusiveWaiters === 0) this.#scheduler?.kick();
+    };
+    try {
+      const release = await this.#mutex.acquire(signal);
+      let released = false;
+      return { dispose: () => {
+        if (released) return;
+        released = true;
+        release(); resume();
+      } };
+    } catch (error) { resume(); throw error; }
+    finally { closeAdmission?.(); }
+  }
+
+  async runExclusive<T>(
+    fn: () => Promise<T>,
+    trace?: PromptResponseTrace,
+    signal?: AbortSignal,
+  ): Promise<T> {
+    const lease = await this.acquireExecutionLease(signal, trace);
+    try { return await fn(); } finally { lease.dispose(); }
+  }
+
+  /** Preparation reads model weights without replacing active model state.
+   * A compatible backend can perform it between existing decode iterations. */
+  runPreparation<T>(work: () => Promise<T>, signal?: AbortSignal): Promise<T> {
+    if (this.#closed) return Promise.reject(new Error("generation gateway is closed"));
+    if (signal?.aborted) return Promise.reject(signal.reason);
+    const group = this.#ensureScheduler();
+    return group?.runPreparation
+      ? group.runPreparation(work, signal)
+      : this.runExclusive(work, undefined, signal);
+  }
+
+  get mediaBatchingEnabled(): boolean { return !!this.#binding.mediaInput; }
+
+  /** Run one generation through the shared scheduler. onToken is invoked per emitted
+   *  token (its `false` halts); resolves with stats when the generation ends. */
+  async run(
+    promptIds: number[],
+    options: GenerateOptions & { stopSequences?: string[] },
+    onToken: OnToken,
+    vision: Vision | undefined,
+    shape: RequestShape,
+    placement: GenerationPlacement,
+    signal?: AbortSignal,
+    trace?: PromptResponseTrace,
+  ): Promise<GenerateStats> {
+    let reservation;
+    const closeRequestWait = trace?.begin("engine.request_wait", { capacity: this.#batch });
+    try { reservation = await acquireReservation(this.#requests, signal); }
+    catch (error) { cleanupFailure(error, () => disposeUnstartedRequest(options, vision)); }
+    finally { closeRequestWait?.(); }
+    let releasePrefix: (() => void) | undefined;
+    try {
+      try {
+        const adapters = options.adapters?.length
+          ? this.opts.adapterNamespace?.(options.adapters) ?? JSON.stringify(options.adapters) : "";
+        // A prepared media prefix is identified within the request's own namespace, which the
+        // binding places in its method's (the rows' cache namespace, below); the cache service adds its paging.
+        const base = vision?.prefixIdentity ? JSON.stringify(["prepared-prefix-v1", vision.prefixIdentity, adapters]) : adapters;
+        const namespace = this.#binding.prefixNamespace?.(placement.execution, options, base) ??
+          (placement.execution?.method === "speculative" ? null : base);
+        if ((!vision || placement.execution?.promptCache) && namespace !== null && this.opts.cache) {
+          const closePrefetch = trace?.begin("cache.prefetch");
+          try { releasePrefix = await this.opts.cache.prefetch(promptIds, namespace, options.cacheSessionId); }
+          finally { closePrefetch?.(); }
+        }
+      } catch (error) { cleanupFailure(error, () => disposeReservedUnstarted(options)); }
+      return await this.#run(promptIds, options, onToken, vision, shape, placement, signal, trace);
+    } finally {
+      // The request transferred its native inputs to this run; this is their
+      // one release after reservation. A denoising row borrows its pixels for
+      // its first unit and closes its run before the submission settles, so
+      // they are released here, as main's one-request run did.
+      disposeResources([{ dispose: () => releasePrefix?.() }, reservation,
+        ...[vision?.embeddings, vision?.imageMask, vision?.multimodalMask, options.visionPixels]
+          .filter(value => value != null)]);
+    }
+  }
+
+  async #run(
+    promptIds: number[],
+    options: GenerateOptions & { stopSequences?: string[] },
+    onToken: OnToken,
+    vision: Vision | undefined,
+    shape: RequestShape,
+    placement: GenerationPlacement,
+    signal?: AbortSignal,
+    trace?: PromptResponseTrace,
+  ): Promise<GenerateStats> {
+    const disposeUnstarted = () => disposeReservedUnstarted(options);
+    if (placement.shape !== shape) {
+      disposeUnstarted();
+      throw new Error("generation placement does not belong to this request shape");
+    }
+    try {
+      signal?.throwIfAborted();
+    } catch (e) {
+      // The gateway is the first component that accepts ownership of a
+      // compiled controller. An aborted request never reaches the scheduler.
+      disposeUnstarted();
+      throw e;
+    }
+    let sampling: ReturnType<typeof createRowSampling> | undefined;
+    let closeAdmission: (() => void) | undefined;
+    let st;
+    try {
+      const adapters = options.adapters?.length ? [...options.adapters] : undefined;
+      const adapterKey = adapters ? JSON.stringify(adapters) : "";
+      const adapterNamespace = () => adapters ? this.opts.adapterNamespace?.(adapters) ?? adapterKey : "";
+      const cacheNamespace = vision?.prefixIdentity
+        ? () => JSON.stringify(["prepared-prefix-v1", vision.prefixIdentity, adapterNamespace()])
+        : adapters ? adapterNamespace : "";
+      const context = adapters
+        ? this.#binding.bindAdapterContext?.(adapters, `adapters:${adapterKey}`) : undefined;
+
+      // The scheduler owns grammar ready/accept sequencing. StepSampler owns the
+      // shared processors -> mask -> logprobs -> sample -> history contract.
+      const method = this.#binding.methodRequest?.(placement.execution, options);
+      const continuation = method ? undefined : this.#binding.continuationRequest?.(placement.execution, options, promptIds, onToken,
+        this.opts.cache?.checkpointEveryTokens);
+      if (!method && !continuation) {
+        const { createRowSampling } = await import("@mlx-bun/inference/execution");
+        const samplerFactory = this.opts.samplerFactory ?? (await import("@mlx-bun/inference/sampling")).makeStepSampler;
+        sampling = createRowSampling(samplerFactory(options, {
+          tokenRepresentation: "device", grammarWait: "external",
+          historyUpdate: "after-sample", initialHistory: promptIds,
+          captureSelectedLogprob: options.logprobs === true,
+          captureTopLogprobs: options.topLogprobs,
+        }), onToken);
+      } else { sampling = continuation; }
+
+      signal?.throwIfAborted();
+      this.#rowsSubmitted++;
+      closeAdmission = trace?.begin("engine.admission_wait", {
+        mechanism: "continuous",
+      });
+      st = await this.#ensureScheduler().submit({
+        promptIds, context, cacheNamespace, cacheSessionId: options.cacheSessionId, prefillChunkSize: options.prefillChunkSize,
+        ...(vision ? { promptInput: this.#binding.mediaInput!(vision) } : {}),
+        continuation: continuation?.continuation,
+        reusesPrefix: this.#binding.reusesPrefix(placement.execution),
+        compiledDecode: placement.execution?.compiledDecode,
+        maxTokens: options.maxTokens ?? 512,
+        eosTokenIds: options.eosTokenIds ?? this.#binding.config.eosTokenIds,
+        ...(method ? { method, onToken } : { sample: sampling!.sample,
+          plainGreedy: sampling!.plainGreedy, onToken: sampling!.onToken }),
+        onAdmitted: closeAdmission,
+        trace,
+        ...(signal ? { signal } : {}),
+        // B1: pass the per-row grammar controller through. The scheduler drives
+        // accept/ready/terminate; this gateway OWNS disposal (finally below)
+        // across resolve, reject, eviction, and the whole-batch-drop error path.
+        ...(options.grammar ? { grammar: options.grammar } : {}),
+        // Capture reusable prefixes at the established stable boundary.
+        ...(options.snapshotAt !== undefined ? { snapshotAt: options.snapshotAt } : {}),
+      });
+    } finally {
+      // Attempt all request-owned releases even if a destructor fails.
+      disposeResources([{ dispose: () => closeAdmission?.() }, sampling, options.grammar]
+        .filter((resource) => resource != null));
+    }
+
+    // Autoregressive decode time starts at the first token. Denoising computes
+    // every published token inside its decode span, as main's one-request method did.
+    const decodedTokens = placement.execution?.method === "denoising" ? st.generatedTokens : st.generatedTokens - 1;
+    return {
+      promptTokens: st.promptTokens,
+      cachedTokens: st.cachedTokens,
+      generatedTokens: st.generatedTokens,
+      finishReason: st.finishReason,
+      prefillMs: st.prefillMs,
+      decodeMs: st.decodeMs,
+      prefillTps: st.prefillMs > 0 ? ((st.promptTokens - st.cachedTokens) / st.prefillMs) * 1000 : 0,
+      decodeTps: st.decodeMs > 0 && decodedTokens > 0 ? (decodedTokens / st.decodeMs) * 1000 : 0,
+      cacheTokens: [],
+      ...(st.spec ? { spec: st.spec } : {}),
+      ...(st.fill ? { fill: st.fill } : {}),
+    };
+  }
+
+  #ensureScheduler(): MlxBatchGroup {
+    if (!this.#scheduler)
+      this.#scheduler = this.#binding.createBatchGroup({
+        runtime: this.#runtime,
+        maxBatch: this.#batch,
+        ...(this.opts.cache ? { cache: this.opts.cache } : {}),
+        lock: { acquire: () => this.#mutex.acquire() },
+
+        // Exclusive mutations drain current rows before acquiring the model.
+        admissionHeld: () => this.#exclusiveWaiters > 0,
+      });
+    return this.#scheduler;
+  }
+}

package/src/engine/index.ts

@@ -0,0 +1,59 @@
+import { GenerationGateway, disposeUnstartedRequest } from "./generation-gateway";
+import { createSessionCompletionEngine } from "./session-completion-engine";
+import { createPreparationExecutor } from "./preparation";
+import { modelServingBinding } from "./model-serving";
+import { releaseContext, type ContextOwnership, type LoadedModelContext } from "./model-host";
+import type { ModelBinding } from "./model-binding";
+
+export * from "./model-host";
+export * from "./model-binding";
+export * from "./model-serving";
+export * from "./generation-gateway";
+export * from "./completion";
+export * from "./preparation";
+export * from "./session-completion-engine";
+export * from "./cache-services";
+
+/** Takes ownership of beforeModelDispose and, unless `ownership` is "borrowed",
+ * of context. Close cancels sessions, drains work, then runs the hook and
+ * releases the context by that rule, once. A supplied binding keeps replacement
+ * graphs independent of the built-in model classes. No server is started here. */
+export async function createAppEngine(context: LoadedModelContext, options: {
+  capacity: number; binding?: ModelBinding;
+  gateway?: ConstructorParameters<typeof GenerationGateway>[2];
+  /** Owned cleanup, invoked once after execution drains and before model release,
+   * including construction failure. Use for cache flush and cache disposal. */
+  beforeModelDispose?: () => void | Promise<unknown>;
+  /** Default "owned": close and a failed construction dispose the context. */
+  ownership?: ContextOwnership;
+}) {
+  let createdGateway: GenerationGateway | undefined;
+  const release = () => releaseContext(context, options.ownership ?? "owned");
+  try {
+    const binding = await modelServingBinding(context, options.binding);
+    const gateway = createdGateway = new GenerationGateway(binding.gateway, options.capacity, options.gateway);
+    const completion = createSessionCompletionEngine(gateway, disposeUnstartedRequest);
+    const preparation = createPreparationExecutor((work, signal) => gateway.runPreparation(work, signal),
+      options.capacity, gateway.mediaBatchingEnabled ? options.capacity : 1);
+    let closing: Promise<void> | undefined;
+    return {
+      context, binding, gateway, completion, preparation,
+      close() {
+        return closing ??= (async () => {
+          await releaseAll([() => preparation.close(), () => completion.close(),
+            () => gateway.close(), () => options.beforeModelDispose?.(), release]);
+        })();
+      },
+    };
+  } catch (error) {
+    await releaseAll([() => createdGateway?.close(), () => options.beforeModelDispose?.(), release], [error]);
+    throw error;
+  }
+}
+
+/** Attempt owned asynchronous releases in order, preserving every failure. */
+async function releaseAll(releases: readonly (() => void | Promise<unknown>)[], errors: unknown[] = []): Promise<void> {
+  for (const release of releases) { try { await release(); } catch (error) { errors.push(error); } }
+  if (errors.length === 1) throw errors[0];
+  if (errors.length) throw new AggregateError(errors, "app engine cleanup failed");
+}

package/src/engine/kv-budget.ts

@@ -0,0 +1,120 @@
+// One byte budget over the saved-state root (`MLX_BUN_HOME/kv`). Every model's
+// store lives in its own directory `<root>/<fingerprint>/`; a store enforces
+// only its own directory, so the budget lends each live store the room the
+// others leave and evicts the oldest files of directories no live store owns.
+// Saved state is always droppable: an evicted file is a prefix miss, never an
+// error. A live store never loses a file it indexed; it shrinks itself.
+import { existsSync, readdirSync, rmdirSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+/** What the budget needs from one live store. */
+export interface KvBudgetMember {
+  /** The store's own directory under the root. */
+  readonly dir: string;
+  /** Bytes the store holds now. */
+  bytes(): number;
+}
+
+export interface KvBudgetUsage {
+  /** Every byte under the root. */
+  readonly bytes: number;
+  /** Held by directories no live store owns. */
+  readonly idleBytes: number;
+  readonly maxBytes: number;
+}
+
+export interface KvBudget {
+  readonly root: string;
+  /** Infinity: unlimited. */
+  readonly maxBytes: number;
+  /** Count a live store against the budget; `limit()` is the cap it enforces on itself now. */
+  attach(member: KvBudgetMember): { limit(): number; detach(): void };
+  /** Evict the oldest files of idle directories until the root fits. Live stores are never touched. */
+  reclaim(): { removedFiles: number; removedBytes: number };
+  usage(): KvBudgetUsage;
+}
+
+interface FileEntry { path: string; bytes: number; mtimeMs: number }
+
+function walk(dir: string, into: FileEntry[]): void {
+  let entries;
+  try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+  for (const entry of entries) {
+    const path = join(dir, entry.name);
+    if (entry.isDirectory()) { walk(path, into); continue; }
+    try { const stat = statSync(path); into.push({ path, bytes: stat.size, mtimeMs: stat.mtimeMs }); } catch { /* raced with a delete */ }
+  }
+}
+
+/** A live store keeps at least this share of the budget however full the others are. */
+const LIVE_FLOOR = 0.25;
+
+export function createKvBudget(root: string, maxBytes: number = Infinity): KvBudget {
+  if (!(maxBytes > 0)) throw new Error("a saved-state budget must be positive; use Infinity for none");
+  const members = new Set<KvBudgetMember>();
+  let idleBytes = 0, scanned = false;
+  const isLive = (dir: string) => [...members].some(member => member.dir === dir);
+  /** Files of every top-level directory that no live store owns. */
+  const idleFiles = (): FileEntry[] => {
+    const files: FileEntry[] = [];
+    let names: string[] = [];
+    try { names = readdirSync(root); } catch { /* no root yet: nothing saved */ }
+    for (const name of names) if (!isLive(join(root, name))) walk(join(root, name), files);
+    return files;
+  };
+  const refresh = (files = idleFiles()) => { idleBytes = files.reduce((sum, file) => sum + file.bytes, 0); scanned = true; };
+  const liveBytes = (except?: KvBudgetMember) => [...members].reduce((sum, member) => member === except ? sum : sum + member.bytes(), 0);
+  return {
+    root, maxBytes,
+    attach(member) {
+      members.add(member);
+      scanned = false;
+      return {
+        limit: () => {
+          if (!Number.isFinite(maxBytes)) return Infinity;
+          if (!scanned) refresh();
+          return Math.max(maxBytes * LIVE_FLOOR, maxBytes - idleBytes - liveBytes(member));
+        },
+        detach: () => { members.delete(member); scanned = false; },
+      };
+    },
+    reclaim() {
+      const files = idleFiles();
+      refresh(files);
+      let removedFiles = 0, removedBytes = 0;
+      if (Number.isFinite(maxBytes)) {
+        files.sort((a, b) => a.mtimeMs - b.mtimeMs);
+        for (const file of files) {
+          if (idleBytes + liveBytes() <= maxBytes) break;
+          try { rmSync(file.path, { force: true }); } catch { continue; }
+          idleBytes -= file.bytes; removedFiles++; removedBytes += file.bytes;
+        }
+        if (removedFiles) pruneEmpty(root, members);
+      }
+      return { removedFiles, removedBytes };
+    },
+    usage() {
+      refresh();
+      return { bytes: idleBytes + liveBytes(), idleBytes, maxBytes };
+    },
+  };
+}
+
+/** Remove directories the eviction emptied, never a live store's own. */
+function pruneEmpty(root: string, members: ReadonlySet<KvBudgetMember>): void {
+  const live = new Set([...members].map(member => member.dir));
+  const prune = (dir: string): boolean => {
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return false; }
+    let empty = true;
+    for (const entry of entries) {
+      if (entry.isDirectory() && prune(join(dir, entry.name))) continue;
+      empty = false;
+    }
+    if (!empty || live.has(dir)) return false;
+    try { rmdirSync(dir); return true; } catch { return false; }
+  };
+  if (!existsSync(root)) return;
+  for (const entry of readdirSync(root, { withFileTypes: true }))
+    if (entry.isDirectory() && !live.has(join(root, entry.name))) prune(join(root, entry.name));
+}