@procedures/client 0.0.0-stage → 0.1.0

package/dist/procedures/policy.js.map

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

package/dist/procedures/ref.d.ts

@@ -0,0 +1,606 @@
+/**
+ * Procedure Reference System
+ *
+ * Enables procedures-as-data: procedures can be passed as inputs to other procedures,
+ * composed declaratively via JSON, or imperatively via TypeScript.
+ *
+ * Key concepts:
+ * - PROCEDURE_SYMBOL: Symbol tag to identify procedure references in JSON/objects
+ * - ProcedureRef: A reference to a procedure with pre-bound input
+ * - $when: Controls when a procedure reference is executed during hydration
+ * - $name: Names the result of a chain step, for `$ref`
+ * - $ref: Reads a name of the scope (a chain step, `$last`, `item`, `acc`, `index`, `input`)
+ * - $literal: Gives a value without hydration
+ * - hydrateInput: Walks input tree and executes nested procedure references
+ * - executeRef: Helper for procedures to execute deferred refs
+ * - proc(): Factory function to create procedure references
+ *
+ * ## Execution Control with $when
+ *
+ * The `$when` field controls when a procedure reference is executed:
+ * - `"$immediate"` (or absent): Execute during hydration (default)
+ * - `"$never"`: Never execute during hydration, pass as pure data (with its whole subtree)
+ * - `"$parent"`: Defer to parent procedure (pass as data)
+ * - `"someName"`: Defer to the runner that gives this name in its `contextStack`
+ *   (`dag.traverse` gives "dag.traverse", `core.catch` gives "catch")
+ *
+ * A deferred ref is data at every depth: hydration of the input that holds it does not run it.
+ * The procedure that receives it runs it later (deep dive CORE-11).
+ *
+ * ## Raw input
+ *
+ * A procedure that takes its input raw (control flow, the `runs-refs` and `raw-input` tags) gets
+ * the refs of its input unchanged: it runs them itself. Such an input carries the scope of the
+ * caller (`withScope`), so nested control flow can read the names of an outer chain.
+ *
+ * @example
+ * ```typescript
+ * // Declarative (JSON) with execution control
+ * const pipelineJson = {
+ *   $name: "traversal",
+ *   $proc: ["dag", "traverse"],
+ *   input: {
+ *     visit: {
+ *       $proc: ["git", "add"],
+ *       input: { all: true },
+ *       $when: "traversal",  // Defer to traversal context
+ *     },
+ *   },
+ * };
+ *
+ * // The inner $proc is NOT executed during hydration.
+ * // dag.traverse receives it as data and executes per-node.
+ * await client.exec(pipelineJson);
+ * ```
+ */
+import type { ProcedurePath } from "./types.js";
+/**
+ * Symbol used to tag objects as procedure references.
+ * This allows procedure references to be identified during input hydration.
+ */
+export declare const PROCEDURE_SYMBOL: symbol;
+/**
+ * JSON key used to identify procedure references in serialized form.
+ */
+export declare const PROCEDURE_JSON_KEY: string;
+/**
+ * JSON key used to control when a procedure reference is executed.
+ */
+export declare const PROCEDURE_WHEN_KEY: string;
+/**
+ * JSON key that names the result of a chain step: a later step reads it with `{ $ref: "<name>" }`.
+ */
+export declare const PROCEDURE_NAME_KEY: string;
+/**
+ * JSON key used to reference outputs from named stages.
+ */
+export declare const OUTPUT_REF_KEY: string;
+/**
+ * JSON key of a literal. Hydration gives the value of `{ $literal: value }` and does not look
+ * inside it, so a `$proc` or a `$ref` in the value stays data (for example a JSON Schema `$ref`).
+ */
+export declare const LITERAL_KEY: string;
+/**
+ * Execute immediately during hydration (default behavior).
+ */
+export declare const WHEN_IMMEDIATE: string;
+/**
+ * Never execute during hydration - pass as pure data.
+ */
+export declare const WHEN_NEVER: string;
+/**
+ * Defer to parent procedure - pass as data for parent to execute.
+ */
+export declare const WHEN_PARENT: string;
+/**
+ * Information passed to $continueIf handlers about the result of a procedure execution.
+ */
+export interface StepResultInfo {
+    /** Whether the procedure executed successfully */
+    success: boolean;
+    /** The procedure's output (if success) */
+    result?: unknown;
+    /** Error message (if failed) */
+    error?: string;
+    /** Whether the operation was a no-op (from result.skipped if present) */
+    skipped?: boolean;
+    /** The procedure path that was executed */
+    proc: ProcedurePath;
+}
+/**
+ * Decision returned by $continueIf handlers.
+ */
+export interface ContinueDecision {
+    /** Whether to continue execution (true) or propagate the error (false) */
+    continue: boolean;
+}
+/**
+ * A reference to an output from a named stage.
+ *
+ * Reference syntax:
+ * - `"stageName"` - reference full output of named stage
+ * - `"stageName.field"` - reference field in output
+ * - `"stageName.nested.path"` - deep path traversal
+ * - `"$last"` - reference previous stage output
+ * - `"$last.value"` - reference field in previous output
+ */
+export interface OutputRef {
+    /** Path to a named output, optionally with property path */
+    readonly $ref: string;
+}
+/**
+ * Scope for tracking outputs during chain execution.
+ * Scopes form a tree structure for nested chains.
+ */
+export interface RefScope {
+    /** Named outputs in this scope */
+    outputs: Map<string, unknown>;
+    /** Previous step output ($last) */
+    last?: unknown | undefined;
+    /** Parent scope for nested chains */
+    parent?: RefScope | undefined;
+    /** This scope's name (if in a named chain) */
+    name?: string | undefined;
+}
+/**
+ * Create a new RefScope with optional parent.
+ */
+export declare function createRefScope(parent?: RefScope, name?: string): RefScope;
+/**
+ * Get a value by path from an object.
+ * Supports dot-separated paths like "foo.bar.baz".
+ * Only the own properties are read, so a path such as "a.constructor" gives undefined.
+ */
+export declare function getPath(obj: unknown, path: string[]): unknown;
+/**
+ * Look up an output reference in a scope and its parents.
+ *
+ * The first segment is a name: the innermost scope with that name gives the value. `$last` is the
+ * last result of the innermost scope that has one. The other segments read fields of the value.
+ * `found` is false when no scope has the name. A missing field is `found` with the value undefined.
+ */
+export declare function lookupOutputRef(refPath: string, scope: RefScope | undefined): {
+    found: boolean;
+    value?: unknown;
+};
+/**
+ * Resolve an output reference within a scope.
+ *
+ * @param refPath - The reference path (e.g., "stageName.value" or "$last.value")
+ * @param scope - The current scope to resolve within
+ * @returns The resolved value, or undefined if not found
+ */
+export declare function resolveOutputRef(refPath: string, scope: RefScope): unknown;
+/**
+ * This function gives a copy of a raw input that carries a scope. A procedure that takes its input
+ * raw (control flow) reads the scope with `scopeOf()` and makes it the parent of its own scope.
+ * Thus the operands of a nested control-flow procedure can read the names of the outer chain.
+ * The scope is a property that is not enumerable: JSON and the transports do not see it.
+ */
+export declare function withScope<T>(input: T, scope: RefScope | undefined): T;
+/** The scope that a raw input carries (see `withScope()`), or undefined. */
+export declare function scopeOf(input: unknown): RefScope | undefined;
+/** True for a plain object: an object literal, or an object with a null prototype. */
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/** True for `{ $literal: value }`: a plain object whose only key is `$literal`. */
+export declare function isLiteral(value: unknown): value is {
+    $literal: unknown;
+};
+/**
+ * Execution timing for procedure references.
+ * - `"$immediate"`: Execute during hydration (default)
+ * - `"$never"`: Never execute, pass as pure data
+ * - `"$parent"`: Defer to parent procedure
+ * - `string`: Defer to named ancestor context
+ */
+export type ProcedureWhen = "$immediate" | "$never" | "$parent" | string;
+/**
+ * A reference to a procedure with pre-bound input (runtime form).
+ * Can be passed as input to other procedures and will be executed during hydration.
+ *
+ * @example
+ * ```typescript
+ * const ref: ProcedureRef = {
+ *   [PROCEDURE_SYMBOL]: true,
+ *   path: ["git", "add"],
+ *   input: { all: true },
+ * };
+ * ```
+ */
+export interface ProcedureRef<TInput = unknown, TOutput = unknown> {
+    /** Symbol tag identifying this as a procedure reference */
+    readonly [PROCEDURE_SYMBOL]: true;
+    /** Path to the procedure */
+    readonly path: ProcedurePath;
+    /** Pre-bound input for the procedure */
+    readonly input: TInput;
+    /** Optional name for this execution context */
+    readonly $name?: string;
+    /** When to execute this reference */
+    readonly $when?: ProcedureWhen;
+    /**
+     * Phantom type for output inference.
+     * Not present at runtime, used for TypeScript type inference.
+     */
+    readonly __output?: TOutput;
+}
+/**
+ * JSON-serializable form of a procedure reference.
+ * Uses `$proc` key instead of Symbol for JSON compatibility.
+ */
+export interface ProcedureRefJson<TInput = unknown> {
+    /** JSON key identifying this as a procedure reference */
+    readonly $proc: ProcedurePath;
+    /** Pre-bound input for the procedure */
+    readonly input?: TInput;
+    /** Optional name for this execution context (for nested refs to target) */
+    readonly $name?: string;
+    /**
+     * When to execute this reference:
+     * - "$immediate" (or absent): Execute during hydration
+     * - "$never": Never execute, pass as pure data
+     * - "$parent": Defer to parent procedure
+     * - "someName": Defer to named ancestor context
+     */
+    readonly $when?: ProcedureWhen;
+}
+/**
+ * Either a runtime ProcedureRef or JSON-serialized form.
+ */
+export type AnyProcedureRef<TInput = unknown, TOutput = unknown> = ProcedureRef<TInput, TOutput> | ProcedureRefJson<TInput>;
+/**
+ * Check if a value is a procedure reference (runtime form with Symbol).
+ */
+export declare function isProcedureRef(value: unknown): value is ProcedureRef;
+/**
+ * Check if a value is a JSON procedure reference (serialized form with $proc key).
+ */
+export declare function isProcedureRefJson(value: unknown): value is ProcedureRefJson;
+/**
+ * Check if a value is any form of procedure reference.
+ */
+export declare function isAnyProcedureRef(value: unknown): value is AnyProcedureRef;
+/**
+ * Check if a value is an output reference ($ref).
+ */
+export declare function isOutputRef(value: unknown): value is OutputRef;
+/**
+ * Get the $when value from a procedure reference.
+ * Returns "$immediate" if not specified.
+ */
+export declare function getRefWhen(ref: AnyProcedureRef): ProcedureWhen;
+/**
+ * Get the $name value from a procedure reference, if any.
+ */
+export declare function getRefName(ref: AnyProcedureRef): string | undefined;
+/**
+ * Check if a procedure reference should be executed in the given context.
+ *
+ * @param ref - The procedure reference to check
+ * @param contextStack - Stack of named contexts (innermost first)
+ * @param isParentContext - Whether we're checking from a parent procedure
+ * @returns true if the ref should be executed now
+ */
+export declare function shouldExecuteRef(ref: AnyProcedureRef, contextStack: string[], isParentContext?: boolean): boolean;
+/**
+ * Builder for creating procedure references with a fluent API.
+ */
+export declare class ProcedureRefBuilder<TInput = unknown, TOutput = unknown> {
+    private _path;
+    private _input;
+    private _name?;
+    private _when?;
+    constructor(path: ProcedurePath);
+    /**
+     * Set the input for this procedure reference.
+     */
+    input<T>(input: T): ProcedureRefBuilder<T, TOutput>;
+    /**
+     * Name this execution context (for nested refs to target with $when).
+     */
+    name(name: string): this;
+    /**
+     * Set when this reference should be executed.
+     * @param when - "$immediate", "$never", "$parent", or a named context
+     */
+    when(when: ProcedureWhen): this;
+    /**
+     * Shorthand for .when("$never") - pass as pure data.
+     */
+    defer(): this;
+    /**
+     * Shorthand for .when("$parent") - defer to parent procedure.
+     */
+    deferToParent(): this;
+    /**
+     * Build the procedure reference object.
+     */
+    build(): ProcedureRef<TInput, TOutput>;
+    /**
+     * Convert to JSON-serializable form.
+     */
+    toJson(): ProcedureRefJson<TInput>;
+    /**
+     * Alias for build() - makes the builder callable in expression contexts.
+     */
+    get ref(): ProcedureRef<TInput, TOutput>;
+}
+/**
+ * Create a procedure reference.
+ *
+ * @param path - Path to the procedure
+ * @returns Builder for the procedure reference
+ *
+ * @example
+ * ```typescript
+ * // Simple reference
+ * const addRef = proc(["git", "add"]).input({ all: true }).build();
+ *
+ * // Nested references (procedures as inputs)
+ * const pipeline = proc(["client", "chain"]).input({
+ *   steps: [
+ *     proc(["git", "add"]).input({ all: true }).ref,
+ *     proc(["git", "commit"]).input({ message: "auto" }).ref,
+ *   ],
+ * }).build();
+ * ```
+ */
+export declare function proc<TOutput = unknown>(path: ProcedurePath): ProcedureRefBuilder<unknown, TOutput>;
+/**
+ * Convert a procedure reference from JSON form to runtime form.
+ * The `$name` and `$when` fields stay (deep dive CORE-11: before, they were dropped).
+ */
+export declare function fromJson<TInput, TOutput>(json: ProcedureRefJson<TInput>): ProcedureRef<TInput, TOutput>;
+/**
+ * Convert a procedure reference from runtime form to JSON form.
+ * The `$name` and `$when` fields stay.
+ */
+export declare function toJson<TInput>(ref: ProcedureRef<TInput>): ProcedureRefJson<TInput>;
+/**
+ * Normalize any procedure reference to runtime form.
+ */
+export declare function normalizeRef<TInput, TOutput>(ref: AnyProcedureRef<TInput, TOutput>): ProcedureRef<TInput, TOutput>;
+/**
+ * Executor function type for hydration.
+ * Called for each procedure reference found during hydration.
+ */
+export type RefExecutor = <TInput, TOutput>(path: ProcedurePath, input: TInput) => Promise<TOutput>;
+/**
+ * Options for input hydration.
+ */
+export interface HydrateOptions {
+    /**
+     * Maximum nesting of procedure refs (default: 10). Plain data does not count: only the input
+     * of a ref inside the input of another ref adds one level.
+     */
+    maxDepth?: number | undefined;
+    /**
+     * Whether sibling refs run at the same time (default: false). With false, the refs run one
+     * after the other, from left to right and depth first, so the order of their effects is known.
+     */
+    parallel?: boolean | undefined;
+    /**
+     * The context names of the runner. A ref with `$when: "<name>"` runs only when this list has
+     * the name. A runner such as `core.catch` gives its own name here when it hydrates its operand.
+     */
+    contextStack?: string[] | undefined;
+    /**
+     * Scope for resolving output references ($ref). Without a scope, a `$ref` object stays as it
+     * is (for example a JSON Schema reference). With a scope, a `$ref` name that no scope has is an error.
+     */
+    scope?: RefScope | undefined;
+    /**
+     * This function tells whether the procedure at a path takes its input raw (control flow, the
+     * `runs-refs` and `raw-input` tags). Such a procedure gets the refs of its input unchanged and
+     * runs them itself. The default knows the core control-flow paths only. See `rawInputRule()`.
+     */
+    rawInput?: ((path: ProcedurePath) => boolean) | undefined;
+    /**
+     * This function gets an event each time hydration runs a ref (see `HydrationEvent`). A trace
+     * uses it to show a nested call under the call that gets its result. An error of the function
+     * does not change the hydration.
+     */
+    onRef?: ((event: HydrationEvent) => void) | undefined;
+}
+/**
+ * An event of hydration: a procedure ref of the input runs now. Its input is hydrated already,
+ * so the events of the refs inside its input came first.
+ */
+export interface HydrationEvent {
+    /** The path of the procedure that runs. */
+    readonly path: ProcedurePath;
+    /**
+     * The ref that runs: the object of the program. For an array of refs that runs as an implicit
+     * chain, it is the `client.chain` ref that hydration made.
+     */
+    readonly ref: AnyProcedureRef;
+    /**
+     * The ref whose input holds this ref: the call that gets the result. It is undefined when the
+     * ref is at the top of the hydrated value. Then the caller of the hydration gets the result:
+     * `exec()` gives it to the root call, and a control-flow procedure to its operand call.
+     */
+    readonly consumer: AnyProcedureRef | undefined;
+}
+/**
+ * This function adds an observer of every hydration in this process (or worker), and gives the
+ * function that removes it. A host that does not call `hydrateInput` itself (the Composer of
+ * the site runs `client.exec()`) uses it for its trace. The observer gets the events of all
+ * concurrent hydrations: use it where one program runs at a time. For the events of one program,
+ * give `onRef` to that program: `client.exec(ref, input, { onRef })` (docs review DOC-10).
+ */
+export declare function observeHydration(observer: (event: HydrationEvent) => void): () => void;
+/** The maximum nesting of plain data in an input. A deeper input is an error, not a stack overflow. */
+export declare const MAX_DATA_DEPTH = 1000;
+/**
+ * Hydrate an input tree by executing any nested procedure references.
+ *
+ * Walks the input object tree and replaces any ProcedureRef or ProcedureRefJson
+ * objects with the result of executing that procedure, respecting $when timing.
+ *
+ * The rules:
+ * - A ref with `$when: "$immediate"` (the default) runs. A ref whose procedure takes its input
+ *   raw (see `HydrateOptions.rawInput`) gets its input unchanged, with the scope attached.
+ * - A ref with `$when: "$never"` stays as it is, with its whole subtree.
+ * - A ref with `$when: "$parent"` or `$when: "<name>"` stays data for its runner. Its procedure
+ *   gets that ref later. The immediate refs of its input run now, unless the procedure takes its
+ *   input raw. A named ref runs now only when `contextStack` has the name.
+ * - A `$ref` object gives a value from the scope. `{ $literal: value }` gives the value unchanged.
+ * - An array whose items are all refs that run now, outside the input of a ref, runs as one
+ *   `client.chain`. An array with a deferred ref is a list.
+ * - Values that are not plain data (`Date`, `Map`, typed arrays, class instances) stay unchanged.
+ *   A subtree without refs stays the same object.
+ *
+ * @param input - The input object potentially containing procedure references
+ * @param executor - Function to execute procedure references
+ * @param options - Hydration options
+ * @returns The hydrated input with executed procedure refs replaced by their results
+ *
+ * @example
+ * ```typescript
+ * const input = {
+ *   visit: proc(["git", "add"]).input({ all: true }).build(),
+ *   config: { nested: true },
+ * };
+ *
+ * const hydrated = await hydrateInput(input, async (path, input) => {
+ *   return await client.call({ path, input });
+ * });
+ *
+ * // hydrated.visit is now the result of executing git.add
+ * ```
+ */
+export declare function hydrateInput<T>(input: T, executor: RefExecutor, options?: HydrateOptions): Promise<T>;
+/**
+ * The path and the input of the root call of a program: the call that `client.exec()` starts.
+ * `exec()` and the body of a procedure that `procedure.define` made both use this function, so
+ * the same program gives the same result in both (docs review DOC-3: before, a defined body
+ * hydrated its root call as a nested ref).
+ *
+ * The rules of the root call:
+ * - A `$when` on the root call does not apply: the caller starts the root call now.
+ * - A procedure that takes its input raw (`rawInput`) gets its input unchanged, with the scope
+ *   attached, and runs its operands itself.
+ * - Another procedure gets its input hydrated as a root: a list of calls that run now is an
+ *   implicit chain, and the nested refs run.
+ *
+ * The caller then starts the call with the path and the input.
+ */
+export declare function prepareRootCall(ref: AnyProcedureRef, executor: RefExecutor, options?: Pick<HydrateOptions, "rawInput" | "onRef" | "scope">): Promise<{
+    path: ProcedurePath;
+    input: unknown;
+}>;
+/**
+ * Last path segments of the core control-flow procedures (registered under `["client", ...]`).
+ *
+ * These procedures MUST receive their operand refs RAW so their handlers can execute
+ * them with correct ordering, laziness, short-circuiting, and error scoping. If `exec()`
+ * eagerly hydrated their inputs, the operands would run up-front (voiding conditional/
+ * tryCatch short-circuiting) and an all-refs array would be hijacked into an implicit
+ * chain that clobbers `steps` — the outer handler then throws `steps is not iterable`.
+ * See documentation/BUGS-2026-07.md (C2, H2, H3, M35).
+ */
+export declare const CONTROL_FLOW_PROCEDURES: ReadonlySet<string>;
+/**
+ * Whether a procedure path is one of the core control-flow procedures (`client.chain`,
+ * `client.map` and the others). The whole path must match: a user procedure `foo.map` is not
+ * control flow (deep dive CORE-5: before, only the last segment was compared).
+ */
+export declare function isControlFlowPath(path: ProcedurePath): boolean;
+/**
+ * The tag of a procedure that runs procedure refs from its input (for example `dag.traverse`).
+ * A server with an `expose` rule lets such a procedure call only the exposed procedures.
+ * Hydration gives such a procedure its input raw.
+ */
+export declare const RUNS_REFS_TAG = "runs-refs";
+/**
+ * The tag of a procedure that takes refs as data and does not run them (for example
+ * `client.export`, which writes a ref as JSON). Hydration gives such a procedure its input raw.
+ */
+export declare const RAW_INPUT_TAG = "raw-input";
+/** The fields of a procedure that the rules of this module read. */
+interface ProcedureShape {
+    path: ProcedurePath;
+    metadata?: {
+        tags?: string[] | undefined;
+    } | undefined;
+    handler?: unknown;
+}
+/**
+ * This function marks a procedure whose behavior comes from data, for example a procedure
+ * that `procedure.define` made from an aggregation. The mark is on the handler function: the
+ * registry stores a copy of each procedure, but the copy has the same handler. The mark is not
+ * in the metadata, because the caller of `procedure.define` gives the metadata.
+ */
+export declare function markDataDriven<T extends {
+    handler?: unknown;
+}>(procedure: T): T;
+/**
+ * A data-driven procedure runs procedure refs that come from its input or from data: the
+ * control-flow procedures, the procedures with the `runs-refs` tag and the procedures that
+ * `procedure.define` made. The caller of such a procedure chooses what it calls.
+ */
+export declare function isDataDriven(procedure: ProcedureShape): boolean;
+/**
+ * A procedure that takes its input raw: the control-flow procedures and the procedures with the
+ * `runs-refs` or `raw-input` tag. `exec()` and hydration do not run the refs of such an input.
+ * A procedure that `procedure.define` made takes ordinary input: its body is the data-driven part.
+ */
+export declare function takesRawInput(procedure: ProcedureShape): boolean;
+/**
+ * The raw-input rule of a registry, for `HydrateOptions.rawInput`. The procedure at the path
+ * decides (deep dive CORE-5). A path that the registry does not have uses the control-flow paths.
+ */
+export declare function rawInputRule(registry: {
+    get(path: ProcedurePath): ProcedureShape | undefined;
+} | undefined): (path: ProcedurePath) => boolean;
+/**
+ * Execute a deferred procedure reference.
+ *
+ * This is a helper for procedures that receive deferred refs (via $when)
+ * and need to execute them with additional context.
+ *
+ * @param ref - The procedure reference to execute
+ * @param executor - Function to execute the procedure
+ * @param additionalInput - Additional input to merge (e.g., cwd for dag.traverse)
+ * @param options - Hydration options for the input of the ref (for example the runner's `contextStack`)
+ * @returns The result of executing the procedure
+ *
+ * @example
+ * ```typescript
+ * // In dag.traverse, execute a deferred ref with cwd
+ * const result = await executeRef(
+ *   input.visit,
+ *   (path, input) => ctx.client.call(path, input),
+ *   { cwd: node.repoPath }
+ * );
+ * ```
+ */
+export declare function executeRef<TOutput = unknown>(ref: AnyProcedureRef, executor: RefExecutor, additionalInput?: Record<string, unknown>, options?: HydrateOptions): Promise<TOutput>;
+/**
+ * Extract a JSON template from a procedure reference.
+ * Useful for serializing imperative procedure compositions.
+ * The `$name` and `$when` fields stay. A `$literal` stays as it is.
+ *
+ * @param ref - Procedure reference to extract template from
+ * @returns JSON-serializable template
+ */
+export declare function extractTemplate<TInput>(ref: ProcedureRef<TInput>): ProcedureRefJson<unknown>;
+/**
+ * Parse JSON string and convert $proc objects to runtime ProcedureRef objects.
+ * The `$name` and `$when` fields stay. A `$literal` stays as it is.
+ *
+ * @param json - JSON string potentially containing procedure references
+ * @returns Parsed object with ProcedureRef objects
+ */
+export declare function parseProcedureJson<T>(json: string): T;
+/**
+ * Stringify an object with procedure refs to JSON.
+ * Converts ProcedureRef objects to $proc JSON form.
+ *
+ * @param value - Object potentially containing ProcedureRef objects
+ * @param space - Indentation (passed to JSON.stringify)
+ * @returns JSON string
+ */
+export declare function stringifyProcedureJson(value: unknown, space?: number): string;
+export {};
+//# sourceMappingURL=ref.d.ts.map

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

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