@procedures/lib 0.1.0 → 0.2.1

package/src/procedures/lib/new.ts

@@ -2,9 +2,11 @@
  * lib.new procedure
  *
  * Creates a new client package in the workspace, at packages/<name>, with the
- * structure the other client packages have: cue-config files, src/index.ts (which
- * imports src/register.ts), src/register.ts, src/types.ts, the "./register" export and the
- * "client.procedures" field. `mark procedure new` then adds procedures that compile.
+ * structure the other client packages have: cue-config files, src/module.ts (the procedures as
+ * data), src/register.ts (the only file with a side effect), src/index.ts, src/types.ts, the
+ * "./module" and "./register" exports and the "client.procedures" field. Importing the package
+ * root registers nothing (ARCHITECTURE-PROPOSALS-2026-10, P9). `mark procedure new` then adds
+ * procedures to the module, and they compile.
  * Uses fs.* and shell.* procedures via ctx.client.call() for all operations.
  *
  * After it, run `pnpm install` and `pnpm build` in the workspace root.
@@ -22,9 +24,9 @@ interface ShellRunOutput {
   success: boolean;
 }
 
-// Importing the package registers its procedures, as in the other client packages
-const INDEX_TS = `// Entry point: importing the package registers its procedures
-export * from "./register.js";
+// The root registers nothing: `import "<package>/register"` or `createRegistry()` registers the procedures
+const INDEX_TS = `// The root registers nothing: import "<package>/register", or give the module to createRegistry()
+export * from "./module.js";
 export * from "./types.js";
 `;
 
@@ -39,22 +41,52 @@ const TYPES_TS = `/**
 export {};
 `;
 
-function registerTs(name: string): string {
+/** The names of a package folder in code: "my-package" gives "myPackage" and "MyPackage". */
+function codeNames(name: string): { camel: string; pascal: string } {
+  const pascal = name
+    .split(/[^A-Za-z0-9]+/)
+    .filter(Boolean)
+    .map((part) => part[0]!.toUpperCase() + part.slice(1))
+    .join("");
+  return { camel: pascal[0]!.toLowerCase() + pascal.slice(1), pascal };
+}
+
+function moduleTs(name: string, packageName: string): string {
+  const { camel, pascal } = codeNames(name);
   return `/**
- * Procedure registration for ${name}
+ * The procedures of ${packageName} as data. Importing this file registers nothing.
  *
- * Add each procedure of this package to the registerProcedures() array.
  * Scaffold a procedure with: mark procedure new <name> --path packages/${name}
  */
 
-import { registerProcedures } from "@procedures/client";
+import { defineModule, registerModules, PROCEDURE_REGISTRY, type ProcedureModule, type ProcedureRegistry } from "@procedures/client";
+
+export const ${camel}Module: ProcedureModule = defineModule("${packageName}", []);
+
+export default ${camel}Module;
 
-export function register(): void {
-  registerProcedures([]);
+/**
+ * This function registers the procedures of ${packageName} in a registry. The default is the
+ * global registry.
+ */
+export function register${pascal}Procedures(registry: ProcedureRegistry = PROCEDURE_REGISTRY): void {
+  registerModules(registry, [${camel}Module]);
 }
+`;
+}
+
+function registerTs(name: string, packageName: string): string {
+  const { pascal } = codeNames(name);
+  return `/**
+ * Importing this file registers the procedures of ${packageName} in the global registry:
+ * \`import "${packageName}/register"\`. The package root registers nothing.
+ */
+
+import { register${pascal}Procedures } from "./module.js";
+
+export * from "./module.js";
 
-// Auto-register
-register();
+register${pascal}Procedures();
 `;
 }
 
@@ -121,6 +153,7 @@ export async function libNew(input: LibNewInput, ctx: ProcedureContext): Promise
 
   const files = [
     join(packagePath, "src", "index.ts"),
+    join(packagePath, "src", "module.ts"),
     join(packagePath, "src", "register.ts"),
     join(packagePath, "src", "types.ts"),
     join(packagePath, "dependencies.json"),
@@ -136,7 +169,7 @@ export async function libNew(input: LibNewInput, ctx: ProcedureContext): Promise
       packagePath,
       created: [`${packagePath}/`, `${join(packagePath, "src")}/`, ...files],
       operations: [
-        "Would create packages/" + input.name + " with src/index.ts, src/register.ts and src/types.ts",
+        "Would create packages/" + input.name + " with src/index.ts, src/module.ts, src/register.ts and src/types.ts",
         `Would run cue-config init --preset ${input.preset}`,
         "Would run cue-config generate",
         `Would set the package name to ${packageName}, the exports, client.procedures and the client dependency`,
@@ -157,7 +190,8 @@ export async function libNew(input: LibNewInput, ctx: ProcedureContext): Promise
 
     for (const [file, content] of [
       [join(packagePath, "src", "index.ts"), INDEX_TS],
-      [join(packagePath, "src", "register.ts"), registerTs(input.name)],
+      [join(packagePath, "src", "module.ts"), moduleTs(input.name, packageName)],
+      [join(packagePath, "src", "register.ts"), registerTs(input.name, packageName)],
       [join(packagePath, "src", "types.ts"), TYPES_TS],
     ] as const) {
       await ctx.client.call<{ path: string; content: string }, { path: string; bytesWritten: number }>(
@@ -188,8 +222,11 @@ export async function libNew(input: LibNewInput, ctx: ProcedureContext): Promise
     pkgJson["name"] = packageName;
     pkgJson["exports"] = {
       ".": { types: "./dist/index.d.ts", import: "./dist/index.js" },
+      "./module": { types: "./dist/module.d.ts", import: "./dist/module.js" },
       "./register": { types: "./dist/register.d.ts", import: "./dist/register.js" },
     };
+    // Only the register entry has a side effect, so a bundler can drop the rest
+    pkgJson["sideEffects"] = ["./dist/register.js"];
     pkgJson["client"] = { procedures: "./dist/register.js" };
     pkgJson["dependencies"] = {
       ...((pkgJson["dependencies"] as Record<string, string> | undefined) ?? {}),

package/src/register.ts

@@ -1,23 +1,11 @@
 /**
- * Importing this file registers the procedures of @procedures/lib 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/lib, and of the modules that it
+ * requires, in the global registry: `import "@procedures/lib/register"`. The package root and the
+ * `./module` entry register nothing (ARCHITECTURE-PROPOSALS-2026-10, P9).
  */
 
-// The lib procedures call fs.* and git.* (their `calls` below). Importing those packages registers
-// them, so client-lib works alone. (Docs review DOC-5: before, lib.scan alone found no packages,
-// and over MCP its git calls failed with NOT_FOUND.)
-import "@procedures/fs";
-import "@procedures/git";
-
-import { registerProcedures } from "@procedures/client";
-import { libModule } from "./module.js";
+import { registerLibProcedures } from "./module.js";
 
 export * from "./module.js";
 
-export function registerLibProcedures(): void {
-  registerProcedures(libModule.procedures);
-}
-
-// Auto-register when this module is loaded
 registerLibProcedures();

package/dist/scoped-input.d.ts

@@ -1,17 +0,0 @@
-/**
- * An input schema for a runner: a procedure that takes its input raw and runs the procedure
- * refs in it (`core.catch`, `dag.traverse`).
- *
- * The caller gives a raw input with its scope (`withScope()`), so the runner can resolve the
- * `$ref` names of an outer chain. The scope is a hidden property, and a Zod parse makes a new
- * object without it. This schema validates with Zod, then puts the scope of the input on the
- * result. (The general fix is in the core: `invokeProcedure` could keep the scope across the
- * validation of every procedure.)
- */
-import { type ZodLikeSchema } from "@mark1russell7/client";
-export declare function scopedInput<T>(schema: {
-    parse: (data: unknown) => T;
-    _def?: unknown;
-    shape?: unknown;
-}): ZodLikeSchema<T>;
-//# sourceMappingURL=scoped-input.d.ts.map

package/dist/scoped-input.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scoped-input.d.ts","sourceRoot":"","sources":["../src/scoped-input.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAkC,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3F,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE;IAAE,KAAK,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,aAAa,CAAC,CAAC,CAAC,CAQzH"}

package/dist/scoped-input.js

@@ -1,23 +0,0 @@
-/**
- * An input schema for a runner: a procedure that takes its input raw and runs the procedure
- * refs in it (`core.catch`, `dag.traverse`).
- *
- * The caller gives a raw input with its scope (`withScope()`), so the runner can resolve the
- * `$ref` names of an outer chain. The scope is a hidden property, and a Zod parse makes a new
- * object without it. This schema validates with Zod, then puts the scope of the input on the
- * result. (The general fix is in the core: `invokeProcedure` could keep the scope across the
- * validation of every procedure.)
- */
-import { scopeOf, withScope, zodAdapter } from "@mark1russell7/client";
-export function scopedInput(schema) {
-    const scoped = {
-        parse: (data) => withScope(schema.parse(data), scopeOf(data)),
-    };
-    // zodAdapter shows _def and shape, so the CLI help and the MCP schema still see the fields
-    if (schema._def !== undefined)
-        scoped._def = schema._def;
-    if (schema.shape !== undefined)
-        scoped.shape = schema.shape;
-    return zodAdapter(scoped);
-}
-//# sourceMappingURL=scoped-input.js.map

package/dist/scoped-input.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"scoped-input.js","sourceRoot":"","sources":["../src/scoped-input.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAsB,MAAM,uBAAuB,CAAC;AAE3F,MAAM,UAAU,WAAW,CAAI,MAAwE;IACrG,MAAM,MAAM,GAAqE;QAC/E,KAAK,EAAE,CAAC,IAAa,EAAE,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;KACvE,CAAC;IACF,2FAA2F;IAC3F,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS;QAAE,MAAM,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;IACzD,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS;QAAE,MAAM,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;IAC5D,OAAO,UAAU,CAAI,MAAM,CAAC,CAAC;AAC/B,CAAC"}