treelay 0.1.0 → 0.2.0

package/README.md

@@ -15,7 +15,10 @@ edits can be pushed back up into the layers they belong to (`promote`).
 > append/prepend, tombstones, sidecar/suffix ops, **unified-diff patches with true
 > 3-way merge**, `.treelay` state, **`explain`** for tracing where any file came
 > from, and **git/npm layer refs pinned in `treelay.lock`** with vendored
-> `mounts` and drift detection. Remaining per SPEC §12: `watch` and `eject`.
+> `mounts` and drift detection. `validate`, `watch` and `eject` complete the
+> SPEC §12 build order — every documented command is implemented. What remains
+> is the **[open]** v2 design work: hunk-level reflux, `by-key` array merging,
+> and the reflux/variables interaction (§8).
 
 ## Why not just OverlayFS / copier / Kustomize?
 
@@ -33,7 +36,10 @@ See [SPEC.md §1](./SPEC.md) for the full comparison.
 ## Core ideas
 
 - **Composition graph** — `parents` (transitive, C3-linearized) and `mixins`,
-  with precedence `mounts < parents < mixins < self`.
+  with precedence `mounts < parents < mixins < self`. Mixins carry their own
+  parents in with them. Note the two lists run opposite ways: the *first*
+  parent declared outranks the rest (Python's C3), while the *last* mixin
+  declared wins.
 - **Distributable layers** — a parent, mixin or mount can be a local path, a git
   ref, or an npm package. Whatever a build resolves is pinned in `treelay.lock`,
   so the next build reproduces it and an upstream that has moved is *reported*
@@ -68,10 +74,25 @@ treelay lock    [dir]          # resolve every layer ref and pin it
                                #   --check  --update  --drift
 treelay plan    [dir]          # print the linearized layer order
 treelay explain <dir> [file]   # trace file provenance (--json for machine output)
+treelay validate [dir]         # cycles, failing patches, conflicts, stale lock
+                               #   --drift (network)  --json
+treelay watch   <src> <dest>   # recompile on change
+                               #   --debounce ms  --poll
+treelay eject   <dest>         # drop .treelay state, keep the files (--dry-run)
 ```
 
 `compile`, `update` and `plan` also take `--frozen-lockfile`.
 
+`validate` is built to be a merge gate: it reports every problem it can find in
+one pass instead of stopping at the first, exits non-zero only on real errors
+(stale pins and missing answers are warnings), and always lists the checks it
+could *not* run — a clean report that quietly skipped half of them would be
+worse than a noisy one.
+
+`eject` is one-way. It deletes the baseline that makes `update` a three-way
+merge rather than a guess, and nothing in the output can reconstruct it, so
+`--dry-run` shows what the link was tracking before you cut it.
+
 ### Layers from git and npm, pinned
 
 A parent, mixin or mount can live anywhere. The three forms are told apart by
@@ -93,11 +114,11 @@ merge by ordinary layer precedence, which is the point: a leaf can hold
 override rule as everything else rather than a separate package mechanism.
 
 ```console
-$ treelay plan edo/soredi/_layer
+$ treelay plan klamath/project/_layer
 Layers (lowest → highest precedence):
   1. mount:packages  [mounted at packages/, pinned 64cf108ee311]
   2. core
-  3. soredi
+  3. project
 ```
 
 Whatever gets materialized is pinned in `treelay.lock` beside the leaf manifest
@@ -284,6 +305,8 @@ still local until you wire it in.
 
 ## Development
 
+Requires Node 20.19 or newer.
+
 ```bash
 npm install
 npm run typecheck   # tsc --noEmit

package/SPEC.md

@@ -96,7 +96,7 @@ Three origins, told apart by shape alone so nothing has to be declared twice:
 
 Any non-local ref may carry **`?path=<subdir>`** to use a subdirectory of the
 fetched tree as the layer root — the monorepo-of-layers case
-(`git+https://…/lake.git?path=core/_layer#v3`). Order follows URL convention:
+(`git+https://…/klamath.git?path=core/_layer#v3`). Order follows URL convention:
 query before fragment.
 
 **Git refs are enforced; npm refs are delegated.** A git ref names a commit, and
@@ -166,6 +166,24 @@ Final stack, lowest → highest:
 2. `mixins` in declaration order (each strictly above all parents)
 3. the directory's own files (always win)
 
+The two lists run in opposite directions, which is worth stating plainly:
+`parents` follows Python, so the **first**-declared base is the most derived and
+outranks the ones after it; `mixins` are layered on in order, so the **last**
+one declared wins. Parents answer "what am I a specialization of" (earlier =
+closer to you); mixins answer "what is layered on top" (later = on top).
+
+### Mixin ancestry **[decided]** ✅ *implemented*
+
+A mixin may declare `parents` of its own. Each mixin's ancestry is C3-linearized
+and placed **directly beneath that mixin**, while the whole group stays above
+every one of the leaf's parents — so `parents < mixins < self` still holds when
+read as groups rather than individual layers.
+
+A layer that already appears lower in the stack keeps its position rather than
+being re-inserted beneath its mixin. This is the diamond rule again: a shared
+ancestor applies once, at its lowest position, because promoting it upward would
+let it override the very layers it is supposed to sit beneath.
+
 ### Guards **[decided]**
 
 - **Cycle detection** — `A → B → A` fails loud with the full path shown.
@@ -190,7 +208,7 @@ in a diff.
       "resolved": "3f2a1c9e…",                        // the immutable thing it became
       "integrity": "sha256:…",                        // over the materialized tree
       "path": "core/_layer",                          // ?path=, when present
-      "requestedBy": ["edo/soredi/_layer"]            // relative to the lockfile
+      "requestedBy": ["klamath/project/_layer"]       // relative to the lockfile
     }
   }
 }
@@ -810,9 +828,12 @@ treelay explain <dir> [file] [--set k=v] [--answers f] [--json]
                                # trace which layers touched a file, in order, with patches
                                # <dir> = a source layer, or a compiled destination
                                # omit [file] to explain every path in the composition
-treelay validate [dir]         # cycles? patches apply? unresolved conflicts? drift vs lock?
-treelay watch   <src> <dest>   # recompile on change
-treelay eject   <dest>         # flatten + drop .treelay state (sever the template link)
+treelay validate [dir] [--set k=v] [--answers f] [--drift] [--json]
+                               # cycles? patches apply? unresolved conflicts? drift vs lock?
+treelay watch   <src> <dest> [--set k=v] [--debounce ms] [--poll]
+                               # recompile on change
+treelay eject   <dest> [--dry-run]
+                               # flatten + drop .treelay state (sever the template link)
 ```
 
 `promote` and `extract` always end with the §8 round-trip recompile-and-verify,
@@ -820,6 +841,15 @@ and both refuse read-only or shadowed targets with a clear explanation.
 
 `compile`, `update` and `plan` all accept `--frozen-lockfile` (§3).
 
+`validate` **collects** rather than stopping at the first problem: it is
+producing a report, not an artifact, so a finding only suppresses the checks
+that genuinely cannot run without it, and whatever went unchecked is always
+stated. Errors exit non-zero; warnings (stale pins, missing answers) do not, so
+it can be a merge gate. `watch` re-resolves the whole graph on every pass —
+editing a manifest can reshape the layer stack, so nothing from the previous
+pass can be assumed still valid. `eject` is one-way: the baseline it removes is
+the merge base `update` needs, and no part of the output can reconstruct it.
+
 `plan` and `explain` are not nice-to-haves — they are the debugging story for a
 system whose entire job is "this file came from somewhere non-obvious." Build
 `plan` before `compile`.
@@ -913,8 +943,12 @@ De-risk by building resolution first, then output, then the bidirectional loops:
 7. ✅ `explain` — per-file provenance (source layers or a compiled destination; `--json`)
 8. ✅ `status` + file-level `promote` / `extract` — reflux (pushes changes *up*)
 9. ✅ npm/git layer resolution + `mounts` + `treelay.lock` (pins, drift, `--frozen-lockfile`)
-10. `watch` / `eject`  ← next
+10. ✅ `validate` / `watch` / `eject` — the remaining §9 surface
 
 Demoable and trustworthy after step 3; templated scaffolding works at step 4;
 the headline pull-down lands at step 6, and the bidirectional link closes at
 step 8.
+
+Every command in §9 is now implemented. What remains is the **[open]** design
+work rather than build order: hunk-level reflux, `by-key` array merging, and the
+reflux/variables interaction (§8) — all deferred to v2 on purpose.

package/dist/{chunk-QKQUPZVD.js → chunk-CP7GIVGA.js}

@@ -8,14 +8,14 @@ var CycleError = class extends Error {
   path;
 };
 var InconsistentHierarchyError = class extends Error {
-  constructor(message) {
-    super(`Inconsistent hierarchy: ${message}`);
+  constructor(message2) {
+    super(`Inconsistent hierarchy: ${message2}`);
     this.name = "InconsistentHierarchyError";
   }
 };
 var MergeConflictError = class extends Error {
-  constructor(file, message) {
-    super(`Merge conflict in ${file}: ${message}`);
+  constructor(file, message2) {
+    super(`Merge conflict in ${file}: ${message2}`);
     this.file = file;
     this.name = "MergeConflictError";
   }
@@ -135,7 +135,20 @@ function templateTarget(path, suffix = DEFAULT_TEMPLATE_SUFFIX) {
 
 // src/variables.ts
 import { createInterface } from "readline/promises";
+import { Writable } from "stream";
 import { parse as parseYaml2 } from "yaml";
+var MaskableOutput = class extends Writable {
+  constructor(target = process.stdout) {
+    super();
+    this.target = target;
+  }
+  target;
+  muted = false;
+  _write(chunk, _encoding, done) {
+    if (!this.muted) this.target.write(chunk);
+    done();
+  }
+};
 function mergeVariableDecls(layers) {
   const merged = {};
   for (const layer of layers) {
@@ -196,11 +209,28 @@ async function resolveValues(graph, options = {}) {
   const resolved = new Set(Object.keys(provided).filter((n) => decls[n]));
   let pending = Object.keys(decls).filter((n) => !resolved.has(n));
   let rl;
+  let out;
   const promptVar = async (name, decl, fallback) => {
-    rl ??= createInterface({ input: process.stdin, output: process.stdout });
+    if (!rl) {
+      out = new MaskableOutput();
+      rl = createInterface({
+        input: process.stdin,
+        output: out,
+        // readline infers `terminal` from `output.isTTY`, which a proxy stream
+        // does not have. Without this it would disable echo and line editing
+        // even in a real terminal.
+        terminal: process.stdout.isTTY === true
+      });
+    }
     const hint = decl.choices ? ` ${JSON.stringify(decl.choices)}` : "";
     const def = fallback !== void 0 ? ` [${String(fallback)}]` : "";
-    const answer = (await rl.question(`${decl.prompt}${hint}${def} `)).trim();
+    const pendingAnswer = rl.question(`${decl.prompt}${hint}${def} `);
+    if (decl.secret && out) out.muted = true;
+    const answer = (await pendingAnswer).trim();
+    if (decl.secret && out) {
+      out.muted = false;
+      out.write("\n");
+    }
     return answer === "" ? fallback : coerce(decl.type, answer);
   };
   try {
@@ -466,8 +496,8 @@ import { execFileSync } from "child_process";
 import { existsSync as existsSync3, rmSync as rmSync2 } from "fs";
 import { join as join4 } from "path";
 var GitFetchError = class extends Error {
-  constructor(url, message) {
-    super(`git layer ${url}: ${message}`);
+  constructor(url, message2) {
+    super(`git layer ${url}: ${message2}`);
     this.url = url;
     this.name = "GitFetchError";
   }
@@ -580,8 +610,8 @@ import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
 import { dirname, join as join5 } from "path";
 import { satisfies, validRange } from "semver";
 var NpmResolveError = class extends Error {
-  constructor(packageName, message) {
-    super(`npm layer ${packageName}: ${message}`);
+  constructor(packageName, message2) {
+    super(`npm layer ${packageName}: ${message2}`);
     this.packageName = packageName;
     this.name = "NpmResolveError";
   }
@@ -775,7 +805,17 @@ function resolve(srcDir, options = {}) {
   const parentsOf = (layer) => (layer.manifest.parents ?? []).map((ref) => loadRef(ctx, ref, layer));
   const mro = c3Linearize(self, parentsOf, (l) => l.id);
   const parentsLowToHigh = mro.slice(1).reverse();
-  const mixins = (self.manifest.mixins ?? []).map((ref) => loadRef(ctx, ref, self));
+  const mixinGroups = (self.manifest.mixins ?? []).flatMap((ref) => {
+    const mixin = loadRef(ctx, ref, self);
+    return c3Linearize(mixin, parentsOf, (l) => l.id).reverse();
+  });
+  const placed = /* @__PURE__ */ new Set([self.id, ...parentsLowToHigh.map((l) => l.id)]);
+  const mixins = [];
+  for (const layer of mixinGroups) {
+    if (placed.has(layer.id)) continue;
+    placed.add(layer.id);
+    mixins.push(layer);
+  }
   const declared = [...parentsLowToHigh, ...mixins, self];
   const mounts = resolveMounts(ctx, declared);
   const layers = [...mounts, ...declared];
@@ -944,11 +984,11 @@ function assertParseable(file, patch) {
   try {
     hunks = parsePatch(patch).reduce((n, p) => n + p.hunks.length, 0);
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    const hint = /invalid line/i.test(message) ? "\nCheck the `@@ -old,COUNT +new,COUNT @@` header: the counts must match the number of lines in the hunk body (context + removals for the first, context + additions for the second)." : "";
+    const message2 = err instanceof Error ? err.message : String(err);
+    const hint = /invalid line/i.test(message2) ? "\nCheck the `@@ -old,COUNT +new,COUNT @@` header: the counts must match the number of lines in the hunk body (context + removals for the first, context + additions for the second)." : "";
     throw new MergeConflictError(
       file,
-      `patch payload is not a valid unified diff \u2014 ${message}${hint}`
+      `patch payload is not a valid unified diff \u2014 ${message2}${hint}`
     );
   }
   if (hunks === 0) {
@@ -2569,6 +2609,298 @@ var LayerTransaction = class {
   }
 };
 
+// src/eject.ts
+import { rmSync as rmSync6 } from "fs";
+var NotEjectableError = class extends Error {
+  constructor(destDir) {
+    super(
+      `${destDir} has no .treelay state \u2014 it is not a compiled destination, so there is no template link to sever.`
+    );
+    this.name = "NotEjectableError";
+  }
+};
+function eject(destDir, options = {}) {
+  if (!hasState(destDir)) throw new NotEjectableError(destDir);
+  const state = readState(destDir);
+  const entries = Object.entries(state.manifest);
+  const source = sourceOf(state);
+  const result = {
+    ...source !== void 0 ? { source } : {},
+    lineage: state.lock.lineage,
+    // `owned` marks a *user*-created file, so the template's own files are the
+    // ones where it is false (§7).
+    tracked: entries.filter(([, m]) => !m.owned).map(([path]) => path).sort(),
+    userOwned: entries.filter(([, m]) => m.owned).map(([path]) => path).sort(),
+    removed: false
+  };
+  if (options.dryRun) return result;
+  rmSync6(statePaths(destDir).dir, { recursive: true, force: true });
+  return { ...result, removed: true };
+}
+function formatEject(result, destDir) {
+  const lines = [];
+  const verb = result.removed ? "Ejected" : "Would eject";
+  lines.push(`${verb} ${destDir}.`);
+  if (result.source) lines.push(`  was tracking: ${result.source}`);
+  if (result.lineage.length) {
+    lines.push(`  composed from ${result.lineage.length} layer(s)`);
+  }
+  lines.push(`  ${result.tracked.length} template-owned file(s) left in place`);
+  if (result.userOwned.length) {
+    lines.push(`  ${result.userOwned.length} file(s) you created, untouched`);
+  }
+  lines.push(
+    result.removed ? `
+\`treelay update\` no longer works here. Re-linking means compiling the template into a fresh directory and copying your changes across.` : `
+Nothing was removed. Re-run without --dry-run to sever the link.`
+  );
+  return lines.join("\n");
+}
+
+// src/validate.ts
+async function validate(srcDir, options = {}) {
+  const issues = [];
+  const skipped = [];
+  const { values: given, drift: probeDrift, ...resolveOptions } = options;
+  let graph;
+  try {
+    graph = resolve(srcDir, resolveOptions);
+  } catch (err) {
+    issues.push(classifyResolveError(err));
+    skipped.push("patches and conflicts (the graph did not resolve)");
+    skipped.push("lockfile freshness (the graph did not resolve)");
+    return { ok: false, issues, skipped };
+  }
+  if (graph.lockDirty) {
+    issues.push({
+      severity: "warning",
+      code: "lock-stale",
+      message: `${lockfilePath(srcDir)} does not match what this tree resolves to.`,
+      remedy: `Run \`treelay lock ${srcDir}\` and commit the result.`
+    });
+  }
+  let values;
+  try {
+    values = await resolveValues(graph, { ...given ? { set: given } : {}, prompt: false });
+  } catch (err) {
+    issues.push({
+      severity: "warning",
+      code: "variables-unresolved",
+      message: message(err),
+      remedy: "Pass --answers or --set so validate can render and compose the tree; without values it cannot check patches or conflicts."
+    });
+    skipped.push("patches and conflicts (no values to render with)");
+  }
+  if (values) {
+    try {
+      const files = await composeToMemory(graph, values);
+      return finish(issues, skipped, graph, files.size, probeDrift, srcDir);
+    } catch (err) {
+      issues.push(classifyComposeError(err));
+    }
+  }
+  return finish(issues, skipped, graph, void 0, probeDrift, srcDir);
+}
+function finish(issues, skipped, graph, fileCount, probeDrift, srcDir) {
+  if (probeDrift) {
+    const reports = checkDrift(graph);
+    if (hasDrift(reports)) {
+      issues.push({
+        severity: "warning",
+        code: "drift",
+        message: formatDrift(reports).trim(),
+        remedy: `Run \`treelay lock ${srcDir} --update\` to advance the pins.`
+      });
+    }
+  } else {
+    skipped.push("upstream drift (needs the network; pass --drift)");
+  }
+  return {
+    ok: !issues.some((i) => i.severity === "error"),
+    issues,
+    layerCount: graph.layers.length,
+    ...fileCount !== void 0 ? { fileCount } : {},
+    skipped
+  };
+}
+var message = (err) => err instanceof Error ? err.message : String(err);
+function classifyResolveError(err) {
+  const name = err instanceof Error ? err.name : "";
+  if (name === "CycleError") {
+    return {
+      severity: "error",
+      code: "cycle",
+      message: message(err),
+      remedy: "Break the loop: a layer cannot be its own ancestor."
+    };
+  }
+  if (name === "InconsistentHierarchyError") {
+    return {
+      severity: "error",
+      code: "hierarchy",
+      message: message(err),
+      remedy: "Two layers demand incompatible orderings of the same ancestors. Reorder the conflicting `parents` lists so they agree."
+    };
+  }
+  return { severity: "error", code: "resolve-failed", message: message(err) };
+}
+function classifyComposeError(err) {
+  if (err instanceof Error && err.name === "MergeConflictError") {
+    return {
+      severity: "error",
+      code: "merge-conflict",
+      message: message(err),
+      remedy: "Either the patch no longer applies to the inherited file, or two layers edit the same lines. `treelay explain <dir> <file>` shows who touched it."
+    };
+  }
+  return { severity: "error", code: "compose-failed", message: message(err) };
+}
+function formatValidation(report, srcDir) {
+  const lines = [];
+  const errors = report.issues.filter((i) => i.severity === "error");
+  const warnings = report.issues.filter((i) => i.severity === "warning");
+  for (const issue of [...errors, ...warnings]) {
+    lines.push(`${issue.severity === "error" ? "\u2717" : "!"} ${issue.code}: ${issue.message}`);
+    if (issue.remedy) lines.push(`    ${issue.remedy}`);
+  }
+  if (lines.length) lines.push("");
+  const scope = report.layerCount === void 0 ? "" : ` (${report.layerCount} layer(s)` + (report.fileCount === void 0 ? "" : `, ${report.fileCount} file(s)`) + ")";
+  lines.push(
+    errors.length ? `${errors.length} error(s), ${warnings.length} warning(s) in ${srcDir}${scope}.` : warnings.length ? `No errors, ${warnings.length} warning(s) in ${srcDir}${scope}.` : `${srcDir} is valid${scope}.`
+  );
+  for (const s of report.skipped) lines.push(`  not checked: ${s}`);
+  return lines.join("\n");
+}
+
+// src/watch.ts
+import { watch as chokidarWatch } from "chokidar";
+import { relative as relative4, resolve as resolvePath6, isAbsolute as isAbsolute3, sep as sep2 } from "path";
+var WatchTargetError = class extends Error {
+  constructor(destDir, existing, incoming) {
+    super(
+      `${destDir} was compiled from ${existing}, not ${incoming}. Watching it would overwrite that project's files. Pick an empty destination.`
+    );
+    this.name = "WatchTargetError";
+  }
+};
+function isInside(parent, child) {
+  const rel = relative4(parent, child);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute3(rel);
+}
+function watchRoots(layerDirs, destDir) {
+  const roots = [];
+  for (const dir of layerDirs) {
+    if (isInside(dir, destDir) && dir === destDir) continue;
+    if (!roots.some((r) => isInside(r, dir))) {
+      for (let i = roots.length - 1; i >= 0; i--) {
+        if (isInside(dir, roots[i])) roots.splice(i, 1);
+      }
+      roots.push(dir);
+    }
+  }
+  return roots.sort();
+}
+async function watch(srcDir, destDir, options = {}) {
+  const {
+    values,
+    debounceMs = 120,
+    usePolling,
+    pollIntervalMs,
+    onEvent,
+    ...resolveOptions
+  } = options;
+  const src = resolvePath6(srcDir);
+  const dest = resolvePath6(destDir);
+  if (hasState(dest)) {
+    const existing = sourceOf(readState(dest));
+    if (existing && resolvePath6(existing) !== src) {
+      throw new WatchTargetError(dest, existing, src);
+    }
+  }
+  let watcher;
+  let roots = [src];
+  const syncRoots = (dirs) => {
+    const next = watchRoots([src, ...dirs], dest);
+    const added = next.filter((r) => !roots.includes(r));
+    roots = next;
+    if (added.length && watcher) watcher.add(added);
+  };
+  const build = async (trigger) => {
+    const started = Date.now();
+    try {
+      const graph = resolve(src, resolveOptions);
+      const composed = await resolveValues(graph, {
+        ...values ? { set: values } : {},
+        prompt: false
+      });
+      const result = await compile(graph, { destDir: dest, values: composed });
+      syncRoots(
+        graph.layers.filter((l) => !l.origin || l.origin.kind === "local").map((l) => l.dir)
+      );
+      onEvent?.({
+        kind: "compiled",
+        files: Object.keys(result.files).length,
+        ms: Date.now() - started,
+        ...trigger ? { trigger } : {}
+      });
+    } catch (err) {
+      onEvent?.({
+        kind: "failed",
+        error: err instanceof Error ? err : new Error(String(err)),
+        ...trigger ? { trigger } : {}
+      });
+    }
+  };
+  await build();
+  let timer;
+  let pending;
+  let closed = false;
+  watcher = chokidarWatch(roots, {
+    ignoreInitial: true,
+    ...usePolling ? { usePolling: true } : {},
+    ...pollIntervalMs !== void 0 ? { interval: pollIntervalMs } : {},
+    // The output must never feed the loop that produces it, and neither should
+    // the state directory compile itself writes on every pass.
+    ignored: (path) => isInside(dest, path) || path.split(sep2).includes(STATE_DIR) || path.split(sep2).includes("node_modules") || path.split(sep2).includes(".git")
+  });
+  watcher.on("all", (_event, path) => {
+    if (closed) return;
+    pending ??= path;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      const trigger = pending;
+      pending = void 0;
+      timer = void 0;
+      void build(trigger);
+    }, debounceMs);
+  });
+  await new Promise((res) => watcher.once("ready", () => res()));
+  onEvent?.({ kind: "ready", roots });
+  return {
+    // A getter, not a snapshot: `syncRoots` replaces the array when the graph
+    // gains a layer, and a stale copy would misreport what is being watched.
+    get roots() {
+      return roots;
+    },
+    trigger: () => build(),
+    close: async () => {
+      closed = true;
+      if (timer) clearTimeout(timer);
+      await watcher.close();
+    }
+  };
+}
+function formatWatchEvent(event) {
+  switch (event.kind) {
+    case "ready":
+      return `Watching ${event.roots.length} layer(s). Ctrl-C to stop.`;
+    case "compiled":
+      return `Compiled ${event.files} file(s) in ${event.ms}ms` + (event.trigger ? `  \u2190 ${event.trigger}` : "");
+    case "failed":
+      return `Build failed: ${event.error.message}`;
+  }
+}
+
 export {
   CycleError,
   InconsistentHierarchyError,
@@ -2660,6 +2992,14 @@ export {
   status,
   formatStatus,
   promote,
-  extract
+  extract,
+  NotEjectableError,
+  eject,
+  formatEject,
+  validate,
+  formatValidation,
+  WatchTargetError,
+  watch,
+  formatWatchEvent
 };
-//# sourceMappingURL=chunk-QKQUPZVD.js.map
+//# sourceMappingURL=chunk-CP7GIVGA.js.map