@procedures/peer 0.1.0 → 0.2.1

package/dist/register.d.ts

@@ -1,8 +1,7 @@
 /**
- * Importing this file registers the procedures of @procedures/peer in the global registry
- * (DECISIONS-2026-10, "Every package root registers its procedures"). The procedures as data
- * are in `module.ts`, which registers nothing: a host with its own registry uses that one.
+ * Importing this file registers the procedures of @procedures/peer, and of the modules that it
+ * requires, in the global registry: `import "@procedures/peer/register"`. The package root and the
+ * `./module` entry register nothing (ARCHITECTURE-PROPOSALS-2026-10, P9).
  */
 export * from "./module.js";
-export declare function registerServerProcedures(): void;
 //# sourceMappingURL=register.d.ts.map

package/dist/register.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../src/register.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,cAAc,aAAa,CAAC;AAE5B,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C"}
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../src/register.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,cAAc,aAAa,CAAC"}

package/dist/register.js

@@ -1,14 +1,9 @@
 /**
- * Importing this file registers the procedures of @procedures/peer in the global registry
- * (DECISIONS-2026-10, "Every package root registers its procedures"). The procedures as data
- * are in `module.ts`, which registers nothing: a host with its own registry uses that one.
+ * Importing this file registers the procedures of @procedures/peer, and of the modules that it
+ * requires, in the global registry: `import "@procedures/peer/register"`. The package root and the
+ * `./module` entry register nothing (ARCHITECTURE-PROPOSALS-2026-10, P9).
  */
-import { registerProcedures } from "@procedures/client";
-import { serverModule } from "./module.js";
+import { registerServerProcedures } from "./module.js";
 export * from "./module.js";
-export function registerServerProcedures() {
-    registerProcedures(serverModule.procedures);
-}
-// Auto-register when this module is loaded
 registerServerProcedures();
 //# sourceMappingURL=register.js.map

package/dist/register.js.map

@@ -1 +1 @@
-{"version":3,"file":"register.js","sourceRoot":"","sources":["../src/register.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,cAAc,aAAa,CAAC;AAE5B,MAAM,UAAU,wBAAwB;IACtC,kBAAkB,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;AAC9C,CAAC;AAED,2CAA2C;AAC3C,wBAAwB,EAAE,CAAC"}
+{"version":3,"file":"register.js","sourceRoot":"","sources":["../src/register.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAEvD,cAAc,aAAa,CAAC;AAE5B,wBAAwB,EAAE,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@procedures/peer",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Serve procedures: HTTP and WebSocket peers with token authentication, browser checks, an expose list, server.create, status and stop, and manifests.",
   "keywords": [
     "server",
@@ -35,6 +35,10 @@
       "types": "./dist/module.d.ts",
       "import": "./dist/module.js"
     },
+    "./register": {
+      "types": "./dist/register.d.ts",
+      "import": "./dist/register.js"
+    },
     "./procedures": {
       "types": "./dist/procedures/index.d.ts",
       "import": "./dist/procedures/index.js"
@@ -53,7 +57,6 @@
     "CHANGELOG.md"
   ],
   "sideEffects": [
-    "./dist/index.js",
     "./dist/register.js"
   ],
   "engines": {
@@ -74,7 +77,7 @@
     "procedures": "./dist/register.js"
   },
   "dependencies": {
-    "@procedures/client": "0.1.0",
+    "@procedures/client": "0.2.1",
     "zod": "^4.6.5"
   },
   "optionalDependencies": {

package/src/discovery/index.ts

@@ -7,8 +7,10 @@
 
 import {
   createProcedure,
+  type Effects,
   type Procedure,
   PROCEDURE_REGISTRY,
+  REGISTRY_READ_EFFECTS,
 } from "@procedures/client";
 import { schema } from "../schema.js";
 import type {
@@ -39,7 +41,7 @@ const discoveryAnnounceOutputSchema = schema<ProcedureAnnounceMessage>();
 export const discoveryAnnounceProcedure: Procedure<
   DiscoveryAnnounceInput,
   ProcedureAnnounceMessage,
-  { description: string; internal: boolean }
+  { description: string; internal: boolean; effects: Effects }
 > = createProcedure()
   .path(["_discovery", "announce"])
   .input(discoveryAnnounceInputSchema)
@@ -47,6 +49,7 @@ export const discoveryAnnounceProcedure: Procedure<
   .meta({
     description: "Exchange procedure manifests for discovery",
     internal: true,
+    effects: REGISTRY_READ_EFFECTS,
   })
   .handler(async (_input: DiscoveryAnnounceInput) => {
     // Get all registered procedures

package/src/index.ts

@@ -66,4 +66,4 @@ export {
 } from "./discovery/index.js";
 
 // Registration
-export { procedures, registerServerProcedures } from "./register.js";
+export { procedures, registerServerProcedures } from "./module.js";

package/src/module.ts

@@ -7,7 +7,7 @@
  * This file is referenced by package.json's client.procedures field.
  */
 
-import { type AnyProcedure, defineModule, type ProcedureModule } from "@procedures/client";
+import { type AnyProcedure, defineModule, type ProcedureModule, PROCEDURE_REGISTRY, registerModules, type ProcedureRegistry } from "@procedures/client";
 
 // Import all procedures
 import { serverCreateProcedure } from "./procedures/server.create.js";
@@ -44,3 +44,12 @@ export const procedures: readonly AnyProcedure[] = [
 export const serverModule: ProcedureModule = defineModule("@procedures/peer", [...procedures]);
 
 export default serverModule;
+
+/**
+ * This function registers the procedures of @procedures/peer, and of the modules that it requires, in
+ * a registry. The default is the global registry. Importing this file registers nothing: the
+ * `./register` entry starts this function (ARCHITECTURE-PROPOSALS-2026-10, P9).
+ */
+export function registerServerProcedures(registry: ProcedureRegistry = PROCEDURE_REGISTRY): void {
+  registerModules(registry, [serverModule]);
+}

package/src/procedures/manifest.generate.ts

@@ -3,7 +3,7 @@
  * Generates procedure manifests in various formats
  */
 
-import { createProcedure, jsonSchemaOf, type Procedure, PROCEDURE_REGISTRY } from "@procedures/client";
+import { createProcedure, jsonSchemaOf, type Effects, type Procedure, PROCEDURE_REGISTRY } from "@procedures/client";
 import { wrapSchema } from "../schema.js";
 import { ManifestGenerateOutputSchema } from "../output-schemas.js";
 import { manifestGenerateInputSchema } from "../input-schemas.js";
@@ -19,12 +19,16 @@ const manifestGenerateOutputSchema = wrapSchema<ManifestGenerateOutput>(Manifest
 export const manifestGenerateProcedure: Procedure<
   ManifestGenerateInput,
   ManifestGenerateOutput,
-  { description: string }
+  { description: string; effects: Effects }
 > = createProcedure()
   .path(["manifest", "generate"])
   .input(manifestGenerateInputSchema)
   .output(manifestGenerateOutputSchema)
-  .meta({ description: "Generate procedure manifests in various formats" })
+  .meta({
+    description: "Generate procedure manifests in various formats",
+    // With `outputDir`, it overwrites procedures.json and procedures.d.ts there
+    effects: { reads: ["registry"], writes: ["fs"], idempotent: true },
+  })
   .handler(async (input: ManifestGenerateInput) => {
     // Get all registered procedures
     const allProcedures = PROCEDURE_REGISTRY.getAll();

package/src/procedures/server.call.ts

@@ -3,7 +3,7 @@
  * Call a procedure on a remote peer through an outbound connection
  */
 
-import { createProcedure, pathToMethod, type Procedure } from "@procedures/client";
+import { createProcedure, pathToMethod, type Effects, type Procedure } from "@procedures/client";
 import { wrapSchema } from "../schema.js";
 import { ServerCallOutputSchema } from "../output-schemas.js";
 import { serverCallInputSchema } from "../input-schemas.js";
@@ -42,13 +42,15 @@ const serverCallOutputSchema = wrapSchema<ServerCallOutput>(ServerCallOutputSche
 export const serverCallProcedure: Procedure<
   ServerCallInput,
   ServerCallOutput,
-  { description: string; args: string[]; shorts: Record<string, string>; output: string }
+  { description: string; effects: Effects; args: string[]; shorts: Record<string, string>; output: string }
 > = createProcedure()
   .path(["server", "call"])
   .input(serverCallInputSchema)
   .output(serverCallOutputSchema)
   .meta({
     description: "Call a procedure on a remote peer through an outbound connection",
+    // The remote procedure can change anything on its peer
+    effects: { reads: ["network"], writes: ["network"] },
     args: ["path"],
     shorts: { connectionId: "c", address: "a" },
     output: "json",

package/src/procedures/server.connect.ts

@@ -3,7 +3,7 @@
  * Connects to a remote peer for bidirectional RPC
  */
 
-import { createProcedure, type Procedure } from "@procedures/client";
+import { createProcedure, type Effects, type Procedure } from "@procedures/client";
 import { wrapSchema } from "../schema.js";
 import { ServerConnectOutputSchema } from "../output-schemas.js";
 import { serverConnectInputSchema } from "../input-schemas.js";
@@ -16,12 +16,17 @@ const serverConnectOutputSchema = wrapSchema<ServerConnectOutput>(ServerConnectO
 export const serverConnectProcedure: Procedure<
   ServerConnectInput,
   ServerConnectOutput,
-  { description: string }
+  { description: string; effects: Effects }
 > = createProcedure()
   .path(["server", "connect"])
   .input(serverConnectInputSchema)
   .output(serverConnectOutputSchema)
-  .meta({ description: "Connect to a remote peer for bidirectional RPC", args: ["address"] })
+  .meta({
+    description: "Connect to a remote peer for bidirectional RPC",
+    // It opens a new connection to a remote peer and reads the procedures of that peer
+    effects: { reads: ["network"], writes: ["network"], destructive: false },
+    args: ["address"],
+  })
   .handler(async (input: ServerConnectInput) => {
     const connectOptions: Parameters<typeof connect>[0] = {
       address: input.address,

package/src/procedures/server.connections.ts

@@ -3,7 +3,7 @@
  * List all outbound connections to remote peers
  */
 
-import { createProcedure, type Procedure } from "@procedures/client";
+import { createProcedure, type Effects, type Procedure } from "@procedures/client";
 import { wrapSchema } from "../schema.js";
 import { ServerConnectionsOutputSchema } from "../output-schemas.js";
 import { serverConnectionsInputSchema } from "../input-schemas.js";
@@ -37,13 +37,15 @@ const serverConnectionsOutputSchema = wrapSchema<ServerConnectionsOutput>(Server
 export const serverConnectionsProcedure: Procedure<
   ServerConnectionsInput,
   ServerConnectionsOutput,
-  { description: string; output: string }
+  { description: string; effects: Effects; output: string }
 > = createProcedure()
   .path(["server", "connections"])
   .input(serverConnectionsInputSchema)
   .output(serverConnectionsOutputSchema)
   .meta({
     description: "List outbound connections to remote peers",
+    // It reads the connections that server.connect opened, and sends nothing
+    effects: { reads: ["network"], writes: [] },
     output: "json",
   })
   .handler(async (): Promise<ServerConnectionsOutput> => {

package/src/procedures/server.create.ts

@@ -3,7 +3,7 @@
  * Creates a transport-agnostic peer that exposes procedures
  */
 
-import { createProcedure, type Procedure, PROCEDURE_REGISTRY } from "@procedures/client";
+import { createProcedure, type Effects, type Procedure, PROCEDURE_REGISTRY } from "@procedures/client";
 import { wrapSchema } from "../schema.js";
 import { ServerCreateOutputSchema } from "../output-schemas.js";
 import { serverCreateInputSchema } from "../input-schemas.js";
@@ -20,12 +20,16 @@ const activePeers = new Map<string, Peer>();
 export const serverCreateProcedure: Procedure<
   ServerCreateInput,
   ServerCreateOutput,
-  { description: string }
+  { description: string; effects: Effects }
 > = createProcedure()
   .path(["server", "create"])
   .input(serverCreateInputSchema)
   .output(serverCreateOutputSchema)
-  .meta({ description: "Create a transport-agnostic peer that exposes procedures" })
+  .meta({
+    description: "Create a transport-agnostic peer that exposes procedures",
+    // Each call starts a new peer that listens on its transports. It replaces nothing.
+    effects: { reads: ["registry"], writes: ["network", "server"], destructive: false },
+  })
   .handler(async (input: ServerCreateInput) => {
     // Generate unique server ID
     const serverId = `peer-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;

package/src/procedures/server.disconnect.ts

@@ -3,7 +3,7 @@
  * Disconnects from a remote peer
  */
 
-import { createProcedure, type Procedure } from "@procedures/client";
+import { createProcedure, type Effects, type Procedure } from "@procedures/client";
 import { wrapSchema } from "../schema.js";
 import { ServerDisconnectOutputSchema } from "../output-schemas.js";
 import { serverDisconnectInputSchema } from "../input-schemas.js";
@@ -16,12 +16,16 @@ const serverDisconnectOutputSchema = wrapSchema<ServerDisconnectOutput>(ServerDi
 export const serverDisconnectProcedure: Procedure<
   ServerDisconnectInput,
   ServerDisconnectOutput,
-  { description: string }
+  { description: string; effects: Effects }
 > = createProcedure()
   .path(["server", "disconnect"])
   .input(serverDisconnectInputSchema)
   .output(serverDisconnectOutputSchema)
-  .meta({ description: "Disconnect from a remote peer", args: ["connectionId"] })
+  .meta({
+    description: "Disconnect from a remote peer",
+    effects: { reads: ["network"], writes: ["network"], idempotent: true },
+    args: ["connectionId"],
+  })
   .handler(async (input: ServerDisconnectInput) => {
     const success = await disconnect(input.connectionId);
     return { success };

package/src/procedures/server.start.ts

@@ -7,7 +7,7 @@ import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
-import { createProcedure, type Procedure } from "@procedures/client";
+import { createProcedure, type Effects, type Procedure } from "@procedures/client";
 import { wrapSchema } from "../schema.js";
 import { ServerStartOutputSchema } from "../output-schemas.js";
 import { serverStartInputSchema } from "../input-schemas.js";
@@ -88,13 +88,16 @@ function findCliPath(): string {
 export const serverStartProcedure: Procedure<
   ServerStartInput,
   ServerStartOutput,
-  { description: string; args: string[]; shorts: Record<string, string> }
+  { description: string; effects: Effects; args: string[]; shorts: Record<string, string> }
 > = createProcedure()
   .path(["server", "start"])
   .input(serverStartInputSchema)
   .output(serverStartOutputSchema)
   .meta({
     description: "Start CLI server as background daemon",
+    // The daemon loads the procedure packages of the workspace. The procedure moves server.log
+    // over server.log.1.
+    effects: { reads: ["fs", "server"], writes: ["fs", "network", "process", "server"] },
     args: [],
     shorts: { port: "p", host: "h" },
   })

package/src/procedures/server.status.ts

@@ -5,7 +5,7 @@
 
 import * as path from "node:path";
 import * as os from "node:os";
-import { createProcedure, type Procedure } from "@procedures/client";
+import { createProcedure, type Effects, type Procedure } from "@procedures/client";
 import { wrapSchema } from "../schema.js";
 import { ServerStatusOutputSchema } from "../output-schemas.js";
 import { serverStatusInputSchema } from "../input-schemas.js";
@@ -50,13 +50,15 @@ function formatUptime(startedAt: string): string {
 export const serverStatusProcedure: Procedure<
   ServerStatusInput,
   ServerStatusOutput,
-  { description: string; output: string }
+  { description: string; effects: Effects; output: string }
 > = createProcedure()
   .path(["server", "status"])
   .input(serverStatusInputSchema)
   .output(serverStatusOutputSchema)
   .meta({
     description: "Get CLI server status",
+    // It deletes the lockfile of a server that does not answer
+    effects: { reads: ["fs", "server"], writes: ["fs"], idempotent: true },
     args: [],
     shorts: { port: "p" },
     output: "text",

package/src/procedures/server.stop.ts

@@ -3,7 +3,7 @@
  * Stops the running CLI server daemon
  */
 
-import { createProcedure, type Procedure } from "@procedures/client";
+import { createProcedure, type Effects, type Procedure } from "@procedures/client";
 import { wrapSchema } from "../schema.js";
 import { ServerStopOutputSchema } from "../output-schemas.js";
 import { serverStopInputSchema } from "../input-schemas.js";
@@ -32,13 +32,15 @@ function killProcess(pid: number, signal: NodeJS.Signals = "SIGTERM"): boolean {
 export const serverStopProcedure: Procedure<
   ServerStopInput,
   ServerStopOutput,
-  { description: string }
+  { description: string; effects: Effects }
 > = createProcedure()
   .path(["server", "stop"])
   .input(serverStopInputSchema)
   .output(serverStopOutputSchema)
   .meta({
     description: "Stop running CLI server",
+    // It stops the servers of the lockfiles and deletes their lockfiles
+    effects: { reads: ["fs", "server"], writes: ["fs", "server"], idempotent: true },
     args: [],
     shorts: { port: "p" },
   })

package/src/register.ts

@@ -1,17 +1,11 @@
 /**
- * Importing this file registers the procedures of @procedures/peer in the global registry
- * (DECISIONS-2026-10, "Every package root registers its procedures"). The procedures as data
- * are in `module.ts`, which registers nothing: a host with its own registry uses that one.
+ * Importing this file registers the procedures of @procedures/peer, and of the modules that it
+ * requires, in the global registry: `import "@procedures/peer/register"`. The package root and the
+ * `./module` entry register nothing (ARCHITECTURE-PROPOSALS-2026-10, P9).
  */
 
-import { registerProcedures } from "@procedures/client";
-import { serverModule } from "./module.js";
+import { registerServerProcedures } from "./module.js";
 
 export * from "./module.js";
 
-export function registerServerProcedures(): void {
-  registerProcedures(serverModule.procedures);
-}
-
-// Auto-register when this module is loaded
 registerServerProcedures();