@procedures/client 0.0.0-stage → 0.2.0

package/dist/procedures/define.d.ts

@@ -0,0 +1,228 @@
+/**
+ * Procedure Definition Helper
+ *
+ * Factory functions for creating well-typed procedure definitions.
+ *
+ * ## defineProcedure vs createProcedure
+ *
+ * This module provides two ways to create procedures:
+ *
+ * ### 1. defineProcedure (Declarative - Recommended for most cases)
+ *
+ * Use `defineProcedure` when:
+ * - You have all the procedure properties available upfront
+ * - You want a concise, single-expression definition
+ * - You're defining static procedures at module load time
+ * - You prefer declarative configuration
+ *
+ * ```typescript
+ * const myProcedure = defineProcedure({
+ *   path: ['users', 'get'],
+ *   input: z.object({ id: z.string() }),
+ *   output: z.object({ id: z.string(), name: z.string() }),
+ *   metadata: { description: 'Get a user' },
+ *   handler: async ({ id }) => fetchUser(id),
+ * });
+ * ```
+ *
+ * ### 2. createProcedure (Builder - For complex/dynamic scenarios)
+ *
+ * Use `createProcedure` (builder pattern) when:
+ * - Building procedures conditionally or dynamically
+ * - Composing procedures from multiple sources
+ * - Schemas are determined at runtime
+ * - You want to reuse partial configurations
+ * - Working with code generation or metaprogramming
+ *
+ * ```typescript
+ * const builder = createProcedure()
+ *   .path(['users', 'get'])
+ *   .input(inputSchema);
+ *
+ * if (featureFlags.includeExtendedOutput) {
+ *   builder.output(extendedOutputSchema);
+ * } else {
+ *   builder.output(basicOutputSchema);
+ * }
+ *
+ * const myProcedure = builder.handler(myHandler).build();
+ * ```
+ *
+ * ### 3. defineStub (Client-side type stubs)
+ *
+ * Use `defineStub` when:
+ * - You need type definitions without implementation
+ * - Building client-side code that calls remote procedures
+ * - Generating TypeScript types from procedure definitions
+ *
+ * ### Summary
+ *
+ * | Function          | Use Case                       | Returns         |
+ * |-------------------|--------------------------------|-----------------|
+ * | `defineProcedure` | Static, declarative definition | Procedure       |
+ * | `createProcedure` | Dynamic, builder pattern       | ProcedureBuilder|
+ * | `defineStub`      | Client-side type stubs         | Procedure (no handler) |
+ */
+import { type ProcedureSchema } from "./schema.js";
+import type { Procedure, ProcedurePath, ProcedureMetadata, ProcedureHandler } from "./types.js";
+/**
+ * Input for defining a procedure.
+ * Type parameters are inferred from schemas.
+ */
+export interface ProcedureDefinition<TInput, TOutput, TMeta extends ProcedureMetadata = ProcedureMetadata> {
+    /** Path in the route tree (e.g., ['collections', 'users', 'get']) */
+    path: ProcedurePath;
+    /** Input validation schema: a Standard Schema (zod 4, valibot, arktype) or a `ZodLike` */
+    input: ProcedureSchema<TInput>;
+    /** Output validation schema: a Standard Schema or a `ZodLike` */
+    output: ProcedureSchema<TOutput>;
+    /** Procedure metadata */
+    metadata?: TMeta;
+    /** Optional handler implementation */
+    handler?: ProcedureHandler<TInput, TOutput>;
+}
+/**
+ * Minimal definition without handler.
+ * Useful for client-side procedure stubs.
+ */
+export interface ProcedureStub<TInput, TOutput> {
+    path: ProcedurePath;
+    input: ProcedureSchema<TInput>;
+    output: ProcedureSchema<TOutput>;
+    metadata?: ProcedureMetadata;
+}
+/**
+ * Define a procedure with type inference from schemas.
+ *
+ * Creates a well-typed procedure definition that can be registered
+ * with the procedure registry.
+ *
+ * @param definition - Procedure definition with path, schemas, and optional handler
+ * @returns Fully typed procedure object
+ *
+ * @example
+ * ```typescript
+ * const getUserProcedure = defineProcedure({
+ *   path: ['users', 'get'],
+ *   input: z.object({ id: z.string() }),
+ *   output: z.object({ id: z.string(), name: z.string(), email: z.string() }),
+ *   metadata: {
+ *     description: 'Get user by ID',
+ *     tags: ['users', 'read'],
+ *   },
+ *   handler: async ({ id }, ctx) => {
+ *     const storage = ctx.repository?.getStorage<User>('users');
+ *     const user = await storage?.get(id);
+ *     if (!user) throw new Error('User not found');
+ *     return user;
+ *   },
+ * });
+ * ```
+ */
+export declare function defineProcedure<TInput, TOutput, TMeta extends ProcedureMetadata = ProcedureMetadata>(definition: ProcedureDefinition<TInput, TOutput, TMeta>): Procedure<TInput, TOutput, TMeta>;
+/**
+ * Define a procedure stub without handler.
+ * Useful for client-side type definitions.
+ *
+ * @param stub - Procedure stub with path and schemas
+ * @returns Procedure object without handler
+ *
+ * @example
+ * ```typescript
+ * // Client-side stub for type inference
+ * const getUserStub = defineStub({
+ *   path: ['users', 'get'],
+ *   input: z.object({ id: z.string() }),
+ *   output: z.object({ id: z.string(), name: z.string() }),
+ * });
+ * ```
+ */
+export declare function defineStub<TInput, TOutput>(stub: ProcedureStub<TInput, TOutput>): Procedure<TInput, TOutput, ProcedureMetadata>;
+/**
+ * Fluent builder for procedure definitions.
+ * Provides a chainable API for building procedures.
+ */
+export declare class ProcedureBuilder<TInput = unknown, TOutput = unknown, TMeta extends ProcedureMetadata = ProcedureMetadata> {
+    private _path;
+    private _input?;
+    private _output?;
+    private _metadata;
+    private _handler?;
+    /**
+     * Set the procedure path.
+     */
+    path(path: ProcedurePath): this;
+    /**
+     * Set the input schema.
+     */
+    input<T>(schema: ProcedureSchema<T>): ProcedureBuilder<T, TOutput, TMeta>;
+    /**
+     * Set the output schema.
+     */
+    output<T>(schema: ProcedureSchema<T>): ProcedureBuilder<TInput, T, TMeta>;
+    /**
+     * Set procedure metadata.
+     */
+    meta<T extends ProcedureMetadata>(metadata: T): ProcedureBuilder<TInput, TOutput, T>;
+    /**
+     * Set the handler implementation.
+     */
+    handler(fn: ProcedureHandler<TInput, TOutput>): this;
+    /**
+     * Build the procedure definition.
+     *
+     * @throws Error if path, input, or output are not set
+     */
+    build(): Procedure<TInput, TOutput, TMeta>;
+}
+/**
+ * Create a new procedure builder.
+ *
+ * @example
+ * ```typescript
+ * const procedure = createProcedure()
+ *   .path(['users', 'get'])
+ *   .input(z.object({ id: z.string() }))
+ *   .output(z.object({ id: z.string(), name: z.string() }))
+ *   .meta({ description: 'Get user by ID' })
+ *   .handler(async ({ id }, ctx) => {
+ *     // Implementation
+ *   })
+ *   .build();
+ * ```
+ */
+export declare function createProcedure(): ProcedureBuilder;
+/**
+ * Create procedures under a common namespace.
+ * Automatically prefixes all procedure paths.
+ *
+ * @param namespace - Namespace path prefix
+ * @param procedures - Procedures to namespace
+ * @returns Procedures with prefixed paths
+ *
+ * @example
+ * ```typescript
+ * const collectionProcedures = namespace(['collections', 'users'], [
+ *   defineProcedure({
+ *     path: ['get'],  // Becomes ['collections', 'users', 'get']
+ *     input: z.object({ id: z.string() }),
+ *     output: userSchema,
+ *   }),
+ *   defineProcedure({
+ *     path: ['set'],  // Becomes ['collections', 'users', 'set']
+ *     input: z.object({ id: z.string(), value: userSchema }),
+ *     output: z.void(),
+ *   }),
+ * ]);
+ * ```
+ */
+export declare function namespace<T extends Procedure<unknown, unknown, ProcedureMetadata>[]>(namespacePath: ProcedurePath, procedures: T): T;
+/**
+ * Validate a procedure definition.
+ * Throws if the definition is invalid.
+ *
+ * @param procedure - Procedure to validate
+ * @throws Error if validation fails
+ */
+export declare function validateProcedure(procedure: Procedure<unknown, unknown, ProcedureMetadata>): void;
+//# sourceMappingURL=define.d.ts.map

package/dist/procedures/define.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define.d.ts","sourceRoot":"","sources":["../../src/procedures/define.ts"],"names":[],"mappings":"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"}

package/dist/procedures/define.js

@@ -0,0 +1,300 @@
+/**
+ * Procedure Definition Helper
+ *
+ * Factory functions for creating well-typed procedure definitions.
+ *
+ * ## defineProcedure vs createProcedure
+ *
+ * This module provides two ways to create procedures:
+ *
+ * ### 1. defineProcedure (Declarative - Recommended for most cases)
+ *
+ * Use `defineProcedure` when:
+ * - You have all the procedure properties available upfront
+ * - You want a concise, single-expression definition
+ * - You're defining static procedures at module load time
+ * - You prefer declarative configuration
+ *
+ * ```typescript
+ * const myProcedure = defineProcedure({
+ *   path: ['users', 'get'],
+ *   input: z.object({ id: z.string() }),
+ *   output: z.object({ id: z.string(), name: z.string() }),
+ *   metadata: { description: 'Get a user' },
+ *   handler: async ({ id }) => fetchUser(id),
+ * });
+ * ```
+ *
+ * ### 2. createProcedure (Builder - For complex/dynamic scenarios)
+ *
+ * Use `createProcedure` (builder pattern) when:
+ * - Building procedures conditionally or dynamically
+ * - Composing procedures from multiple sources
+ * - Schemas are determined at runtime
+ * - You want to reuse partial configurations
+ * - Working with code generation or metaprogramming
+ *
+ * ```typescript
+ * const builder = createProcedure()
+ *   .path(['users', 'get'])
+ *   .input(inputSchema);
+ *
+ * if (featureFlags.includeExtendedOutput) {
+ *   builder.output(extendedOutputSchema);
+ * } else {
+ *   builder.output(basicOutputSchema);
+ * }
+ *
+ * const myProcedure = builder.handler(myHandler).build();
+ * ```
+ *
+ * ### 3. defineStub (Client-side type stubs)
+ *
+ * Use `defineStub` when:
+ * - You need type definitions without implementation
+ * - Building client-side code that calls remote procedures
+ * - Generating TypeScript types from procedure definitions
+ *
+ * ### Summary
+ *
+ * | Function          | Use Case                       | Returns         |
+ * |-------------------|--------------------------------|-----------------|
+ * | `defineProcedure` | Static, declarative definition | Procedure       |
+ * | `createProcedure` | Dynamic, builder pattern       | ProcedureBuilder|
+ * | `defineStub`      | Client-side type stubs         | Procedure (no handler) |
+ */
+import { isStandardSchema } from "./schema.js";
+/** True for a schema that the core can validate with: a Standard Schema or a `ZodLike`. */
+function isProcedureSchema(schema) {
+    return isStandardSchema(schema) || typeof schema?.safeParse === "function";
+}
+// =============================================================================
+// Define Procedure
+// =============================================================================
+/**
+ * Define a procedure with type inference from schemas.
+ *
+ * Creates a well-typed procedure definition that can be registered
+ * with the procedure registry.
+ *
+ * @param definition - Procedure definition with path, schemas, and optional handler
+ * @returns Fully typed procedure object
+ *
+ * @example
+ * ```typescript
+ * const getUserProcedure = defineProcedure({
+ *   path: ['users', 'get'],
+ *   input: z.object({ id: z.string() }),
+ *   output: z.object({ id: z.string(), name: z.string(), email: z.string() }),
+ *   metadata: {
+ *     description: 'Get user by ID',
+ *     tags: ['users', 'read'],
+ *   },
+ *   handler: async ({ id }, ctx) => {
+ *     const storage = ctx.repository?.getStorage<User>('users');
+ *     const user = await storage?.get(id);
+ *     if (!user) throw new Error('User not found');
+ *     return user;
+ *   },
+ * });
+ * ```
+ */
+export function defineProcedure(definition) {
+    const procedure = {
+        path: definition.path,
+        input: definition.input,
+        output: definition.output,
+        metadata: (definition.metadata ?? {}),
+    };
+    // Only set handler if provided (exactOptionalPropertyTypes)
+    if (definition.handler) {
+        procedure.handler = definition.handler;
+    }
+    return procedure;
+}
+/**
+ * Define a procedure stub without handler.
+ * Useful for client-side type definitions.
+ *
+ * @param stub - Procedure stub with path and schemas
+ * @returns Procedure object without handler
+ *
+ * @example
+ * ```typescript
+ * // Client-side stub for type inference
+ * const getUserStub = defineStub({
+ *   path: ['users', 'get'],
+ *   input: z.object({ id: z.string() }),
+ *   output: z.object({ id: z.string(), name: z.string() }),
+ * });
+ * ```
+ */
+export function defineStub(stub) {
+    return {
+        path: stub.path,
+        input: stub.input,
+        output: stub.output,
+        metadata: stub.metadata ?? {},
+    };
+}
+// =============================================================================
+// Procedure Builder (Fluent API)
+// =============================================================================
+/**
+ * Fluent builder for procedure definitions.
+ * Provides a chainable API for building procedures.
+ */
+export class ProcedureBuilder {
+    _path = [];
+    _input;
+    _output;
+    _metadata = {};
+    _handler;
+    /**
+     * Set the procedure path.
+     */
+    path(path) {
+        this._path = path;
+        return this;
+    }
+    /**
+     * Set the input schema.
+     */
+    input(schema) {
+        const builder = this;
+        builder._input = schema;
+        return builder;
+    }
+    /**
+     * Set the output schema.
+     */
+    output(schema) {
+        const builder = this;
+        builder._output = schema;
+        return builder;
+    }
+    /**
+     * Set procedure metadata.
+     */
+    meta(metadata) {
+        const builder = this;
+        builder._metadata = metadata;
+        return builder;
+    }
+    /**
+     * Set the handler implementation.
+     */
+    handler(fn) {
+        this._handler = fn;
+        return this;
+    }
+    /**
+     * Build the procedure definition.
+     *
+     * @throws Error if path, input, or output are not set
+     */
+    build() {
+        if (this._path.length === 0) {
+            throw new Error("Procedure path is required");
+        }
+        if (!this._input) {
+            throw new Error("Input schema is required");
+        }
+        if (!this._output) {
+            throw new Error("Output schema is required");
+        }
+        const procedure = {
+            path: this._path,
+            input: this._input,
+            output: this._output,
+            metadata: this._metadata,
+        };
+        // Only set handler if provided (exactOptionalPropertyTypes)
+        if (this._handler) {
+            procedure.handler = this._handler;
+        }
+        return procedure;
+    }
+}
+/**
+ * Create a new procedure builder.
+ *
+ * @example
+ * ```typescript
+ * const procedure = createProcedure()
+ *   .path(['users', 'get'])
+ *   .input(z.object({ id: z.string() }))
+ *   .output(z.object({ id: z.string(), name: z.string() }))
+ *   .meta({ description: 'Get user by ID' })
+ *   .handler(async ({ id }, ctx) => {
+ *     // Implementation
+ *   })
+ *   .build();
+ * ```
+ */
+export function createProcedure() {
+    return new ProcedureBuilder();
+}
+// =============================================================================
+// Namespace Helper
+// =============================================================================
+/**
+ * Create procedures under a common namespace.
+ * Automatically prefixes all procedure paths.
+ *
+ * @param namespace - Namespace path prefix
+ * @param procedures - Procedures to namespace
+ * @returns Procedures with prefixed paths
+ *
+ * @example
+ * ```typescript
+ * const collectionProcedures = namespace(['collections', 'users'], [
+ *   defineProcedure({
+ *     path: ['get'],  // Becomes ['collections', 'users', 'get']
+ *     input: z.object({ id: z.string() }),
+ *     output: userSchema,
+ *   }),
+ *   defineProcedure({
+ *     path: ['set'],  // Becomes ['collections', 'users', 'set']
+ *     input: z.object({ id: z.string(), value: userSchema }),
+ *     output: z.void(),
+ *   }),
+ * ]);
+ * ```
+ */
+export function namespace(namespacePath, procedures) {
+    return procedures.map((proc) => ({
+        ...proc,
+        path: [...namespacePath, ...proc.path],
+    }));
+}
+// =============================================================================
+// Validation Helpers
+// =============================================================================
+/**
+ * Validate a procedure definition.
+ * Throws if the definition is invalid.
+ *
+ * @param procedure - Procedure to validate
+ * @throws Error if validation fails
+ */
+export function validateProcedure(procedure) {
+    if (!procedure.path || procedure.path.length === 0) {
+        throw new Error("Procedure path cannot be empty");
+    }
+    for (const segment of procedure.path) {
+        if (typeof segment !== "string" || segment.length === 0) {
+            throw new Error(`Invalid path segment: ${segment}`);
+        }
+        if (segment.includes(".")) {
+            throw new Error(`Path segment cannot contain dots: ${segment}`);
+        }
+    }
+    if (!isProcedureSchema(procedure.input)) {
+        throw new Error("Input schema must be a Standard Schema (zod 4, valibot, arktype) or have a safeParse method");
+    }
+    if (!isProcedureSchema(procedure.output)) {
+        throw new Error("Output schema must be a Standard Schema (zod 4, valibot, arktype) or have a safeParse method");
+    }
+}
+//# sourceMappingURL=define.js.map

package/dist/procedures/define.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define.js","sourceRoot":"","sources":["../../src/procedures/define.ts"],"names":[],"mappings":"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"}

package/dist/procedures/discovery.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Procedure Registration Helpers
+ *
+ * Manual registration helpers for procedures. For compile-time auto-discovery,
+ * use the CLI: `npx client-registry discover`
+ *
+ * Libraries that depend on client should:
+ * 1. Add `"client": { "procedures": "./dist/register.js" }` to package.json
+ * 2. Create a register.ts that uses createAndRegister()
+ * 3. Consumers run `npx client-registry discover` to generate imports
+ */
+import type { AnyProcedure, ProcedureModule } from "./types.js";
+/**
+ * Register procedures from a module.
+ * Use this for explicit registration when auto-discovery isn't suitable.
+ *
+ * @param module - Module with procedures array
+ *
+ * @example
+ * ```typescript
+ * // In repo-b/src/register.ts
+ * import { registerModule } from 'client/procedures';
+ * import { weatherModule } from './procedures';
+ *
+ * registerModule(weatherModule);
+ * ```
+ */
+export declare function registerModule(module: ProcedureModule): void;
+/**
+ * Register an array of procedures.
+ *
+ * @param procedures - Procedures to register
+ */
+export declare function registerProcedures(procedures: AnyProcedure[]): void;
+/**
+ * Create a self-registering module.
+ * Returns the module and registers it immediately.
+ *
+ * @param name - Module name
+ * @param procedures - Procedures in the module
+ * @returns The registered module
+ *
+ * @example
+ * ```typescript
+ * // In repo-b/src/register.ts
+ * import { createAndRegister } from 'client/procedures';
+ * import { forecastProcedure, currentWeatherProcedure } from './procedures';
+ *
+ * // Registers immediately when this file is imported
+ * export const weatherModule = createAndRegister('weather', [
+ *   forecastProcedure,
+ *   currentWeatherProcedure,
+ * ]);
+ * ```
+ */
+export declare function createAndRegister(name: string, procedures: AnyProcedure[]): ProcedureModule;
+//# sourceMappingURL=discovery.d.ts.map

package/dist/procedures/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../src/procedures/discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAMhE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI,CAE5D;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,YAAY,EAAE,GAAG,IAAI,CAEnE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,YAAY,EAAE,GACzB,eAAe,CAIjB"}

package/dist/procedures/discovery.js

@@ -0,0 +1,68 @@
+/**
+ * Procedure Registration Helpers
+ *
+ * Manual registration helpers for procedures. For compile-time auto-discovery,
+ * use the CLI: `npx client-registry discover`
+ *
+ * Libraries that depend on client should:
+ * 1. Add `"client": { "procedures": "./dist/register.js" }` to package.json
+ * 2. Create a register.ts that uses createAndRegister()
+ * 3. Consumers run `npx client-registry discover` to generate imports
+ */
+import { PROCEDURE_REGISTRY } from "./registry.js";
+// =============================================================================
+// Manual Registration Helpers
+// =============================================================================
+/**
+ * Register procedures from a module.
+ * Use this for explicit registration when auto-discovery isn't suitable.
+ *
+ * @param module - Module with procedures array
+ *
+ * @example
+ * ```typescript
+ * // In repo-b/src/register.ts
+ * import { registerModule } from 'client/procedures';
+ * import { weatherModule } from './procedures';
+ *
+ * registerModule(weatherModule);
+ * ```
+ */
+export function registerModule(module) {
+    PROCEDURE_REGISTRY.registerModule(module);
+}
+/**
+ * Register an array of procedures.
+ *
+ * @param procedures - Procedures to register
+ */
+export function registerProcedures(procedures) {
+    PROCEDURE_REGISTRY.registerAll(procedures);
+}
+/**
+ * Create a self-registering module.
+ * Returns the module and registers it immediately.
+ *
+ * @param name - Module name
+ * @param procedures - Procedures in the module
+ * @returns The registered module
+ *
+ * @example
+ * ```typescript
+ * // In repo-b/src/register.ts
+ * import { createAndRegister } from 'client/procedures';
+ * import { forecastProcedure, currentWeatherProcedure } from './procedures';
+ *
+ * // Registers immediately when this file is imported
+ * export const weatherModule = createAndRegister('weather', [
+ *   forecastProcedure,
+ *   currentWeatherProcedure,
+ * ]);
+ * ```
+ */
+export function createAndRegister(name, procedures) {
+    const module = { name, procedures };
+    PROCEDURE_REGISTRY.registerModule(module);
+    return module;
+}
+//# sourceMappingURL=discovery.js.map

package/dist/procedures/discovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.js","sourceRoot":"","sources":["../../src/procedures/discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAGnD,gFAAgF;AAChF,8BAA8B;AAC9B,gFAAgF;AAEhF;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,cAAc,CAAC,MAAuB;IACpD,kBAAkB,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;AAC5C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAC,UAA0B;IAC3D,kBAAkB,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;AAC7C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,iBAAiB,CAC/B,IAAY,EACZ,UAA0B;IAE1B,MAAM,MAAM,GAAoB,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;IACrD,kBAAkB,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAC1C,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/procedures/effects.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Effect declarations for groups of procedures (CAPABILITIES-2026-10). This file imports only
+ * types, so each file of procedures can use it without an import cycle.
+ */
+import type { AnyProcedure, Effects } from "./types.js";
+/** The effects of a procedure that reads and changes nothing: its output comes from its input. */
+export declare const PURE_EFFECTS: Effects;
+/** The effects of a procedure that reads the procedure registry and changes nothing. */
+export declare const REGISTRY_READ_EFFECTS: Effects;
+/**
+ * This function gives copies of the procedures with the effects in their metadata. A procedure
+ * that declares its own effects keeps them.
+ */
+export declare function withEffects<T extends AnyProcedure>(effects: Effects, procedures: readonly T[]): T[];
+//# sourceMappingURL=effects.d.ts.map