@procedures/client 0.46.0 → 0.47.2

package/src/procedures/define-procedure.ts

@@ -26,7 +26,7 @@
  */
 
 import { defineProcedure, validateProcedure } from "./define.js";
-import { PROCEDURE_REGISTRY, assertValidPath } from "./registry.js";
+import { PROCEDURE_REGISTRY, assertValidPath, loadAllIn, resolveIn } from "./registry.js";
 import type {
   Procedure,
   ProcedurePath,
@@ -36,13 +36,14 @@ import type {
   ProcedureRegistryLike,
   Effects,
 } from "./types.js";
-import { z } from "zod";
+import * as z from "zod";
 import { anySchema } from "./core/schemas.js";
 import { keyToPath, pathToKey } from "./types.js";
 import {
   createRefScope,
   isAnyProcedureRef,
   markDataDriven,
+  preloadRefPaths,
   rawInputRule,
   RUNS_REFS_TAG,
 } from "./ref.js";
@@ -211,7 +212,11 @@ function createAggregationHandler(
     const scope = createRefScope();
     scope.outputs.set("input", input);
     const executor = <TIn, TOut>(path: ProcedurePath, value: TIn): Promise<TOut> => ctx.client.call<TIn, TOut>(path, value);
-    const options = { scope, rawInput: rawInputRule(ctx.registry ?? PROCEDURE_REGISTRY), onRef: ctx.onRef };
+    const registry = ctx.registry ?? PROCEDURE_REGISTRY;
+    // A lazy registry loads the paths of the body before the raw-input rule reads them (roadmap O93)
+    const preload = preloadRefPaths(registry, aggregation);
+    if (preload) await preload;
+    const options = { scope, rawInput: rawInputRule(registry), onRef: ctx.onRef };
     if (isAnyProcedureRef(aggregation)) {
       return runProgram(aggregation, { ...options, executor });
     }
@@ -327,7 +332,8 @@ export const defineProcedureProcedure: Procedure<
     }
 
     const pathKey = pathToKey(path);
-    const existing = registry.get(path);
+    // A lazy registry loads the package of the path first: a procedure of a package is not new (roadmap O93)
+    const existing = await resolveIn(registry, path);
     // A procedure outside the expose rule of the host is not the caller's to replace (R17)
     if (existing && ctx?.expose && !ctx.expose(path)) {
       throw new InvocationError(
@@ -473,7 +479,8 @@ export const getProcedureProcedure: Procedure<
   },
   handler: async (input: ProcedureGetInput, ctx?: ProcedureContext) => {
     const path = typeof input.path === "string" ? keyToPath(input.path) : input.path;
-    const procedure = (ctx?.registry ?? PROCEDURE_REGISTRY).get(path);
+    // A lazy registry loads the package of the path first (roadmap O93)
+    const procedure = await resolveIn(ctx?.registry ?? PROCEDURE_REGISTRY, path);
     // A procedure outside the expose rule of the host is not found (R17)
     if (!procedure || (ctx?.expose && !ctx.expose(procedure.path))) {
       return { found: false as const };
@@ -513,7 +520,10 @@ export const listProceduresProcedure: Procedure<
     output: "json",
   },
   handler: async (input: ProcedureListInput, ctx?: ProcedureContext) => {
-    let all = (ctx?.registry ?? PROCEDURE_REGISTRY).getAll();
+    const registry = ctx?.registry ?? PROCEDURE_REGISTRY;
+    // A lazy registry loads each package first: the list has each procedure (roadmap O93)
+    await loadAllIn(registry);
+    let all = registry.getAll();
     // Only the procedures that the host exposes (R17)
     if (ctx?.expose) all = all.filter((procedure) => ctx.expose!(procedure.path));
     if (input.runtime) all = all.filter(isRuntimeDefined);
@@ -539,11 +549,15 @@ export const manifestProcedure: Procedure<{ namespace?: string | undefined }, Pr
     shorts: { namespace: "n" },
     output: "json",
   },
-  handler: async (input: { namespace?: string | undefined }, ctx?: ProcedureContext) =>
-    describeRegistry(ctx?.registry ?? PROCEDURE_REGISTRY, {
+  handler: async (input: { namespace?: string | undefined }, ctx?: ProcedureContext) => {
+    const registry = ctx?.registry ?? PROCEDURE_REGISTRY;
+    // A lazy registry loads each package first: the manifest has each procedure (roadmap O93)
+    await loadAllIn(registry);
+    return describeRegistry(registry, {
       ...(ctx?.expose ? { expose: ctx.expose } : {}),
       ...(input.namespace ? { include: (procedure: AnyProcedure) => procedure.path[0] === input.namespace } : {}),
-    }),
+    });
+  },
 });
 
 /**
@@ -568,7 +582,8 @@ export const deleteProcedureProcedure: Procedure<
     if (ctx?.expose && !ctx.expose(input.path)) {
       return { deleted: false };
     }
-    const existing = registry.get(input.path);
+    // A lazy registry loads the package of the path first (roadmap O93)
+    const existing = await resolveIn(registry, input.path);
     if (!existing) {
       return { deleted: false };
     }

package/src/procedures/index.ts

@@ -114,7 +114,8 @@ export { NARROWING_METADATA_KEY, NARROWING_HEADER, narrowingOf, narrowWithin, ad
 export type { NarrowingNote, WireNarrowing, NarrowedCapability } from "./narrowing.js";
 
 // Registry
-export { ProcedureRegistry, RegistryError, PROCEDURE_REGISTRY, assertValidPath } from "./registry.js";
+export { ProcedureRegistry, RegistryError, PROCEDURE_REGISTRY, assertValidPath, resolveIn, loadAllIn } from "./registry.js";
+export type { RegistryResolver, ProcedureRegistryOptions, ResolvingRegistry } from "./registry.js";
 
 // Definition helpers
 export {
@@ -223,9 +224,10 @@ export {
   moduleClosure,
   registerModules,
   createRegistry,
+  createLazyRegistry,
   registerClientProcedures,
 } from "./module.js";
-export type { ModuleInput, PackageDefinition } from "./module.js";
+export type { ModuleInput, PackageDefinition, LazyRegistryOptions } from "./module.js";
 // One call for a registry of some modules, `invokePath` and `outputValue`
 export { callerOf } from "./caller.js";
 export type { Caller, CallerOptions } from "./caller.js";
@@ -262,6 +264,7 @@ export {
   RAW_INPUT_TAG,
   takesRawInput,
   rawInputRule,
+  preloadRefPaths,
   MAX_DATA_DEPTH,
   LITERAL_KEY,
   isLiteral,
@@ -338,6 +341,8 @@ export {
   // Every core procedure (math, comparison, string, type, object, array, meta too). Not registered by default.
   allCoreProcedures,
   allCoreModules,
+  // Only the math procedures: a bundle that imports only these gets no other core procedure (roadmap O95)
+  mathProcedures,
   chainProcedure,
   traceProcedure,
   type TraceRow,

package/src/procedures/invoke.ts

@@ -440,6 +440,13 @@ export async function invokeProcedure<TOutput = unknown>(
   return dispatch(0, invocation, options) as Promise<ProcedureOutput<TOutput>>;
 }
 
+/** True when the declared effects of a procedure read or write the registry. */
+function usesRegistry(procedure: AnyProcedure): boolean {
+  const effects = (procedure.metadata as { effects?: { reads?: unknown; writes?: unknown } } | undefined)?.effects;
+  const names = (list: unknown): boolean => Array.isArray(list) && list.includes("registry");
+  return names(effects?.reads) || names(effects?.writes);
+}
+
 /** The end of the chain: the validation, the context, the handler and the output. */
 async function runInvocation<TOutput>(invocation: Invocation, options: InvokeOptions): Promise<ProcedureOutput<TOutput>> {
   const { procedure, path, input } = invocation;
@@ -472,6 +479,11 @@ async function runInvocation<TOutput>(invocation: Invocation, options: InvokeOpt
     data = parsed.value === input ? input : withScope(parsed.value, scopeOf(input));
   }
 
+  // A procedure that declares a read or a write of the registry sees each procedure of a lazy
+  // registry (roadmap O93). An eager registry does not wait here.
+  const registry = options.registry;
+  if (registry?.lazy && usesRegistry(procedure)) await registry.loadAll();
+
   // The handler starts here, before the first await (the site's trace depends on it)
   const result: unknown = await handler(data, createProcedureContext(procedure, { ...options, capability: invocation.capability }, invocation));
   // The output filter examines only what leaves the host
@@ -508,7 +520,9 @@ export async function invokePath<TOutput = unknown>(
   input: unknown,
   options: InvokeOptions = {},
 ): Promise<ProcedureOutput<TOutput>> {
-  const procedure = (options.registry ?? PROCEDURE_REGISTRY).get(path);
+  const registry = options.registry ?? PROCEDURE_REGISTRY;
+  // A miss of a lazy registry loads the packages of the path (roadmap O93). A hit does not wait.
+  const procedure = registry.get(path) ?? (registry.lazy ? await registry.resolve(path) : undefined);
   if (!procedure) {
     throw new InvocationError("NOT_FOUND", `Procedure not found: ${pathToKey(path)}`, path);
   }

package/src/procedures/module.ts

@@ -18,10 +18,10 @@
  * rule of a server all use the registry of the invocation (`ctx.registry`).
  */
 
-import { PROCEDURE_REGISTRY, ProcedureRegistry, RegistryError } from "./registry.js";
+import { PROCEDURE_REGISTRY, ProcedureRegistry, RegistryError, type RegistryResolver } from "./registry.js";
 import { coreProcedures } from "./core/index.js";
 import { metaProcedures as definitionProcedures } from "./define-procedure.js";
-import { pathToKey, type AnyProcedure, type ProcedureModule, type RegistrationOptions } from "./types.js";
+import { pathToKey, type AnyProcedure, type ProcedureModule, type ProcedurePath, type RegistrationOptions } from "./types.js";
 
 /**
  * The procedures of `@procedures/client`: the control flow (`client.chain`, `client.map` and the
@@ -139,6 +139,117 @@ export function createRegistry(...modules: ModuleInput[]): ProcedureRegistry {
   return registerModules(new ProcedureRegistry(), [clientModule, ...modules]);
 }
 
+/** The options of `createLazyRegistry()` (roadmap O93). */
+export interface LazyRegistryOptions {
+  /** The modules that the registry registers at once, after `clientModule`: the core procedures. */
+  readonly modules?: readonly ModuleInput[] | undefined;
+  /**
+   * The index: the key of each path (`pathToKey()`) and the names of the packages that give it.
+   * Two packages can give one path.
+   */
+  readonly index: Readonly<Record<string, readonly string[]>>;
+  /** This function gives the module of a package, or undefined for a package without a build. */
+  readonly load: (name: string) => Promise<ProcedureModule | undefined>;
+  /**
+   * The names of all packages, in the order of the eager load. `loadAll()` loads them in this
+   * order. The default is the names of the index.
+   */
+  readonly packages?: readonly string[] | undefined;
+  /** This function gets each warning. The default is `console.warn`. */
+  readonly warn?: ((message: string) => void) | undefined;
+}
+
+/** The first line of the message of an error. */
+function firstLine(error: unknown): string {
+  return (error instanceof Error ? error.message : String(error)).split("\n")[0] ?? "";
+}
+
+/**
+ * This function makes a lazy registry (roadmap O93). The registry has the procedures of
+ * `clientModule` and of `options.modules` at once. A miss of `resolve()` loads only the packages
+ * that the index names for the path.
+ *
+ * - Concurrent resolves of one package start one load.
+ * - A path that is not in the index loads each package, with one warning for each path.
+ * - A package that did not load gives a warning. The resolve of a path that is still missing
+ *   then rejects with a `RegistryError`, with the load error as its `cause`. A later resolve tries
+ *   that package again.
+ * - The registration goes through `registerModules()`: the modules that a module requires come
+ *   with it, and the same handler from two modules registers one time.
+ * - `loadAll()` loads each package in the order of `options.packages`.
+ */
+export function createLazyRegistry(options: LazyRegistryOptions): ProcedureRegistry {
+  const warn = options.warn ?? ((message: string): void => console.warn(message));
+  const packages = options.packages ?? [...new Set(Object.values(options.index).flat())];
+  const loaded = new Set<string>();
+  const inFlight = new Map<string, Promise<void>>();
+  const warnedPaths = new Set<string>();
+
+  function loadPackage(name: string): Promise<void> {
+    if (loaded.has(name)) return Promise.resolve();
+    const current = inFlight.get(name);
+    if (current) return current;
+    const started = (async (): Promise<void> => {
+      const module = await options.load(name);
+      if (module) registerModules(registry, [module]);
+    })();
+    inFlight.set(name, started);
+    // A failure is not recorded as a load: the next resolve tries the package again
+    started.then(
+      () => {
+        loaded.add(name);
+        inFlight.delete(name);
+      },
+      (error: unknown) => {
+        inFlight.delete(name);
+        warn(`the procedures of ${name} did not load: ${firstLine(error)}`);
+      },
+    );
+    return started;
+  }
+
+  const resolver: RegistryResolver = {
+    async resolve(path: ProcedurePath): Promise<void> {
+      const key = pathToKey(path);
+      const named = Object.hasOwn(options.index, key) ? options.index[key] : undefined;
+      let targets: readonly string[];
+      if (named !== undefined && named.length > 0) {
+        targets = named;
+      } else {
+        if (!warnedPaths.has(key)) {
+          warnedPaths.add(key);
+          warn(`the index has no package for ${key}: each package loads`);
+        }
+        targets = packages;
+      }
+      let failure: { name: string; error: unknown } | undefined;
+      // One package after the other, in the order of the index: the order of the eager load
+      for (const name of targets) {
+        try {
+          await loadPackage(name);
+        } catch (error) {
+          failure ??= { name, error };
+        }
+      }
+      if (failure === undefined || registry.has(path)) return;
+      const cause = failure.error instanceof Error ? failure.error : new Error(String(failure.error));
+      throw new RegistryError(`The procedure ${key} did not load: the package ${failure.name} did not load: ${firstLine(cause)}`, path, cause);
+    },
+    async loadAll(): Promise<void> {
+      for (const name of packages) {
+        try {
+          await loadPackage(name);
+        } catch {
+          // loadPackage() gave the warning. The other packages still load, as in the eager load.
+        }
+      }
+    },
+  };
+
+  const registry = new ProcedureRegistry({ resolver });
+  return registerModules(registry, [clientModule, ...(options.modules ?? [])]);
+}
+
 /**
  * This function registers the procedures of `clientModule` in a registry: the global registry by
  * default. A procedure that the registry has already stays. The `./register` entry of the package

package/src/procedures/ref.ts

@@ -57,7 +57,8 @@
  * ```
  */
 
-import type { ProcedurePath } from "./types.js";
+import { pathToKey, type ProcedurePath } from "./types.js";
+import type { ResolvingRegistry } from "./registry.js";
 
 // =============================================================================
 // Procedure Reference Constants
@@ -854,6 +855,62 @@ export function rawInputRule(
 
 const RAW_INPUT_RULES = new WeakMap<object, (path: ProcedurePath) => boolean>();
 
+/** The `$proc` paths of a value that the registry does not have yet, by key. */
+function missingRefPaths(registry: ResolvingRegistry, value: unknown): ProcedurePath[] {
+  const missing = new Map<string, ProcedurePath>();
+  const seen = new Set<object>();
+  const visit = (node: unknown): void => {
+    if (node === null || typeof node !== "object" || seen.has(node)) return;
+    seen.add(node);
+    if (isLiteral(node)) return;
+    if (Array.isArray(node)) {
+      for (const item of node) visit(item);
+      return;
+    }
+    if (isAnyProcedureRef(node)) {
+      try {
+        const ref = normalizeRef(node);
+        const path: unknown = ref.path;
+        if (Array.isArray(path) && path.length > 0 && path.every((segment) => typeof segment === "string") && registry.get(path) === undefined) {
+          missing.set(pathToKey(path), path);
+        }
+        visit(ref.input);
+      } catch {
+        // The run reports a ref that is not correct
+      }
+      return;
+    }
+    if (!isPlainObject(node)) return;
+    for (const field of Object.values(node)) visit(field);
+  };
+  visit(value);
+  return [...missing.values()];
+}
+
+/**
+ * This function loads the procedures of the `$proc` paths of a value into a lazy registry (roadmap
+ * O93). A run starts it before it reads the raw-input rule, because the rule is sync and reads only
+ * the procedures that have loaded. The function gives undefined, with no wait, for an eager
+ * registry and for a value whose paths the registry has. A package that does not load does not
+ * stop the run: the call of its path reports the error.
+ */
+export function preloadRefPaths(registry: ResolvingRegistry | undefined, value: unknown): Promise<void> | undefined {
+  if (registry?.lazy !== true || registry.resolve === undefined) return undefined;
+  const missing = missingRefPaths(registry, value);
+  if (missing.length === 0) return undefined;
+  const resolve = registry.resolve.bind(registry);
+  return (async (): Promise<void> => {
+    // One path after the other: the order of the registrations does not depend on the time of each load
+    for (const path of missing) {
+      try {
+        await resolve(path);
+      } catch {
+        // The call of the path reports the load error
+      }
+    }
+  })();
+}
+
 // =============================================================================
 // Template Extraction
 // =============================================================================

package/src/procedures/registry.ts

@@ -76,6 +76,60 @@ function samePath(a: ProcedurePath, b: ProcedurePath): boolean {
   return a.length === b.length && a.every((segment, index) => segment === b[index]);
 }
 
+// =============================================================================
+// Lazy Resolution (roadmap O93)
+// =============================================================================
+
+/**
+ * The resolver of a lazy registry: it loads procedures into the registry on demand.
+ * `createLazyRegistry()` gives one. An eager registry has no resolver.
+ */
+export interface RegistryResolver {
+  /**
+   * This method loads the packages that give the path. It rejects when a package did not load.
+   * A later call tries that package again.
+   */
+  resolve(path: ProcedurePath): Promise<void>;
+  /** This method loads each package. A package that did not load gives a warning, not a rejection. */
+  loadAll(): Promise<void>;
+}
+
+/** The options of `new ProcedureRegistry()`. */
+export interface ProcedureRegistryOptions {
+  /**
+   * The resolver of a lazy registry. Without it, the registry is eager: `resolve()` gives what
+   * `get()` gives, and `loadAll()` does nothing.
+   */
+  resolver?: RegistryResolver | undefined;
+}
+
+/** The reads of a registry that `resolveIn()` and `loadAllIn()` use. A lazy registry has all of them. */
+export interface ResolvingRegistry {
+  get(path: ProcedurePath): AnyProcedure | undefined;
+  readonly lazy?: boolean;
+  resolve?(path: ProcedurePath): Promise<AnyProcedure | undefined>;
+  loadAll?(): Promise<void>;
+}
+
+/**
+ * This function gives the procedure at a path of a registry. On a miss, a lazy registry loads the
+ * packages of the path. An eager registry gives what `get()` gives.
+ */
+export async function resolveIn(registry: ResolvingRegistry, path: ProcedurePath): Promise<AnyProcedure | undefined> {
+  const found = registry.get(path);
+  if (found !== undefined || registry.lazy !== true || registry.resolve === undefined) return found;
+  return registry.resolve(path);
+}
+
+/**
+ * This function loads each package of a lazy registry. A procedure that enumerates its registry
+ * (`procedure.list`, `procedure.manifest`, `mcp.listTools`) starts it first. On an eager
+ * registry, it does nothing.
+ */
+export async function loadAllIn(registry: Pick<ResolvingRegistry, "lazy" | "loadAll">): Promise<void> {
+  if (registry.lazy === true && registry.loadAll !== undefined) await registry.loadAll();
+}
+
 // =============================================================================
 // Procedure Registry
 // =============================================================================
@@ -113,6 +167,17 @@ export class ProcedureRegistry {
   /** Registered module names for debugging */
   private readonly registeredModules = new Set<string>();
 
+  /** The resolver of a lazy registry, or undefined for an eager registry (roadmap O93) */
+  private readonly resolver: RegistryResolver | undefined;
+
+  /**
+   * This constructor makes an eager registry. With `options.resolver`, the registry is lazy: a
+   * miss of `resolve()` loads the packages of the path.
+   */
+  constructor(options: ProcedureRegistryOptions = {}) {
+    this.resolver = options.resolver;
+  }
+
   // ---------------------------------------------------------------------------
   // Registration
   // ---------------------------------------------------------------------------
@@ -278,6 +343,40 @@ export class ProcedureRegistry {
     return this.procedures.size;
   }
 
+  // ---------------------------------------------------------------------------
+  // Lazy Resolution (roadmap O93)
+  // ---------------------------------------------------------------------------
+
+  /**
+   * This property is true for a lazy registry. The sync reads (`get`, `has`, `getAll`,
+   * `getByPrefix`, `size`) of a lazy registry give only the procedures that have loaded.
+   */
+  get lazy(): boolean {
+    return this.resolver !== undefined;
+  }
+
+  /**
+   * This method gives the procedure at a path. A registered path gives its procedure at once. On
+   * a miss, a lazy registry loads the packages of the path first. An eager registry gives undefined.
+   *
+   * @throws RegistryError when the path is still missing and a package of the path did not load.
+   *   The load error is the `cause`.
+   */
+  async resolve(path: ProcedurePath): Promise<AnyProcedure | undefined> {
+    const found = this.get(path);
+    if (found || !this.resolver) return found;
+    await this.resolver.resolve(path);
+    return this.get(path);
+  }
+
+  /**
+   * This method loads each package of a lazy registry. After it, the sync reads give each
+   * procedure. On an eager registry, it does nothing.
+   */
+  async loadAll(): Promise<void> {
+    if (this.resolver) await this.resolver.loadAll();
+  }
+
   /**
    * Get all registered module names.
    */

package/src/procedures/segments.ts

@@ -24,7 +24,8 @@
  * ```
  */
 export function encodeSegment(segment: string): string {
-  return segment.replace(/[%.]/g, (char) => (char === "%" ? "%25" : "%2E"));
+  // Almost each segment has no `.` and no `%`: a test costs less than a replace with a callback (roadmap O90)
+  return /[%.]/.test(segment) ? segment.replace(/[%.]/g, (char) => (char === "%" ? "%25" : "%2E")) : segment;
 }
 
 /**
@@ -39,7 +40,8 @@ export function encodeSegment(segment: string): string {
  * ```
  */
 export function decodeSegment(segment: string): string {
-  return segment.replace(/%(25|2[Ee])/g, (_sequence, code: string) => (code === "25" ? "%" : "."));
+  // Almost each segment has no `%`: a test costs less than a replace with a callback (roadmap O90)
+  return segment.includes("%") ? segment.replace(/%(25|2[Ee])/g, (_sequence, code: string) => (code === "25" ? "%" : ".")) : segment;
 }
 
 /**
@@ -56,7 +58,14 @@ export function decodeSegment(segment: string): string {
 export function segmentsToTopic(segments: readonly string[]): string {
   // A segment that is not a string becomes text as with join(): null and undefined give "" (a
   // caller can check a path that is not valid, for example the compiler)
-  return segments.map((segment: unknown) => encodeSegment(segment === null || segment === undefined ? "" : String(segment))).join(".");
+  // The loop makes no array for each key: a key is made for each step of a call (roadmap O90)
+  let topic = "";
+  for (let index = 0; index < segments.length; index++) {
+    const segment: unknown = segments[index];
+    if (index > 0) topic += ".";
+    topic += encodeSegment(segment === null || segment === undefined ? "" : String(segment));
+  }
+  return topic;
 }
 
 /**

package/src/procedures/types.ts

@@ -442,6 +442,12 @@ export interface ProcedureRegistryLike {
   getAll(): AnyProcedure[];
   register(procedure: AnyProcedure, options?: RegistrationOptions): void;
   unregister(path: ProcedurePath): boolean;
+  /** This property is true for a lazy registry (roadmap O93). Its sync reads give only the procedures that have loaded. */
+  readonly lazy?: boolean;
+  /** This method gives the procedure at a path. A lazy registry loads the packages of the path on a miss. */
+  resolve?(path: ProcedurePath): Promise<AnyProcedure | undefined>;
+  /** This method loads each package of a lazy registry. A procedure that enumerates the registry starts it first. */
+  loadAll?(): Promise<void>;
 }
 
 /**

package/src/server/error-policy.ts

@@ -22,7 +22,8 @@
 
 import type { ProcedurePath } from "../procedures/types.js";
 import { closableUnread } from "../procedures/invoke.js";
-import { isKnownErrorCode } from "../client/errors/registry.js";
+// The codes only: the texts of ERROR_REGISTRY stay out of a bundle of the server (roadmap O95)
+import { isKnownCode as isKnownErrorCode } from "../client/errors/known-codes.js";
 import { errorCodeOf } from "../protocol.js";
 import { errorResponse, realErrorOf } from "./error-response.js";
 import { methodToPath } from "./method.js";

package/src/server/face-rules.ts

@@ -73,7 +73,7 @@ function exposeRule(expose: NonNullable<FaceRulesOptions["expose"]>): (path: Pro
  *
  * @example
  * ```typescript
- * const rules = faceRules({ narrowing: { effects: { writes: [] } }, expose: ["graphapi.*"] }, policy, "read");
+ * const rules = faceRules({ narrowing: { effects: { writes: [] } }, expose: ["api.*"] }, policy, "read");
  * const handler = { ...inner, handle: (request) => inner.handle(rules.apply(request)) };
  * ```
  */

package/src/server/host-procedures.ts

@@ -9,7 +9,7 @@
  * checks that have no token.
  */
 
-import { z } from "zod";
+import * as z from "zod";
 import { createProcedure } from "../procedures/define.js";
 import { PURE_EFFECTS } from "../procedures/effects.js";
 import type { AnyProcedure } from "../procedures/types.js";
@@ -69,13 +69,17 @@ export function hostProcedures(source: HostSource): AnyProcedure[] {
     .input(z.object({}))
     .output(healthOutput)
     .meta({ description: "The health of the host: its state, its uptime and its calls in flight", effects: PURE_EFFECTS })
-    .handler(async () => ({
-      status: source.server.stopping ? ("stopping" as const) : ("ok" as const),
-      uptimeMs: Date.now() - source.startedAt,
-      procedures: source.server.procedureCount,
-      callsInFlight: source.server.inFlight(),
-      peerId: source.id,
-    }))
+    .handler(async () => {
+      // A lazy registry loads each package first: the count has each procedure (roadmap O93)
+      await source.server.loadAll();
+      return {
+        status: source.server.stopping ? ("stopping" as const) : ("ok" as const),
+        uptimeMs: Date.now() - source.startedAt,
+        procedures: source.server.procedureCount,
+        callsInFlight: source.server.inFlight(),
+        peerId: source.id,
+      };
+    })
     .build();
 
   const info = createProcedure()