@procedures/client 0.2.2 → 0.3.0

package/src/machines.ts

@@ -0,0 +1,186 @@
+/**
+ * The state machines of the core as data (roadmap R35): the connection of the WebSocket client
+ * and the circuit breaker. The documents have the format `mark1russell7.machine/1` of
+ * `@mark1russell7/algebra`. They are the specification, and the code implements them. Their knobs
+ * are the default times of the core (`TIMER_DEFAULTS`), and their timers say which knob gives each
+ * wait.
+ *
+ * The code reports each change of its state as a `MachineTransition` (the option `onTransition`).
+ * `replayTransitions()` replays the reports of a run against a document, so a test finds each
+ * change that the document does not allow. It uses `replay` of `@mark1russell7/algebra/replay`
+ * (roadmap R37). That entry imports nothing else, and it has 418 bytes of gzip.
+ */
+
+import { replay } from "@mark1russell7/algebra/replay";
+import { TIMER_DEFAULTS } from "./timers.js";
+
+/** A change of state that the code reports. It has the fields of a lifecycle event of `@mark1russell7/service`. */
+export interface MachineTransition {
+  /** The id of the document. */
+  readonly machine: string;
+  /** The instance: one connection, one breaker. */
+  readonly instance: string;
+  readonly from: string;
+  readonly on: string;
+  readonly to: string;
+  /** The time of the clock of the instance, in milliseconds. */
+  readonly at: number;
+}
+
+/** A time of a timer: one knob, in a unit. */
+export interface MachineDuration {
+  readonly knob: string;
+  readonly unit: string;
+}
+
+/** A timer of a document: the events that start and stop it, and the event that it gives. */
+export interface MachineTimer {
+  readonly duration: MachineDuration;
+  readonly arms: readonly string[];
+  readonly cancels?: readonly string[] | undefined;
+  readonly fires: string;
+  /** A timer that starts again after it fires, with a longer wait each time. */
+  readonly backoff?: { readonly resets: readonly string[] } | undefined;
+  readonly note?: string | undefined;
+}
+
+/** A transition of a document. */
+export interface MachineTransitionDef {
+  readonly id: string;
+  readonly from: string | readonly string[];
+  readonly on: string | readonly string[];
+  readonly to: string;
+  readonly timer?: string | undefined;
+  readonly note?: string | undefined;
+}
+
+/** A machine document: the subset of `mark1russell7.machine/1` that the core uses. */
+export interface MachineDocument {
+  readonly format: "mark1russell7.machine/1";
+  readonly id: string;
+  readonly title: string;
+  readonly layer: "self";
+  readonly version: string;
+  readonly sources: ReadonlyArray<{ readonly ref: string; readonly rung: "implemented" }>;
+  readonly states: Readonly<Record<string, { readonly initial?: boolean; readonly final?: boolean; readonly note?: string }>>;
+  readonly events: Readonly<Record<string, { readonly kind: "rx" | "tx" | "app" | "timer" | "local"; readonly note?: string }>>;
+  readonly knobs: Readonly<Record<string, { readonly key: string; readonly scope: string; readonly unit: string | null; readonly default: number | null }>>;
+  readonly timers: Readonly<Record<string, MachineTimer>>;
+  readonly transitions: readonly MachineTransitionDef[];
+}
+
+const SOURCE = [{ ref: "packages/client/src (the core implements this document)", rung: "implemented" as const }];
+const ms = (knob: string): MachineDuration => ({ knob, unit: "ms" });
+const client = TIMER_DEFAULTS.webSocketClient;
+
+/** The connection of the WebSocket client (`WebSocketTransport`). */
+export const WEBSOCKET_CONNECTION_MACHINE: MachineDocument = {
+  format: "mark1russell7.machine/1",
+  id: "procedures.machine.websocket-connection",
+  title: "The connection of the WebSocket client",
+  layer: "self",
+  version: "0.2.3",
+  sources: SOURCE,
+  states: {
+    DISCONNECTED: { initial: true, note: "no socket" },
+    CONNECTING: { note: "the handshake, with its time limit" },
+    CONNECTED: { note: "the calls and the heartbeat" },
+    RECONNECTING: { note: "the backoff before the next try" },
+    DISCONNECTING: { note: "close() ends the socket and the calls" },
+  },
+  events: {
+    connect: { kind: "app", note: "the transport starts" },
+    "reconnect-due": { kind: "timer" },
+    open: { kind: "rx", note: "the handshake ends" },
+    drop: { kind: "local", note: "the socket closes, or an error ends it" },
+    "handshake-timeout": { kind: "timer" },
+    "ping-due": { kind: "timer" },
+    pong: { kind: "rx" },
+    "pong-timeout": { kind: "timer", note: "a drop after the last allowed miss" },
+    "give-up": { kind: "local", note: "a drop without reconnect, or without tries left" },
+    close: { kind: "app", note: "close() of the application" },
+    closed: { kind: "local" },
+  },
+  knobs: {
+    connection_timeout: { key: "connectionTimeout", scope: "client", unit: "ms", default: client.connectionTimeoutMs },
+    request_timeout: { key: "requestTimeout", scope: "client", unit: "ms", default: client.requestTimeoutMs },
+    heartbeat_interval: { key: "heartbeat.interval", scope: "client", unit: "ms", default: client.heartbeatIntervalMs },
+    heartbeat_timeout: { key: "heartbeat.timeout", scope: "client", unit: "ms", default: client.heartbeatTimeoutMs },
+    heartbeat_misses: { key: "heartbeat.misses", scope: "client", unit: "count", default: client.heartbeatMisses },
+    reconnect_initial_delay: { key: "reconnect.initialDelay", scope: "client", unit: "ms", default: client.reconnectInitialDelayMs },
+    reconnect_max_delay: { key: "reconnect.maxDelay", scope: "client", unit: "ms", default: client.reconnectMaxDelayMs },
+  },
+  timers: {
+    handshake: { duration: ms("connection_timeout"), arms: ["enter:CONNECTING"], cancels: ["open", "drop", "close"], fires: "handshake-timeout" },
+    reconnect: {
+      duration: ms("reconnect_max_delay"),
+      arms: ["enter:RECONNECTING"],
+      cancels: ["close"],
+      fires: "reconnect-due",
+      backoff: { resets: ["open"] },
+      note: "the longest wait: try n waits a random time up to min(maxDelay, initialDelay × 2^(n-1))",
+    },
+    ping: { duration: ms("heartbeat_interval"), arms: ["enter:CONNECTED", "ping-due"], cancels: ["drop", "close"], fires: "ping-due" },
+    pong: { duration: ms("heartbeat_timeout"), arms: ["ping-due"], cancels: ["pong", "drop", "close"], fires: "pong-timeout" },
+  },
+  transitions: [
+    { id: "connect", from: "DISCONNECTED", on: "connect", to: "CONNECTING" },
+    { id: "reconnect", from: "RECONNECTING", on: "reconnect-due", to: "CONNECTING", timer: "reconnect" },
+    { id: "open", from: "CONNECTING", on: "open", to: "CONNECTED" },
+    {
+      id: "drop",
+      from: ["CONNECTING", "CONNECTED", "RECONNECTING"],
+      on: ["drop", "handshake-timeout", "pong-timeout"],
+      to: "RECONNECTING",
+      note: "the code reports each of them as drop",
+    },
+    { id: "give-up", from: ["CONNECTING", "CONNECTED", "RECONNECTING"], on: "give-up", to: "DISCONNECTED" },
+    { id: "close", from: ["DISCONNECTED", "CONNECTING", "CONNECTED", "RECONNECTING"], on: "close", to: "DISCONNECTING" },
+    { id: "closed", from: "DISCONNECTING", on: "closed", to: "DISCONNECTED" },
+  ],
+};
+
+/** The circuit breaker (`createCircuitBreakerMiddleware`). */
+export const CIRCUIT_BREAKER_MACHINE: MachineDocument = {
+  format: "mark1russell7.machine/1",
+  id: "procedures.machine.circuit-breaker",
+  title: "The circuit breaker",
+  layer: "self",
+  version: "0.2.3",
+  sources: SOURCE,
+  states: {
+    CLOSED: { initial: true, note: "each call goes through. The window counts the failures of availability." },
+    OPEN: { note: "each call fails at once, until the reset time" },
+    HALF_OPEN: { note: "a limited number of probes go through" },
+  },
+  events: {
+    "failure-threshold": { kind: "local", note: "the window has the threshold of failures" },
+    "reset-timeout": { kind: "timer" },
+    "probe-failure": { kind: "local" },
+    "probe-successes": { kind: "local", note: "the threshold of successes of the probes" },
+  },
+  knobs: {
+    failure_threshold: { key: "failureThreshold", scope: "client", unit: "count", default: 5 },
+    failure_window: { key: "failureWindow", scope: "client", unit: "ms", default: TIMER_DEFAULTS.circuitBreaker.failureWindowMs },
+    reset_timeout: { key: "resetTimeout", scope: "client", unit: "ms", default: TIMER_DEFAULTS.circuitBreaker.resetTimeoutMs },
+    success_threshold: { key: "successThreshold", scope: "client", unit: "count", default: 2 },
+  },
+  timers: {
+    reset: { duration: ms("reset_timeout"), arms: ["failure-threshold", "probe-failure"], cancels: ["probe-successes"], fires: "reset-timeout" },
+  },
+  transitions: [
+    { id: "trip", from: "CLOSED", on: "failure-threshold", to: "OPEN" },
+    { id: "reset", from: "OPEN", on: "reset-timeout", to: "HALF_OPEN", timer: "reset" },
+    { id: "reopen", from: "HALF_OPEN", on: "probe-failure", to: "OPEN" },
+    { id: "recover", from: "HALF_OPEN", on: "probe-successes", to: "CLOSED" },
+  ],
+};
+
+/**
+ * This function replays the reported transitions of one document. Each instance starts in the
+ * state that its first transition leaves. Each transition must leave the state where the replay
+ * is, and the document must allow it. The function gives each disagreement.
+ */
+export function replayTransitions(machine: MachineDocument, events: readonly MachineTransition[]): string[] {
+  return replay(machine, events, { machine: machine.id });
+}

package/src/procedures/capability.ts

@@ -25,16 +25,14 @@ import type {
 } from "./types.js";
 import { pathToKey } from "./types.js";
 import { isDataDriven } from "./ref.js";
+import { inferredEffectsOf } from "./effects.js";
 import { callMatches } from "./policy.js";
 
 /** The standard resource names. An application adds its own names. */
 export const STANDARD_RESOURCES = ["fs", "network", "process", "registry"] as const;
 
-/**
- * The metadata key of the remaining time of a remote call, in milliseconds. A server uses it
- * only to make its deadline earlier.
- */
-export const TIMEOUT_METADATA_KEY = "procedure-timeout";
+// The metadata key of the remaining time of a remote call, in milliseconds (client/deadline.ts)
+export { TIMEOUT_METADATA_KEY } from "../client/deadline.js";
 
 /** The capability without limits: the capability of a host that sets none. */
 export const UNLIMITED_CAPABILITY: Capability = Object.freeze({});
@@ -97,11 +95,12 @@ export interface ToolHints {
 /**
  * The MCP hints of a procedure, from its declared effects. A procedure without a declaration,
  * or a data-driven one (its operands decide what it does), gets no hints: then the MCP defaults
- * apply (not read-only, destructive, open world).
+ * apply (not read-only, destructive, open world). A procedure that `procedure.define` made gets
+ * the hints of the effects that the host found for its body (`inferredEffects`, roadmap R22).
  */
 export function toolHints(procedure: AnyProcedure): ToolHints {
-  const effects = effectsOf(procedure);
-  if (!effects || isDataDriven(procedure)) return {};
+  const effects = isDataDriven(procedure) ? inferredEffectsOf(procedure) : effectsOf(procedure);
+  if (!effects) return {};
   if (isReadOnly(effects)) {
     return { readOnlyHint: true, openWorldHint: isOpenWorld(effects) };
   }
@@ -168,7 +167,10 @@ export function narrowCapability<C>(
   const effects = narrowEffects(base.effects, request.effects);
   if (effects !== undefined) result.effects = effects;
 
-  const requestedDeadline = request.timeoutMs !== undefined ? now + request.timeoutMs : undefined;
+  // A time that is not a finite number of milliseconds (NaN, Infinity, below zero) asks for nothing:
+  // Math.min with NaN gives NaN, and a NaN deadline is no deadline, so it would widen
+  const timeoutMs = request.timeoutMs;
+  const requestedDeadline = typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs >= 0 ? now + timeoutMs : undefined;
   const deadline =
     base.deadline === undefined ? requestedDeadline : requestedDeadline === undefined ? base.deadline : Math.min(base.deadline, requestedDeadline);
   if (deadline !== undefined) result.deadline = deadline;

package/src/procedures/collection/index.ts

@@ -19,6 +19,10 @@ export {
   hasOutputSchema,
   getAllInputSchema,
   getAllOutputSchema,
+  entriesInputSchema,
+  entriesOutputSchema,
+  changesInputSchema,
+  changesOutputSchema,
   sizeInputSchema,
   sizeOutputSchema,
   clearInputSchema,
@@ -37,6 +41,10 @@ export type {
   DeleteInput,
   HasInput,
   GetAllInput,
+  EntriesInput,
+  CollectionEntry,
+  ChangesInput,
+  ChangesOutput,
   SizeInput,
   ClearInput,
   GetBatchInput,
@@ -48,4 +56,4 @@ export type {
 export { createCollectionProcedures } from "./procedures.js";
 
 // The storage interface of the core (the shape of client-collections' CollectionStorage)
-export type { CollectionStorage, StorageMetadata } from "./storage.js";
+export type { CollectionStorage, StorageChanges, StorageMetadata } from "./storage.js";

package/src/procedures/collection/procedures.ts

@@ -18,6 +18,10 @@ import {
   hasOutputSchema,
   getAllInputSchema,
   getAllOutputSchema,
+  entriesInputSchema,
+  entriesOutputSchema,
+  changesInputSchema,
+  changesOutputSchema,
   sizeInputSchema,
   sizeOutputSchema,
   clearInputSchema,
@@ -33,6 +37,9 @@ import {
   type DeleteInput,
   type HasInput,
   type GetAllInput,
+  type EntriesInput,
+  type ChangesInput,
+  type ChangesOutput,
   type SizeInput,
   type ClearInput,
   type GetBatchInput,
@@ -168,6 +175,56 @@ export function createCollectionProcedures(collectionName: string): AnyProcedure
       },
     }),
 
+    // Entries: each item with its id, for a sync (roadmap R2)
+    defineProcedure({
+      path: [...basePath, "entries"],
+      input: entriesInputSchema,
+      output: entriesOutputSchema,
+      metadata: {
+        effects: { reads: [resource], writes: [] },
+        description: `Get all items of ${collectionName} with their ids`,
+        tags: ["collections", collectionName, "read"],
+      },
+      handler: async (_input: EntriesInput, ctx: ProcedureContext) => {
+        const storage = getStorage(ctx);
+        if (!storage.getEntries) {
+          throw new Error(`The storage of ${collectionName} cannot give the ids of its items`);
+        }
+        return (await storage.getEntries()).map(([id, value]) => ({ id, value }));
+      },
+    }),
+
+    // Changes: the items that changed after a version, for a delta sync (roadmap R28)
+    defineProcedure({
+      path: [...basePath, "changes"],
+      input: changesInputSchema,
+      output: changesOutputSchema,
+      metadata: {
+        effects: { reads: [resource], writes: [] },
+        description: `Get the items of ${collectionName} that changed after a version`,
+        tags: ["collections", collectionName, "read"],
+      },
+      handler: async (input: ChangesInput, ctx: ProcedureContext): Promise<ChangesOutput> => {
+        const storage = getStorage(ctx);
+        if (storage.getChangesSince) {
+          const changes = await storage.getChangesSince(input.since);
+          return {
+            version: changes.version,
+            full: changes.full,
+            changed: changes.changed.map(([id, value]) => ({ id, value })),
+            deleted: changes.deleted,
+          };
+        }
+        // A storage without a change log gives all its items. The empty version asks for all
+        // items again at the next call.
+        if (storage.getEntries) {
+          const entries = await storage.getEntries();
+          return { version: "", full: true, changed: entries.map(([id, value]) => ({ id, value })), deleted: [] };
+        }
+        throw new Error(`The storage of ${collectionName} cannot give its changes or the ids of its items`);
+      },
+    }),
+
     // Size
     defineProcedure({
       path: [...basePath, "size"],

package/src/procedures/collection/schemas.ts

@@ -335,6 +335,116 @@ export const getAllOutputSchema : ZodLike<unknown[]> = createSchema<unknown[]>((
   };
 });
 
+// =============================================================================
+// Entries Operation Schemas
+// =============================================================================
+
+/**
+ * Input for entries operation - empty object.
+ */
+export interface EntriesInput {}
+
+export const entriesInputSchema : ZodLike<EntriesInput> = createSchema<EntriesInput>((data) => {
+  if (!isObject(data)) {
+    return {
+      success: false,
+      error: {
+        message: "Input must be an object",
+        errors: [{ path: [], message: "Input must be an object" }],
+      },
+    };
+  }
+  return { success: true, data: {} };
+});
+
+/** One item of a collection with its id. */
+export interface CollectionEntry {
+  id: string;
+  value: unknown;
+}
+
+/**
+ * Output for entries operation - each item with its id. A sync needs the ids: `getAll` gives
+ * only the values (roadmap R2).
+ */
+export const entriesOutputSchema : ZodLike<CollectionEntry[]> = createSchema<CollectionEntry[]>((data) => {
+  if (isArray(data) && data.every((entry) => isObject(entry) && isString(entry["id"]) && "value" in entry)) {
+    return { success: true, data: data as CollectionEntry[] };
+  }
+  return {
+    success: false,
+    error: {
+      message: "Output must be an array of { id, value } objects",
+      errors: [{ path: [], message: "Output must be an array of { id, value } objects" }],
+    },
+  };
+});
+
+// =============================================================================
+// Changes Operation Schemas
+// =============================================================================
+
+/** Input for changes operation: the version of an earlier call (roadmap R28). */
+export interface ChangesInput {
+  /** The `version` of an earlier result. Without it, the result has all items. */
+  since?: string;
+}
+
+export const changesInputSchema : ZodLike<ChangesInput> = createSchema<ChangesInput>((data) => {
+  if (!isObject(data)) {
+    return {
+      success: false,
+      error: {
+        message: "Input must be an object",
+        errors: [{ path: [], message: "Input must be an object" }],
+      },
+    };
+  }
+  const since = data["since"];
+  if (since !== undefined && !isString(since)) {
+    return {
+      success: false,
+      error: {
+        message: "since must be a string",
+        errors: [{ path: ["since"], message: "since must be a string" }],
+      },
+    };
+  }
+  return { success: true, data: since === undefined ? {} : { since } };
+});
+
+/**
+ * Output for changes operation: the items that changed after the version, the deleted ids, and
+ * the new version. When `full` is true, `changed` has each item (roadmap R28).
+ */
+export interface ChangesOutput {
+  version: string;
+  full: boolean;
+  changed: CollectionEntry[];
+  deleted: string[];
+}
+
+export const changesOutputSchema : ZodLike<ChangesOutput> = createSchema<ChangesOutput>((data) => {
+  if (
+    isObject(data) &&
+    isString(data["version"]) &&
+    typeof data["full"] === "boolean" &&
+    isArray(data["changed"]) &&
+    data["changed"].every((entry) => isObject(entry) && isString(entry["id"]) && "value" in entry) &&
+    isArray(data["deleted"]) &&
+    data["deleted"].every((id) => isString(id))
+  ) {
+    return { success: true, data: data as unknown as ChangesOutput };
+  }
+  return {
+    success: false,
+    error: {
+      message: "Output must be { version, full, changed: [{ id, value }], deleted: [id] }",
+      errors: [{ path: [], message: "Output must be { version, full, changed: [{ id, value }], deleted: [id] }" }],
+    },
+  };
+});
+
 // =============================================================================
 // Size Operation Schemas
 // =============================================================================

package/src/procedures/collection/storage.ts

@@ -15,6 +15,18 @@ export interface CollectionStorage<T> {
   get(id: string): Promise<T | undefined>;
   /** Every item of the collection. */
   getAll(): Promise<T[]>;
+  /**
+   * Every item with its id. A sync needs the ids (roadmap R2). A storage that cannot give
+   * them does not have this method.
+   */
+  getEntries?(): Promise<Array<[string, T]>>;
+  /**
+   * The changes after a version (roadmap R28). A storage without a change log does not have
+   * this method, and a sync uses `getEntries()`.
+   *
+   * @param since - A `version` that an earlier call gave. Without it, the result has all items.
+   */
+  getChangesSince?(since?: string): Promise<StorageChanges<T>>;
   /** The items for which the predicate gives true. */
   find(predicate: (item: T) => boolean): Promise<T[]>;
   /** True when an item has this id. */
@@ -33,12 +45,38 @@ export interface CollectionStorage<T> {
   deleteBatch(ids: string[]): Promise<number>;
   /** The items of several ids. An id with no item is not in the map. */
   getBatch(ids: string[]): Promise<Map<string, T>>;
+  /**
+   * This method sends the writes that wait in the storage to their destination (roadmap R28). A storage
+   * that keeps no writes does not have this method. `ProcedureServer.useStorage` calls it.
+   */
+  flush?(): Promise<void>;
   /** Release the resources of the storage. */
   close(): Promise<void>;
   /** The kind, the size and the statistics of the storage. */
   getMetadata?(): Promise<StorageMetadata>;
 }
 
+/**
+ * The changes of a storage after a version (roadmap R28).
+ *
+ * - `version` is opaque. The next call gives it back as `since`.
+ * - When `full` is true, `changed` has every item, and each id that it does not have was
+ *   deleted. A storage gives a full result when it cannot find the changes since the version:
+ *   the first call, a version of an older run, or a change log that dropped old deletes.
+ * - When `full` is false, `changed` has the items that changed after the version, and `deleted`
+ *   has the ids that were deleted after it.
+ */
+export interface StorageChanges<T> {
+  /** The version of the storage that includes these changes. */
+  version: string;
+  /** True when `changed` has every item of the storage. */
+  full: boolean;
+  /** The items that changed, with their ids. */
+  changed: Array<[string, T]>;
+  /** The ids that were deleted. Empty when `full` is true. */
+  deleted: string[];
+}
+
 /** The metadata that a storage gives about itself. */
 export interface StorageMetadata {
   type: "memory" | "api" | "hybrid" | "synced" | "custom";

package/src/procedures/core/array.ts

@@ -11,6 +11,16 @@ import { defineProcedure, namespace } from "../define.js";
 import type { AnyProcedure, Procedure } from "../types.js";
 import { PURE_EFFECTS, withEffects } from "../effects.js";
 
+/**
+ * This function gives the own field `key` of an item, or undefined. A field of the prototype
+ * (`toString`, `constructor`) is not a field of the item: before, `count` with the key
+ * `toString` counted each item (catalog test, roadmap R29, as R6 for the object procedures).
+ */
+function fieldOf(item: unknown, key: string): unknown {
+  if (item === null || item === undefined) return undefined;
+  return Object.hasOwn(Object(item), key) ? (item as Record<string, unknown>)[key] : undefined;
+}
+
 // =============================================================================
 // First Procedure
 // =============================================================================
@@ -209,8 +219,8 @@ const sortProcedure: SortProcedure = defineProcedure({
     const direction = input.desc ? -1 : 1;
 
     return items.sort((a, b) => {
-      let aVal = input.key ? (a as Record<string, unknown>)[input.key] : a;
-      let bVal = input.key ? (b as Record<string, unknown>)[input.key] : b;
+      let aVal = input.key ? fieldOf(a, input.key) : a;
+      let bVal = input.key ? fieldOf(b, input.key) : b;
 
       if (typeof aVal === "string" && typeof bVal === "string") {
         return aVal.localeCompare(bVal) * direction;
@@ -309,7 +319,7 @@ const uniqueProcedure: UniqueProcedure = defineProcedure({
     if (input.key) {
       const seen = new Set<unknown>();
       return input.items.filter((item) => {
-        const val = (item as Record<string, unknown>)[input.key!];
+        const val = fieldOf(item, input.key!);
         if (seen.has(val)) return false;
         seen.add(val);
         return true;
@@ -346,11 +356,13 @@ const groupByProcedure: GroupByProcedure = defineProcedure({
   handler: async (input: GroupByInput): Promise<Record<string, unknown[]>> => {
     const result: Record<string, unknown[]> = {};
     for (const item of input.items) {
-      const keyVal = String((item as Record<string, unknown>)[input.key]);
-      if (!result[keyVal]) {
-        result[keyVal] = [];
+      const keyVal = String(fieldOf(item, input.key));
+      // Only an own group: before, a group "constructor" or "toString" found the function of the
+      // prototype, and push failed (catalog test, roadmap R29)
+      if (!Object.hasOwn(result, keyVal)) {
+        Object.defineProperty(result, keyVal, { value: [], writable: true, enumerable: true, configurable: true });
       }
-      result[keyVal].push(item);
+      result[keyVal]!.push(item);
     }
     return result;
   },
@@ -640,7 +652,7 @@ const filterProcedure: FilterProcedure = defineProcedure({
     const { items, key, value, values, match = 'equals', invert = false } = input;
 
     const predicate = (item: unknown): boolean => {
-      const itemValue = key ? (item as Record<string, unknown>)[key] : item;
+      const itemValue = key ? fieldOf(item, key) : item;
 
       let result: boolean;
       switch (match) {
@@ -716,10 +728,7 @@ const whereProcedure: WhereProcedure = defineProcedure({
   },
   handler: async (input: WhereInput): Promise<unknown[]> => {
     const { items, where } = input;
-    return items.filter((item) => {
-      const obj = item as Record<string, unknown>;
-      return Object.entries(where).every(([key, value]) => obj[key] === value);
-    });
+    return items.filter((item) => Object.entries(where).every(([key, value]) => fieldOf(item, key) === value));
   },
 });
 
@@ -750,7 +759,7 @@ const pluckProcedure: PluckProcedure = defineProcedure({
     tags: ["core", "array", "transform"],
   },
   handler: async (input: PluckInput): Promise<unknown[]> => {
-    return input.items.map((item) => (item as Record<string, unknown>)[input.key]);
+    return input.items.map((item) => fieldOf(item, input.key));
   },
 });
 
@@ -785,7 +794,9 @@ const arrPickProcedure: ArrPickProcedure = defineProcedure({
       const obj = item as Record<string, unknown>;
       const result: Record<string, unknown> = {};
       for (const key of input.keys) {
-        if (key in obj) {
+        // Only own fields, as client.pick: before, "toString" picked a function of the prototype
+        // (catalog test, roadmap R29)
+        if (Object.hasOwn(obj, key)) {
           result[key] = obj[key];
         }
       }
@@ -881,7 +892,7 @@ const partitionProcedure: PartitionProcedure = defineProcedure({
     const falsy: unknown[] = [];
 
     for (const item of input.items) {
-      const itemValue = (item as Record<string, unknown>)[input.key];
+      const itemValue = fieldOf(item, input.key);
       const matches = input.value !== undefined ? itemValue === input.value : Boolean(itemValue);
       if (matches) {
         truthy.push(item);
@@ -929,7 +940,7 @@ const countProcedure: CountProcedure = defineProcedure({
     }
 
     return input.items.filter((item) => {
-      const itemValue = (item as Record<string, unknown>)[input.key!];
+      const itemValue = fieldOf(item, input.key!);
       return input.value !== undefined ? itemValue === input.value : Boolean(itemValue);
     }).length;
   },

package/src/procedures/core/index.ts

@@ -582,6 +582,10 @@ const mapProcedure: MapProcedure = defineProcedure({
     // map is a control-flow procedure: its operands arrive raw, and it runs them here.
     // Before, the handler only returned the raw items, so their refs never ran and no
     // function was applied.
+    if (input.fn !== undefined && !isAnyProcedureRef(input.fn)) {
+      // Before, a fn that was not a call was ignored without a word (roadmap R4)
+      throw new Error("client.map: fn must be one call ({ $proc, input }), or absent");
+    }
     const outer = scopeOf(input);
     const items = await hydrateItems(input.items, ctx, outer);
     if (!isAnyProcedureRef(input.fn) || !ctx?.client) {
@@ -625,6 +629,10 @@ const reduceProcedure: ReduceProcedure = defineProcedure({
     tags: controlFlowTags("collection"),
   },
   handler: async (input: ReduceInput, ctx?: ProcedureContext): Promise<unknown> => {
+    if (input.fn !== undefined && !isAnyProcedureRef(input.fn)) {
+      // Before, a fn that was not a call was ignored without a word (roadmap R4)
+      throw new Error("client.reduce: fn must be one call ({ $proc, input }), or absent");
+    }
     if (!ctx?.client) {
       return input.accumulated ?? input.initial;
     }

package/src/procedures/core/meta.ts

@@ -331,7 +331,8 @@ const lookupProcedure: LookupProcedure = defineProcedure({
   handler: async (input: LookupInput, ctx): Promise<LookupOutput> => {
     // The registry of the caller (a server or a client with its own registry)
     const proc = (ctx?.registry ?? PROCEDURE_REGISTRY).get(input.path);
-    if (proc) {
+    // A procedure outside the expose rule of the host does not exist for its callers (R17)
+    if (proc && (!ctx?.expose || ctx.expose(proc.path))) {
       return {
         exists: true,
         metadata: proc.metadata,