@procedures/mark 0.45.0 → 0.47.1

package/dist/print.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"print.d.ts","sourceRoot":"","sources":["../src/print.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,MAAM,OAAO,CAAC;AAI1B;;GAEG;AACH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,OAAO,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,eAAO,MAAM,KAAK;IAEhB,IAAI,QAAQ,MAAM,KAAG,IAAI;IAIzB,OAAO,QAAQ,MAAM,KAAG,IAAI;IAI5B,KAAK,QAAQ,MAAM,KAAG,IAAI;IAI1B,OAAO,QAAQ,MAAM,KAAG,IAAI;IAI5B,KAAK,QAAQ,MAAM,KAAG,IAAI;IAI1B,SAAS,QAAQ,MAAM,KAAG,IAAI;IAK9B,IAAI,QAAQ,MAAM,KAAG,OAAO;IAgB5B,KAAK,SAAS,MAAM,EAAE,EAAE,aAAa;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,KAAG,IAAI;IAsB/D,OAAO,QAAM,IAAI;IAKjB,OAAO,QAAM,IAAI;CAGlB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC;AAEjC;;GAEG;AACH,OAAO,EAAE,KAAK,EAAE,CAAC"}
+{"version":3,"file":"print.d.ts","sourceRoot":"","sources":["../src/print.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,MAAM,OAAO,CAAC;AAa1B;;GAEG;AACH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,OAAO,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,eAAO,MAAM,KAAK;IAEhB,IAAI,QAAQ,MAAM,KAAG,IAAI;IAIzB,OAAO,QAAQ,MAAM,KAAG,IAAI;IAI5B,KAAK,QAAQ,MAAM,KAAG,IAAI;IAI1B,OAAO,QAAQ,MAAM,KAAG,IAAI;IAI5B,KAAK,QAAQ,MAAM,KAAG,IAAI;IAI1B,SAAS,QAAQ,MAAM,KAAG,IAAI;IAK9B,IAAI,QAAQ,MAAM,KAAG,OAAO;IAgB5B,KAAK,SAAS,MAAM,EAAE,EAAE,aAAa;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,KAAG,IAAI;IAuB/D,OAAO,QAAM,IAAI;IAKjB,OAAO,QAAM,IAAI;CAGlB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC;AAEjC;;GAEG;AACH,OAAO,EAAE,KAAK,EAAE,CAAC"}

package/dist/print.js

@@ -6,7 +6,14 @@
  */
 import chalk from "chalk";
 import ora from "ora";
-import Table from "cli-table3";
+import { createRequire } from "node:module";
+/**
+ * This function gives the table class of `cli-table3`. The first table loads the package, not the
+ * start of `mark`: a call that prints no table does not load it (roadmap O93).
+ */
+function tableClass() {
+    return createRequire(import.meta.url)("cli-table3");
+}
 /**
  * Print utilities
  */
@@ -52,6 +59,7 @@ export const print = {
         const [headers, ...rows] = data;
         if (!headers)
             return;
+        const Table = tableClass();
         const table = new Table({
             head: headers.map((h) => chalk.bold(h)),
             style: {

package/dist/print.js.map

@@ -1 +1 @@
-{"version":3,"file":"print.js","sourceRoot":"","sources":["../src/print.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"print.js","sourceRoot":"","sources":["../src/print.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@procedures/mark",
-  "version": "0.45.0",
+  "version": "0.47.1",
   "description": "mark: one CLI for every procedure package. It finds the procedures, parses flags by their Zod types, runs local or through a fast warm server, and asks for missing arguments.",
   "keywords": [
     "cli",
@@ -52,18 +52,18 @@
   },
   "dependencies": {
     "@mark1russell7/service": "^0.6.0",
-    "@procedures/cli-kit": "0.45.0",
-    "@procedures/cli-run": "0.45.0",
-    "@procedures/client": "0.45.0",
-    "@procedures/fs": "0.45.0",
-    "@procedures/lib": "0.45.0",
-    "@procedures/mcp-dev-tools": "0.45.0",
-    "@procedures/peer": "0.45.0",
-    "@procedures/pnpm": "0.45.0",
-    "@procedures/procedure": "0.45.0",
-    "@procedures/server": "0.45.0",
-    "@procedures/shell": "0.45.0",
-    "@procedures/vitest": "0.45.0",
+    "@procedures/cli-kit": "0.47.1",
+    "@procedures/cli-run": "0.47.1",
+    "@procedures/client": "0.47.1",
+    "@procedures/fs": "0.47.1",
+    "@procedures/lib": "0.47.1",
+    "@procedures/mcp-dev-tools": "0.47.1",
+    "@procedures/peer": "0.47.1",
+    "@procedures/pnpm": "0.47.1",
+    "@procedures/procedure": "0.47.1",
+    "@procedures/server": "0.47.1",
+    "@procedures/shell": "0.47.1",
+    "@procedures/vitest": "0.47.1",
     "chalk": "^5.3.0",
     "cli-table3": "^0.6.5",
     "ora": "^8.0.0",
@@ -71,44 +71,44 @@
     "zod": "^4.6.5"
   },
   "devDependencies": {
-    "@mark1russell7/cue": "^1.0.0",
-    "@procedures/archive": "0.45.0",
-    "@procedures/bundle-assistant": "0.45.0",
-    "@procedures/bundle-dev": "0.45.0",
-    "@procedures/bundle-mcp": "0.45.0",
-    "@procedures/claude-cli": "0.45.0",
-    "@procedures/compiler": "0.45.0",
-    "@procedures/cue": "0.45.0",
-    "@procedures/dag": "0.45.0",
-    "@procedures/docker": "0.45.0",
-    "@procedures/env": "0.45.0",
-    "@procedures/exif": "0.45.0",
-    "@procedures/geo": "0.45.0",
-    "@procedures/gh": "0.45.0",
-    "@procedures/git": "0.45.0",
-    "@procedures/http": "0.45.0",
-    "@procedures/ics": "0.45.0",
-    "@procedures/ios-backup": "0.45.0",
-    "@procedures/json": "0.45.0",
-    "@procedures/llm": "0.45.0",
-    "@procedures/mail": "0.45.0",
-    "@procedures/mongo": "0.45.0",
-    "@procedures/node": "0.45.0",
-    "@procedures/notify": "0.45.0",
-    "@procedures/npm": "0.45.0",
-    "@procedures/pdf": "0.45.0",
-    "@procedures/privacy-scan": "0.45.0",
-    "@procedures/restic": "0.45.0",
-    "@procedures/s3": "0.45.0",
-    "@procedures/schedule": "0.45.0",
-    "@procedures/snapshot": "0.45.0",
-    "@procedures/splay": "0.45.0",
-    "@procedures/sqlite": "0.45.0",
-    "@procedures/store": "0.45.0",
-    "@procedures/systems": "0.45.0",
-    "@procedures/tailscale": "0.45.0",
-    "@procedures/vite": "0.45.0",
-    "@procedures/weather": "0.45.0",
+    "@mark1russell7/cue": "^1.1.0",
+    "@procedures/archive": "0.47.1",
+    "@procedures/bundle-assistant": "0.47.1",
+    "@procedures/bundle-dev": "0.47.1",
+    "@procedures/bundle-mcp": "0.47.1",
+    "@procedures/claude-cli": "0.47.1",
+    "@procedures/compiler": "0.47.1",
+    "@procedures/cue": "0.47.1",
+    "@procedures/dag": "0.47.1",
+    "@procedures/docker": "0.47.1",
+    "@procedures/env": "0.47.1",
+    "@procedures/exif": "0.47.1",
+    "@procedures/geo": "0.47.1",
+    "@procedures/gh": "0.47.1",
+    "@procedures/git": "0.47.1",
+    "@procedures/http": "0.47.1",
+    "@procedures/ics": "0.47.1",
+    "@procedures/ios-backup": "0.47.1",
+    "@procedures/json": "0.47.1",
+    "@procedures/llm": "0.47.1",
+    "@procedures/mail": "0.47.1",
+    "@procedures/mongo": "0.47.1",
+    "@procedures/node": "0.47.1",
+    "@procedures/notify": "0.47.1",
+    "@procedures/npm": "0.47.1",
+    "@procedures/pdf": "0.47.1",
+    "@procedures/privacy-scan": "0.47.1",
+    "@procedures/restic": "0.47.1",
+    "@procedures/s3": "0.47.1",
+    "@procedures/schedule": "0.47.1",
+    "@procedures/snapshot": "0.47.1",
+    "@procedures/splay": "0.47.1",
+    "@procedures/sqlite": "0.47.1",
+    "@procedures/store": "0.47.1",
+    "@procedures/systems": "0.47.1",
+    "@procedures/tailscale": "0.47.1",
+    "@procedures/vite": "0.47.1",
+    "@procedures/weather": "0.47.1",
     "@types/node": "^22.0.0",
     "fast-check": "^4.10.2",
     "typescript": "^7.0.2",
@@ -116,7 +116,7 @@
   },
   "scripts": {
     "build": "tsc -b && node dist/manifest-build.js",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc --noEmit && tsc -p tsconfig.test.json",
     "clean": "rm -rf dist .tsbuildinfo",
     "test": "vitest run",
     "test:watch": "vitest",

package/src/bin.ts

@@ -7,8 +7,14 @@
  *
  * The bin owns its process: the runner of each command owns the signals, and it ends the process
  * with the exit code of the command (CLI-26).
+ *
+ * This file enables the compile cache first (roadmap O90). Node.js loads each static import before
+ * the first statement, so the CLI loads with a dynamic import after the cache starts.
  */
 
-import { main } from "./cli.js";
+import { enableCompileCache } from "./compile-cache.js";
+
+enableCompileCache();
 
+const { main } = await import("./cli.js");
 await main(process.argv.slice(2), { ownsProcess: true });

package/src/cli.ts

@@ -16,7 +16,7 @@ import { fieldsOf, generateHelp, resultFieldsOf, type CLIMeta, type CommandLike
 import { readFreshManifest, writeManifest, type ManifestCommand } from "./manifest.js";
 import { askMissing, canAsk, missingFields, processTerminal, terminalAsker, type Asker, type Terminal } from "./ask.js";
 import { formatOutput, type OutputFormat, type Print } from "./format.js";
-import { loadEcosystemRegistry } from "./ecosystem.js";
+import { createLazyEcosystemRegistry, indexOfCommands, loadEcosystemRegistry, packageIndexOf } from "./ecosystem.js";
 import { startServerMode, parsePort, parseTransport } from "./server-mode.js";
 import { connectCliServer } from "./client-mode.js";
 import type { ColdCommand, CommandRun } from "./command.js";
@@ -202,6 +202,37 @@ export async function initCli(verbose = false, fsRoot?: string): Promise<CliCont
   return { client, procedures, registry, verbose, ...(ecosystem.fsRoot !== undefined ? { fsRoot: ecosystem.fsRoot } : {}) };
 }
 
+/**
+ * This function makes the context of a run from a fresh manifest (roadmap O93). Its registry is
+ * lazy: it has the core procedures at once, and a call loads only the packages that the manifest
+ * names for its path. A list, the help of the registry and `procedure.list` load each package
+ * first (`loadAll()`). `procedures` gives the procedures that have loaded at the time of the read.
+ * A root of the files (`--fs-root`) needs each procedure, so `run()` then uses `initCli()`.
+ */
+export async function initLazyCli(verbose: boolean, commands: readonly ManifestCommand[]): Promise<CliContext> {
+  const { Client, LocalTransport } = await import("@procedures/client");
+  const registry = createLazyEcosystemRegistry(indexOfCommands(commands), verbose, true);
+  const transport = new LocalTransport({ registry });
+  const client = new Client({ transport }).useRegistry(registry);
+  return {
+    client,
+    get procedures(): AnyProcedure[] {
+      return registry.getAll();
+    },
+    registry,
+    verbose,
+  };
+}
+
+/**
+ * The procedure of a command in the context of a run. A lazy registry loads the packages of the
+ * path first (roadmap O93).
+ */
+async function procedureOfCommand(runtime: CliContext, path: readonly string[]): Promise<AnyProcedure | undefined> {
+  if (runtime.registry?.lazy) return runtime.registry.resolve([...path]);
+  return findProcedure(runtime.procedures, path);
+}
+
 /**
  * Execute a single command given argv tokens.
  * Reusable by both CLI entry point and REPL.
@@ -434,7 +465,14 @@ export async function executeArgs(
     fail(`Error: ${messageOf(error)}`);
     return;
   }
-  const target = findProcedure(runtime.procedures, path);
+  let target: AnyProcedure | undefined;
+  try {
+    target = await procedureOfCommand(runtime, path);
+  } catch (error) {
+    // A package of the path did not load: the error has the load error
+    fail(`Error: ${messageOf(error)}`);
+    return;
+  }
   if (!target) {
     fail(`Unknown command: mark ${path.join(" ")}`, "Run 'mark --help' for available commands.");
     return;
@@ -755,7 +793,9 @@ async function run(argv: string[], options: RunCliOptions = {}): Promise<void> {
   // server do not load them (roadmap 1.3)
   const manifest = readFreshManifest();
   if (manifest) {
-    await executeArgs(argv, { commands: manifest.commands, verbose, fsRoot, load: () => initCli(verbose, fsRoot) }, execute);
+    // A call loads only the packages of its path (roadmap O93). A root of the files needs each procedure.
+    const load = fsRoot === undefined ? () => initLazyCli(verbose, manifest.commands) : () => initCli(verbose, fsRoot);
+    await executeArgs(argv, { commands: manifest.commands, verbose, fsRoot, load }, execute);
     return;
   }
 
@@ -763,7 +803,7 @@ async function run(argv: string[], options: RunCliOptions = {}): Promise<void> {
   // write the manifest for the next run. A failure to write costs only time.
   const ctx = await initCli(verbose, fsRoot);
   try {
-    await writeManifest(ctx.procedures);
+    await writeManifest(ctx.procedures, packageIndexOf(ctx.registry));
   } catch (error) {
     if (verbose) {
       print.warning(`mark: the manifest was not written: ${error instanceof Error ? error.message : String(error)}`);

package/src/compile-cache.ts

@@ -0,0 +1,51 @@
+/**
+ * The compile cache of Node.js for the `mark` executable (roadmap O90).
+ *
+ * With the cache, a run of `mark` reads the compiled code of its modules from a folder and does not
+ * compile them again. In CI, one `mark` call took 1019 ms with no cache and 754 ms with a warm cache.
+ * The first run after an install or a change of a file writes the cache, and costs 174 ms more.
+ *
+ * The folder is in the cache folder of the user, so a reboot keeps it and other users do not share it.
+ * `NODE_COMPILE_CACHE` replaces the folder, and `NODE_DISABLE_COMPILE_CACHE=1` turns the cache off.
+ */
+
+import module from "node:module";
+import { homedir } from "node:os";
+import * as path from "node:path";
+
+/** The part of `node:module` that this module uses. A test gives its own. */
+export interface CompileCacheApi {
+  readonly enableCompileCache?: ((dir?: string) => { status: number; message?: string; directory?: string }) | undefined;
+}
+
+/**
+ * This function gives the folder of the compile cache of `mark` for a platform: the cache folder of
+ * the user, then `mark/compile-cache`. Linux uses `XDG_CACHE_HOME` or `~/.cache`, macOS uses
+ * `~/Library/Caches`, and Windows uses `LOCALAPPDATA`.
+ */
+export function compileCacheDir(platform: NodeJS.Platform = process.platform, env: NodeJS.ProcessEnv = process.env, home: string = homedir()): string {
+  const join = platform === "win32" ? path.win32.join : path.posix.join;
+  const base =
+    platform === "win32"
+      ? (env["LOCALAPPDATA"] ?? path.win32.join(home, "AppData", "Local"))
+      : platform === "darwin"
+        ? path.posix.join(home, "Library", "Caches")
+        : env["XDG_CACHE_HOME"] !== undefined && path.posix.isAbsolute(env["XDG_CACHE_HOME"])
+          ? env["XDG_CACHE_HOME"]
+          : path.posix.join(home, ".cache");
+  return join(base, "mark", "compile-cache");
+}
+
+/**
+ * This function enables the compile cache in the folder of `compileCacheDir()`. It gives the result
+ * of Node.js, or `undefined` when this Node.js has no compile cache (before 22.1). It never throws:
+ * a folder that cannot be written gives the status `FAILED`, and `mark` runs with no cache.
+ */
+export function enableCompileCache(api: CompileCacheApi = module, dir: () => string = compileCacheDir): ReturnType<NonNullable<CompileCacheApi["enableCompileCache"]>> | undefined {
+  if (typeof api.enableCompileCache !== "function") return undefined;
+  try {
+    return api.enableCompileCache(dir());
+  } catch {
+    return undefined;
+  }
+}

package/src/ecosystem.ts

@@ -19,6 +19,7 @@ import {
   PROCEDURE_REGISTRY,
   allCoreProcedures,
   clientModule,
+  createLazyRegistry,
   createRegistry,
   defineModule,
   pathToKey,
@@ -40,7 +41,8 @@ interface PackageJson {
   exports?: Record<string, unknown>;
 }
 
-interface DiscoveredPackage {
+/** A workspace package that declares `client.procedures`. */
+export interface DiscoveredPackage {
   name: string;
   path: string;
   proceduresPath: string;
@@ -205,10 +207,18 @@ export function listEcosystemProcedurePackages(): Array<{ name: string; path: st
 /** The core procedures that `mark` serves: all of them, also the ones that the core import does not register. */
 const allCoreModule: ProcedureModule = defineModule("@procedures/client (all core procedures)", allCoreProcedures);
 
+/**
+ * The index of the packages of a registry (roadmap O93): the key of each path and the names of
+ * the packages that give it, in the order of the eager load. A core procedure has no package.
+ */
+export type PackageIndex = Record<string, string[]>;
+
 /** The registry of `mark` and the names of the packages that it holds. */
 export interface EcosystemRegistry {
   registry: ProcedureRegistry;
   loaded: string[];
+  /** The packages of each path that a package gives. */
+  index: PackageIndex;
   /** The absolute path of the root of the files (`--fs-root`), or undefined. */
   fsRoot?: string | undefined;
   /** The keys of the procedures that the root refuses, or undefined without a root. */
@@ -248,6 +258,12 @@ async function confineRoot(
   return { root: folder, refused };
 }
 
+/**
+ * The end of the last diff of the global registry. The lazy registry can load two packages at
+ * the same time: the diffs of the packages of the old kind go one after the other.
+ */
+let globalDiffs: Promise<unknown> = Promise.resolve();
+
 /**
  * The module of a package: its `./module` entry (it registers nothing), or else the procedures
  * that importing its procedures file adds to the global registry (a package of the old kind).
@@ -262,10 +278,90 @@ async function moduleOfPackage(pkg: DiscoveredPackage): Promise<ProcedureModule
   }
   const proceduresFile = path.join(pkg.path, pkg.proceduresPath);
   if (!fs.existsSync(proceduresFile)) return undefined;
-  const before = new Set(PROCEDURE_REGISTRY.getAll().map((procedure) => pathToKey(procedure.path)));
-  await import(pathToFileURL(proceduresFile).href);
-  const added: AnyProcedure[] = PROCEDURE_REGISTRY.getAll().filter((procedure) => !before.has(pathToKey(procedure.path)));
-  return { name: pkg.name, procedures: added };
+  const diff = globalDiffs.then(async (): Promise<ProcedureModule> => {
+    const before = new Set(PROCEDURE_REGISTRY.getAll().map((procedure) => pathToKey(procedure.path)));
+    await import(pathToFileURL(proceduresFile).href);
+    const added: AnyProcedure[] = PROCEDURE_REGISTRY.getAll().filter((procedure) => !before.has(pathToKey(procedure.path)));
+    return { name: pkg.name, procedures: added };
+  });
+  globalDiffs = diff.catch(() => undefined);
+  return diff;
+}
+
+/** The keys of the procedures of a registry. */
+function keysOf(registry: ProcedureRegistry): Set<string> {
+  return new Set(registry.getAll().map((procedure) => pathToKey(procedure.path)));
+}
+
+/**
+ * This function adds the paths of a package to the index. The paths of its own procedures name it.
+ * A path that only a module that it requires gives names the first package that registered it.
+ */
+function indexPackage(index: PackageIndex, fallback: Map<string, string>, name: string, module: ProcedureModule, before: ReadonlySet<string>, after: ReadonlySet<string>): void {
+  for (const procedure of module.procedures) {
+    const key = pathToKey(procedure.path);
+    // A procedure that did not register (a conflict stopped the package) is not in the index
+    if (!after.has(key)) continue;
+    const names = (index[key] ??= []);
+    if (!names.includes(name)) names.push(name);
+  }
+  for (const key of after) if (!before.has(key) && !fallback.has(key)) fallback.set(key, name);
+}
+
+/** The index of a registry that `loadEcosystemRegistry()` made, by registry. */
+const INDEXES = new WeakMap<ProcedureRegistry, PackageIndex>();
+
+/** This function gives the index of the packages of an eager registry of `mark`, or undefined. */
+export function packageIndexOf(registry: ProcedureRegistry | undefined): PackageIndex | undefined {
+  return registry === undefined ? undefined : INDEXES.get(registry);
+}
+
+/**
+ * This function gives the index of the commands of a manifest: the key of each path that a
+ * package gives, and the names of the packages.
+ */
+export function indexOfCommands(commands: ReadonlyArray<{ path: readonly string[]; packages?: readonly string[] | undefined }>): PackageIndex {
+  const index: PackageIndex = {};
+  for (const command of commands) {
+    if (command.packages !== undefined && command.packages.length > 0) index[pathToKey(command.path)] = [...command.packages];
+  }
+  return index;
+}
+
+/**
+ * The lazy registry of `mark` (roadmap O93). It has all the core procedures at once. A call of a
+ * path loads only the packages that the index names for it. `loadAll()` loads each package in the
+ * order of `discoverFromEcosystem()`, as `loadEcosystemRegistry()` does. A package that fails to
+ * load gives the warning of the eager load.
+ */
+export function createLazyEcosystemRegistry(
+  index: Readonly<Record<string, readonly string[]>>,
+  verbose = false,
+  warn = true,
+  discovered: readonly DiscoveredPackage[] = discoverFromEcosystem(),
+): ProcedureRegistry {
+  const byName = new Map(discovered.map((pkg) => [pkg.name, pkg]));
+  return createLazyRegistry({
+    modules: [allCoreModule],
+    index,
+    packages: discovered.map((pkg) => pkg.name),
+    load: async (name) => {
+      const pkg = byName.get(name);
+      if (!pkg) return undefined;
+      try {
+        const module = await moduleOfPackage(pkg);
+        if (!module && verbose) console.warn(`Procedures file not found (build the package): ${path.join(pkg.path, pkg.proceduresPath)}`);
+        if (module && verbose) console.log(`Loaded procedures from: ${pkg.name}`);
+        return module;
+      } catch (error) {
+        if (verbose && error instanceof Error && error.stack) console.warn(error.stack);
+        throw error;
+      }
+    },
+    warn: (message) => {
+      if (warn) console.warn(`mark: ${message}`);
+    },
+  });
 }
 
 /**
@@ -278,6 +374,8 @@ async function moduleOfPackage(pkg: DiscoveredPackage): Promise<ProcedureModule
 export async function loadEcosystemRegistry(verbose = false, warn = true, options: EcosystemOptions = {}): Promise<EcosystemRegistry> {
   const registry = createRegistry(allCoreModule);
   const loaded: string[] = [];
+  const index: PackageIndex = {};
+  const fallback = new Map<string, string>();
   const discovered = discoverFromEcosystem();
   for (const pkg of discovered) {
     try {
@@ -286,7 +384,13 @@ export async function loadEcosystemRegistry(verbose = false, warn = true, option
         if (verbose) console.warn(`Procedures file not found (build the package): ${path.join(pkg.path, pkg.proceduresPath)}`);
         continue;
       }
-      registerModules(registry, [module]);
+      const before = keysOf(registry);
+      try {
+        registerModules(registry, [module]);
+      } finally {
+        // The paths that the package registered before an error count too: the lazy load registers them
+        indexPackage(index, fallback, pkg.name, module, before, keysOf(registry));
+      }
       loaded.push(pkg.name);
       if (verbose) console.log(`Loaded procedures from: ${pkg.name}`);
     } catch (error) {
@@ -295,8 +399,11 @@ export async function loadEcosystemRegistry(verbose = false, warn = true, option
       if (verbose && error instanceof Error && error.stack) console.warn(error.stack);
     }
   }
-  if (options.fsRoot === undefined) return { registry, loaded };
+  // A path that only a required module gives names the first package that registered it
+  for (const [key, name] of fallback) index[key] ??= [name];
+  INDEXES.set(registry, index);
+  if (options.fsRoot === undefined) return { registry, loaded, index };
   // After the last package: each procedure of the registry gets the rules of the root
   const { root: fsRoot, refused } = await confineRoot(registry, options.fsRoot, discovered);
-  return { registry, loaded, fsRoot, refusedUnderRoot: refused };
+  return { registry, loaded, index, fsRoot, refusedUnderRoot: refused };
 }

package/src/manifest-build.ts

@@ -7,6 +7,7 @@
 import { loadEcosystemRegistry } from "./ecosystem.js";
 import { manifestPath, writeManifest } from "./manifest.js";
 
-const { registry, loaded } = await loadEcosystemRegistry(false, false);
-const manifest = await writeManifest(registry.getAll());
+const { registry, loaded, index } = await loadEcosystemRegistry(false, false);
+// Each command records the packages of its path: the lazy registry of a run loads only those (roadmap O93)
+const manifest = await writeManifest(registry.getAll(), index);
 console.log(`mark: ${manifestPath()} has ${manifest.commands.length} commands from ${loaded.length} packages`);

package/src/manifest.ts

@@ -17,16 +17,16 @@ import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { describeProcedureEntry, jsonSchemaOf, type AnyProcedure, type ProcedureEntry } from "@procedures/client";
+import { describeProcedureEntry, jsonSchemaOf, pathToKey, type AnyProcedure, type ProcedureEntry } from "@procedures/client";
 import { writeFileAtomicSync } from "@procedures/fs/files";
 import { discoverFromEcosystem, findWorkspaceRoot } from "./ecosystem.js";
 import { extractSchemaFields, resultFieldsOfSchema, type CLIMeta, type SchemaFieldInfo } from "./parse.js";
 
 /**
  * The format of the manifest. A change of the format makes old manifests stale.
- * Version 2 adds `resultFields`.
+ * Version 2 adds `resultFields`. Version 3 adds `packages` (roadmap O93).
  */
-export const MANIFEST_VERSION = 2;
+export const MANIFEST_VERSION = 3;
 
 /** One command of the manifest */
 export interface ManifestCommand {
@@ -39,6 +39,11 @@ export interface ManifestCommand {
   inputSchema: unknown;
   /** The fields of the result, for the help (none when the result is not an object) */
   resultFields: SchemaFieldInfo[];
+  /**
+   * The packages that give the procedure, in the order of the eager load (roadmap O93). A core
+   * procedure has none. The lazy registry loads only these packages for a call of the path.
+   */
+  packages: string[];
 }
 
 export interface Manifest {
@@ -111,8 +116,14 @@ function cliMetadata(entry: ProcedureEntry): CLIMeta {
   return result;
 }
 
-/** The commands of the manifest, from the procedures of the registry */
-export async function commandsOf(procedures: readonly AnyProcedure[]): Promise<ManifestCommand[]> {
+/**
+ * The commands of the manifest, from the procedures of the registry. The index gives the packages
+ * of each path (`packageIndexOf()`). Without it, each command has no package.
+ */
+export async function commandsOf(
+  procedures: readonly AnyProcedure[],
+  index: Readonly<Record<string, readonly string[]>> = {},
+): Promise<ManifestCommand[]> {
   return procedures.map((procedure) => {
     // One JSON Schema for each command: the fields come from it too (roadmap 2.1). The schema and
     // the CLI metadata come from the one manifest type of the core (roadmap R17).
@@ -124,6 +135,7 @@ export async function commandsOf(procedures: readonly AnyProcedure[]): Promise<M
       fields: extractSchemaFields(inputSchema),
       inputSchema,
       resultFields: resultFieldsOfSchema(procedure.output),
+      packages: [...(index[pathToKey(procedure.path)] ?? [])],
     };
   });
 }
@@ -133,13 +145,20 @@ function toJson(manifest: Manifest): string {
   return JSON.stringify(manifest, (_key, value: unknown) => (typeof value === "bigint" ? value.toString() : value), 1);
 }
 
-/** Write the manifest of these procedures for the current fingerprint (a temporary file, then a rename) */
-export async function writeManifest(procedures: readonly AnyProcedure[], file: string = manifestPath()): Promise<Manifest> {
+/**
+ * Write the manifest of these procedures for the current fingerprint (a temporary file, then a
+ * rename). The index gives the packages of each path.
+ */
+export async function writeManifest(
+  procedures: readonly AnyProcedure[],
+  index: Readonly<Record<string, readonly string[]>> = {},
+  file: string = manifestPath(),
+): Promise<Manifest> {
   const manifest: Manifest = {
     version: MANIFEST_VERSION,
     fingerprint: computeFingerprint(),
     generatedAt: new Date().toISOString(),
-    commands: await commandsOf(procedures),
+    commands: await commandsOf(procedures, index),
   };
   // writeFileAtomicSync flushes the file, tries the rename again on Windows and removes the temporary file after a failure
   writeFileAtomicSync(file, toJson(manifest));

package/src/print.ts

@@ -7,7 +7,16 @@
 
 import chalk from "chalk";
 import ora from "ora";
-import Table from "cli-table3";
+import { createRequire } from "node:module";
+import type TableClass from "cli-table3";
+
+/**
+ * This function gives the table class of `cli-table3`. The first table loads the package, not the
+ * start of `mark`: a call that prints no table does not load it (roadmap O93).
+ */
+function tableClass(): typeof TableClass {
+  return createRequire(import.meta.url)("cli-table3") as typeof TableClass;
+}
 
 /**
  * Spinner interface (compatible with existing code)
@@ -71,6 +80,7 @@ export const print = {
     const [headers, ...rows] = data;
     if (!headers) return;
 
+    const Table = tableClass();
     const table = new Table({
       head: headers.map((h) => chalk.bold(h)),
       style: {