@procedures/client 0.46.0 → 0.47.2

package/src/server/procedure-server.ts

@@ -146,7 +146,8 @@ export interface ProcedureServerOptions extends ServerOptions {
    * the server answers `UNAUTHORIZED`. Only a local request (`LOCAL_CREDENTIALS`) skips it. The
    * server refuses a request without credentials (CLI-1). Before, only the Express middleware of
    * the peer examined the token, so a `ProcedureServer` with the HTTP or WebSocket transport of the
-   * core and the token of a host policy accepted each request.
+   * core and the token of a host policy accepted each request. An empty token means "refuse each
+   * network request": no presented token matches it, not even an empty one.
    */
   token?: string | undefined;
 
@@ -235,16 +236,18 @@ export interface RegisterProcedureOptions {
 }
 
 /**
- * True when the presented token is the expected one. The comparison reads each character of the
- * expected token for each presented token, so its time depends only on the expected token. The
- * time tells neither the token nor its length. The function runs in a browser too, so it uses
- * no `node:crypto`.
+ * True when the presented token is the expected one. An empty expected token matches nothing, not
+ * even an empty presented token, so a server with an empty token refuses each network request.
+ * The comparison reads each character of the presented token one time, so its time depends only
+ * on what the caller sent. The time tells neither the expected token nor its length. The function
+ * runs in a browser too, so it uses no `node:crypto`.
  */
 export function tokenMatches(expected: string, presented: string | undefined): boolean {
   if (presented === undefined) return false;
-  // A difference of the lengths makes the result false, after the same loop as an equal length
-  let difference = expected.length ^ presented.length;
-  for (let index = 0; index < expected.length; index++) difference |= expected.charCodeAt(index) ^ (presented.charCodeAt(index) | 0);
+  // An empty expected token and a difference of the lengths make the result false, after the same
+  // loop as an equal length. The modulo reuses the expected characters for a longer token.
+  let difference = (expected.length === 0 ? 1 : 0) | (expected.length ^ presented.length);
+  for (let index = 0; index < presented.length; index++) difference |= presented.charCodeAt(index) ^ expected.charCodeAt(index % expected.length);
   return difference === 0;
 }
 
@@ -835,6 +838,16 @@ export class ProcedureServer extends Server implements RepositoryProvider, StopP
     return procedure ? (request) => this.invoke(procedure, request) : null;
   }
 
+  /**
+   * A miss of a lazy registry loads the packages of the path, then the server looks up the
+   * handler again (roadmap O93). An eager registry, or a server that does not serve its registry,
+   * finds no handler here.
+   */
+  protected override findLateHandler(method: Method, request: ServerRequest<unknown>): Promise<ServerHandler | null> | null {
+    if (!this.servesRegistry || !this.procedureRegistry.lazy) return null;
+    return this.procedureRegistry.resolve(methodToPath(method)).then(() => this.findHandler(method, request));
+  }
+
   /**
    * Run a procedure for a request. A keyed call to a procedure that is not repeatable runs one
    * time for its key (R1).
@@ -1207,6 +1220,14 @@ export class ProcedureServer extends Server implements RepositoryProvider, StopP
     return this.servedKeys().size;
   }
 
+  /**
+   * This method loads each package of a lazy registry that the server serves (roadmap O93). Then
+   * `procedureCount` and the lists count each procedure. For an eager registry it does nothing.
+   */
+  async loadAll(): Promise<void> {
+    if (this.servesRegistry && this.procedureRegistry.lazy) await this.procedureRegistry.loadAll();
+  }
+
   /**
    * Check if the server serves a procedure now.
    *

package/src/server/server.ts

@@ -309,7 +309,8 @@ export class Server {
 
     try {
       // Find handler
-      const handler = this.findHandler(request.method, request);
+      // A miss can load the procedure first (a lazy registry, roadmap O93). A hit does not wait.
+      const handler = this.findHandler(request.method, request) ?? (await this.findLateHandler(request.method, request));
       if (!handler) {
         throw new HandlerNotFoundError(request.method);
       }
@@ -363,6 +364,14 @@ export class Server {
     return null;
   }
 
+  /**
+   * This method finds a handler after `findHandler()` found none. The default finds none at once.
+   * `ProcedureServer` loads the procedure of a lazy registry here (roadmap O93).
+   */
+  protected findLateHandler(_method: Method, _request: ServerRequest<unknown>): Promise<ServerHandler | null> | null {
+    return null;
+  }
+
   /**
    * Check if a method matches a matcher.
    */

package/src/testing/transport-contract.ts

@@ -20,12 +20,12 @@
  * skips the cases of that feature. Each skip thus is data in the test file of the face.
  *
  * The suite is the entry point `@procedures/client/testing`, so a face in another package (and
- * a server of an app, for example Graph) runs the same cases with the client that it uses. The
+ * a server of an app) runs the same cases with the client that it uses. The
  * suite imports no test runner: the caller gives `describe`, `it`, `afterEach` and `expect`
  * (`ContractRunner`). Those of Vitest fit.
  */
 
-import { z } from "zod";
+import * as z from "zod";
 import {
   Client,
   VersionConflictError,

package/src/tracing/traceparent.ts

@@ -20,12 +20,35 @@ export interface TraceContext {
   readonly sampled: boolean;
 }
 
-function randomHex(bytes: number): string {
-  const values = new Uint8Array(bytes);
+/**
+ * The size of the pool of random bytes. One fill gives 256 trace ids or 512 span ids. Before
+ * (roadmap O94), each id called `getRandomValues` for 8 or 16 bytes: in a chain of 200 steps, the
+ * random ids took about 10 % of the per-step time of the host.
+ */
+export const RANDOM_POOL_BYTES = 4096;
+
+/** The two hex digits of each byte value. */
+const HEX = Array.from({ length: 256 }, (_, value) => value.toString(16).padStart(2, "0"));
+
+const pool = new Uint8Array(RANDOM_POOL_BYTES);
+// The pool starts empty: the first id fills it
+let next = RANDOM_POOL_BYTES;
+
+/** This function fills the pool with new random bytes. Each byte goes to one id only. */
+function refill(): void {
   const crypto = (globalThis as { crypto?: { getRandomValues?: (array: Uint8Array) => Uint8Array } }).crypto;
-  if (crypto?.getRandomValues) crypto.getRandomValues(values);
-  else for (let index = 0; index < bytes; index++) values[index] = Math.floor(Math.random() * 256);
-  return Array.from(values, (value) => value.toString(16).padStart(2, "0")).join("");
+  if (crypto?.getRandomValues) crypto.getRandomValues(pool);
+  else for (let index = 0; index < RANDOM_POOL_BYTES; index++) pool[index] = Math.floor(Math.random() * 256);
+  next = 0;
+}
+
+/** This function gives `bytes` random bytes of the pool as hex digits. `bytes` is 16 or less. */
+function randomHex(bytes: number): string {
+  if (next + bytes > RANDOM_POOL_BYTES) refill();
+  let hex = "";
+  for (let index = next; index < next + bytes; index++) hex += HEX[pool[index]!]!;
+  next += bytes;
+  return hex;
 }
 
 /** This function makes a new trace id: 32 random hex digits. */