@procedures/client 0.25.0 → 0.26.1

package/dist/procedures/program.d.ts

@@ -0,0 +1,251 @@
+/**
+ * Programs on the coeval kernel (coeval decisions D9, D10 and D13, roadmap item M14).
+ *
+ * A program runs as a run document of `@mark1russell7/coeval`. This module holds the parts that
+ * are the program format's own:
+ *
+ * - The world of a program: a call kind for each procedure path (an open world), the kinds of
+ *   the control-flow procedures with their parts and their names, and the kinds `lit`, `ref`,
+ *   `program.data`, `program.record`, `program.deferred` and `program.fail`.
+ * - The desugarer: it changes the `$proc` form into a run document. The rules of hydration
+ *   (implicit chains, `$when`, `$literal`, the limits) decide the shape of the document.
+ * - The runners of the kinds, and the boundary: each call is an effect, and the host does it
+ *   with the client (`client.call`). Thus `invokeProcedure()` stays the authority for the
+ *   admission, the validation, the interceptors and the exposure rules of each call.
+ *
+ * The kernel does the rest: the order of the parts, the names of a scope, the references, the
+ * parts at the same time, the error values and the static check.
+ */
+import { type EvalError, type Json, type Key, type Machine, type World } from "@mark1russell7/coeval";
+import { type AnyProcedureRef, type HydrateOptions, type HydrationEvent, type RefExecutor, type RefScope } from "./ref.js";
+import type { ProcedurePath } from "./types.js";
+/**
+ * This function gives the key of a `$proc` name in the names of the kernel. The kernel name
+ * `last` is the result of the step before, so a step with the name `last` gets the key `$last`
+ * (and `$last` gets `$$last`). The change is one to one, so no two names get the same key.
+ */
+export declare function nameKey(name: string): string;
+/** This function gives the `$proc` name of a key of the kernel names (the inverse of `nameKey()`). */
+export declare function nameOfKey(key: string): string;
+/**
+ * This function gives the names of the kernel for a scope of the `$proc` form. The outer scopes
+ * come first, so an inner name wins. The innermost `last` wins too, as `lookupOutputRef()` reads it.
+ */
+export declare function namesOfScope(scope: RefScope | undefined): Record<string, unknown>;
+/** This function gives a scope of the `$proc` form for the names of the kernel, for `withScope()`. */
+export declare function scopeOfNames(names: Readonly<Record<string, unknown>>): RefScope;
+/**
+ * The world of a program. It is open: each path that starts with a key that the world does not
+ * have is a call. A path that starts with a key of the world goes under the namespace `procs`.
+ */
+export declare const PROGRAM_WORLD: World;
+/** A run document. Its value can hold values of the host (a literal of a `Date`, a `Map` or a runtime ref). */
+export interface ProgramDocument {
+    readonly type: Json;
+    readonly value: unknown;
+    readonly name?: string;
+    readonly own?: Readonly<Record<string, string>>;
+}
+/**
+ * The origin of a document of the desugarer: the object of the `$proc` form, its JSON pointer
+ * (RFC 6901) in the program, and the facts that the run needs about its position.
+ */
+export interface DocumentOrigin {
+    /** The object of the program: a call, a `$ref`, or the input of a control-flow procedure. */
+    readonly source: unknown;
+    /** The JSON pointer of the source in the program. The empty string is the root. */
+    readonly pointer: string;
+    /** True when the position has a scope: a raw call then gets the scope (`withScope()`). */
+    readonly scoped: boolean;
+    /** For a call: the nearest call whose input holds it, in the same hydration. */
+    readonly consumer?: AnyProcedureRef | undefined;
+    /** For a `$ref` in the input of a deferred call: an unknown name stays data for the runner. */
+    readonly deferred?: boolean | undefined;
+    /** True for the `client.chain` call that an array of calls makes (an implicit chain). */
+    readonly synthesized?: boolean | undefined;
+    /** For a call: its path, its input and its `$name`, as `normalizeRef()` gives them. */
+    readonly call?: {
+        readonly path: ProcedurePath;
+        readonly input: unknown;
+        readonly $name?: string | undefined;
+    } | undefined;
+}
+/**
+ * This function gives the document at a place of a run document, for example the place of an issue
+ * of `check()` of coeval. A part that is the whole value of its document has the same place as its
+ * document: the function gives the deepest document at the place.
+ */
+export declare function documentAt(doc: unknown, place: readonly Key[]): unknown;
+/** This function gives the origin of a document that the desugarer made, or undefined. */
+export declare function originOf(doc: unknown): DocumentOrigin | undefined;
+/** The settings of one desugaring: the rules of one hydration. */
+export interface DesugarOptions {
+    /** True for a procedure that takes its input raw (`rawInputRule()`). The default knows the control-flow paths. */
+    readonly rawInput?: ((path: ProcedurePath) => boolean) | undefined;
+    /** The context names of the runner (`HydrateOptions.contextStack`). */
+    readonly contextStack?: readonly string[] | undefined;
+    /** The most nested calls (`HydrateOptions.maxDepth`, default 10). */
+    readonly maxDepth?: number | undefined;
+    /** True when the hydration has a scope. Without a scope, a `$ref` object is data. */
+    readonly scoped?: boolean | undefined;
+    /**
+     * True: the operands of a control-flow call in the program become documents too, for a static
+     * check. The default (false) keeps them data: the procedure gets them raw, and it runs them.
+     */
+    readonly expand?: boolean | undefined;
+}
+/**
+ * This function desugars the input of a control-flow procedure: its operands become documents,
+ * and the other fields stay data. It gives undefined when the input does not have the shape of
+ * the procedure. The operands of a procedure without a scope have no scope (`scopeOf()`), except
+ * the operands that the procedure gives names: the steps of a chain, `catch` and `fn`.
+ */
+export declare function desugarControlValue(name: string, input: unknown, options?: DesugarOptions): Record<string, unknown> | undefined;
+/** This function desugars a value of a hydration: the root of `hydrateInput()`. Data gives undefined. */
+export declare function desugarInput(input: unknown, options?: DesugarOptions): ProgramDocument | undefined;
+/**
+ * This function desugars a program: the root call of `client.exec()` (`prepareRootCall()`). A
+ * `$when` on the root call does not apply: the caller starts the root call now. Its input is a new
+ * hydration.
+ */
+export declare function desugarProgram(program: AnyProcedureRef, options?: DesugarOptions): ProgramDocument;
+/** Where a call is: the root call of a program, an operand of control flow, or a call in an input. */
+export type CallPosition = "root" | "operand" | "nested";
+/** The payload of the effect of a call. */
+export interface CallEffect {
+    readonly position: CallPosition;
+    /** The input of the call: hydrated, or raw with the scope of the caller. */
+    readonly input: unknown;
+    /** The call object of the program. */
+    readonly source: unknown;
+    /** The nearest call whose input holds the call (for `HydrationEvent.consumer`). */
+    readonly consumer: AnyProcedureRef | undefined;
+}
+/** What a machine of programs needs from its host. */
+export interface ProgramHost {
+    /** True for a procedure that takes its input raw. The procedure in the registry decides at the time of the call. */
+    readonly rawInput: (path: ProcedurePath) => boolean;
+    /** True: the documents of a value start at the same time (`HydrateOptions.parallel`). */
+    readonly parallel?: boolean | undefined;
+}
+/** The parent context that the control-flow procedures give to their operand calls. */
+export declare function parentContext(input: {
+    cwd?: unknown;
+    node?: unknown;
+}): Record<string, unknown>;
+/** The value that a failed result throws at the boundary: the error of the host, or an error with the reason. */
+export declare function thrownValue(error: EvalError): unknown;
+/**
+ * This function makes the machine of a run of programs: the world of a program, its evaluators
+ * and its runners. The kernel capabilities permit each call: the authority is `invokeProcedure()`,
+ * through the host of each effect.
+ */
+export declare function programMachine(host: ProgramHost): Machine;
+/**
+ * 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 options of a run of a document. */
+export interface RunDocumentOptions {
+    /** The function that does a call. */
+    readonly executor: RefExecutor;
+    /** The function that does the root call of a program. The default is `executor`. */
+    readonly rootExecutor?: ((path: ProcedurePath, input: unknown) => unknown) | undefined;
+    /** The raw-input rule (`rawInputRule()`). The default knows the control-flow paths. */
+    readonly rawInput?: ((path: ProcedurePath) => boolean) | undefined;
+    /** The observer of the calls that start in the run. */
+    readonly onRef?: ((event: HydrationEvent) => void) | undefined;
+    /** The scope of the run: its names are the names of the root. */
+    readonly scope?: RefScope | undefined;
+    /** True: the documents of a value start at the same time. */
+    readonly parallel?: boolean | undefined;
+}
+/**
+ * This function runs a document on the kernel (`prepare(...).run(...)`). Each call is an effect:
+ * the host does it with the executor. A failed run throws the error of the host (the cause of the
+ * error value), so a caller gets the same error as from the call itself.
+ */
+export declare function runDocument(doc: ProgramDocument, options: RunDocumentOptions & {
+    readonly self?: unknown;
+}): Promise<unknown>;
+/**
+ * Hydrate an input tree by executing any nested procedure references.
+ *
+ * The input becomes a run document (`desugarInput()`), and the kernel runs it. Each call of the
+ * input is an effect: the executor does it, and its result takes the place of the call.
+ *
+ * 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
+ */
+export declare function hydrateInput<T>(input: T, executor: RefExecutor, options?: HydrateOptions): Promise<T>;
+/**
+ * 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. The fields of `additionalInput` go over the input of the ref. A
+ * procedure that takes its input raw gets it with the scope. Another procedure gets it hydrated
+ * (`hydrateInput()`), with the options (for example the runner's `contextStack`).
+ *
+ * @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
+ * @returns The result of executing the procedure
+ */
+export declare function executeRef<TOutput = unknown>(ref: AnyProcedureRef, executor: RefExecutor, additionalInput?: Record<string, unknown>, options?: HydrateOptions): Promise<TOutput>;
+/** The options of `runProgram()`. */
+export interface RunProgramOptions extends RunDocumentOptions {
+}
+/**
+ * This function runs a program: its root call is the root document of one kernel run. A `$when`
+ * on the root call does not apply. A procedure that takes its input raw gets its input with the
+ * scope. Another procedure gets its input hydrated as a root: a list of calls is an implicit chain.
+ * `client.exec()` and the body of a procedure that `procedure.define` made use it (docs review DOC-3).
+ */
+export declare function runProgram(program: AnyProcedureRef, options: RunProgramOptions): Promise<unknown>;
+/**
+ * The path and the input of the root call of a program: the call that `client.exec()` starts.
+ * The kernel runs the program (`runProgram()`) up to its root call, and the function gives the
+ * path and the input of that call. The caller then starts the call.
+ */
+export declare function prepareRootCall(ref: AnyProcedureRef, executor: RefExecutor, options?: Pick<HydrateOptions, "rawInput" | "onRef" | "scope">): Promise<{
+    path: ProcedurePath;
+    input: unknown;
+}>;
+/** The options of `runOperand()`. */
+export interface RunOperandOptions extends RunDocumentOptions {
+    /** The parent context that the operand call gets in its input (`cwd`, `node`). */
+    readonly extra?: Record<string, unknown> | undefined;
+}
+/**
+ * This function runs an operand of a control-flow procedure (`callOperand()`, `evaluateOperand()`).
+ * A call is an operand call: only `$never` holds it back, its input is a new hydration, and it gets
+ * the parent context. Another value is a new hydration.
+ */
+export declare function runOperand(value: unknown, options: RunOperandOptions): Promise<unknown>;
+/**
+ * This function runs a control-flow procedure on the kernel: its input becomes a document of its
+ * kind, and the runner of the kind runs the operands. The input is raw: its scope (`scopeOf()`)
+ * gives the names of the caller.
+ */
+export declare function runControl(name: string, input: unknown, options: RunDocumentOptions): Promise<unknown>;
+//# sourceMappingURL=program.d.ts.map

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

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