@evoke-build/evoke 0.8.0 → 0.10.0

package/dist/contain.d.ts

@@ -1,4 +1,6 @@
-import type { Contained, Facts, NeedsKey, Place, Policy, Program } from "./types.ts";
+import type { Contained, Facts, NeedsKey, Place, Platform, Policy, Program } from "./types.ts";
+/** This machine's platform, which the plan and the layers take. */
+export declare const PLATFORM: Platform;
 /** What the machine lacks that the declaration names: a path, or a program `PATH` does not hold. */
 export type Missing = {
     place: Place;

package/dist/contain.js

@@ -8,7 +8,8 @@ import { accessSync, closeSync, constants, mkdtempSync, openSync, readSync, real
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 import { call } from "./core.js";
-const PLATFORM = process.platform === "linux" ? "linux" : "macos";
+/** This machine's platform, which the plan and the layers take. */
+export const PLATFORM = process.platform === "linux" ? "linux" : "macos";
 const SANDBOX_EXEC = "/usr/bin/sandbox-exec";
 /** Whether this runtime's permission model holds the network: from Node 25, the first to know `--allow-net`. */
 const HOLDS_NETWORK = process.allowedNodeEnvironmentFlags.has("--allow-net");

package/dist/errors.d.ts

@@ -22,11 +22,13 @@ export declare class FaultError extends EvokeError {
     readonly fault: Fault;
     constructor(fault: Fault, message: string, command: string);
 }
-/** A host or a body failed: what was attempted, why, and what to do; a body's own error is the `cause`. */
+/** A host or a body failed: what was attempted, why, and what to do; a body's own error is the `cause`, and the
+ *  frames of an error a file body threw are `frames`, from the first. */
 export declare class FailureError extends EvokeError {
     readonly kind = "failure";
     readonly what: string;
     readonly why: string | undefined;
     readonly fix: Fix;
-    constructor(what: string, why: string | undefined, fix: Fix, command: string, options?: ErrorOptions);
+    readonly frames: readonly string[];
+    constructor(what: string, why: string | undefined, fix: Fix, command: string, options?: ErrorOptions, frames?: readonly string[]);
 }

package/dist/errors.js

@@ -30,17 +30,20 @@ export class FaultError extends EvokeError {
         this.fault = fault;
     }
 }
-/** A host or a body failed: what was attempted, why, and what to do; a body's own error is the `cause`. */
+/** A host or a body failed: what was attempted, why, and what to do; a body's own error is the `cause`, and the
+ *  frames of an error a file body threw are `frames`, from the first. */
 export class FailureError extends EvokeError {
     kind = "failure";
     what;
     why;
     fix;
-    constructor(what, why, fix, command, options) {
+    frames;
+    constructor(what, why, fix, command, options, frames = []) {
         super(`${what}${why === undefined ? "" : `: ${why}`}  →  ${command}`, command, options);
         this.what = what;
         this.why = why;
         this.fix = fix;
+        this.frames = frames;
     }
 }
 /** The CLI's line for one problem. */

package/dist/ops.d.ts

@@ -109,6 +109,7 @@ export interface Ops {
         input: {
             set: T.Installed;
             limits?: T.Limits;
+            platform?: T.Platform;
         };
         output: T.Result<T.Plan, T.Diagnostic>;
     };
@@ -183,11 +184,12 @@ export interface Ops {
         input: {
             chosen: T.Chosen;
             active: T.Active;
+            taken?: Record<T.ArgName, T.Json>;
             input: T.Input;
             deadline: T.Millis;
             home: string;
         };
-        output: T.Envelope;
+        output: T.Result<T.Envelope, T.Diagnostic>;
     };
     argv: {
         input: {
@@ -368,7 +370,8 @@ export interface Ops {
     thieves: {
         input: {
             newcomers: T.LocalName[];
-            routed: [T.Case, T.LocalName | null][];
+            routed: T.Routed[];
+            floor?: T.Prob;
         };
         output: T.Theft[];
     };
@@ -394,6 +397,7 @@ export interface Ops {
     "weave.plan": {
         input: {
             plan: T.Plan;
+            gate?: T.Gate;
             input: string;
             tags: T.Tag[];
             answers: T.Answers;

package/dist/project.d.ts

@@ -14,6 +14,9 @@ export interface LoadOptions<R = AnyReflexes> {
     } | undefined;
     /** Who answers. Absent: the adapter evoke.toml names, from its own subpath; required without a root. */
     adapter?: Adapter | undefined;
+    /** The platform a manifest's `platforms` is judged by: this machine's when absent. A reflex named for another
+     *  is inactive; name one to decide or test as that machine would. A body still runs here. */
+    platform?: W.Platform | undefined;
 }
 export interface DecideOptions {
     /** Only reflexes carrying one of these tags are offered. */
@@ -129,6 +132,7 @@ export declare function load<R extends object = AnyReflexes>(options: {
         [K in keyof R]?: Inline<R[K]> | undefined;
     }> | undefined;
     adapter?: Adapter | undefined;
+    platform?: W.Platform | undefined;
 }): Promise<Project<R>>;
 /** A project from reflexes handed as code alone: R is inferred from them. */
 export declare function load<R extends object = AnyReflexes>(options: {
@@ -137,4 +141,5 @@ export declare function load<R extends object = AnyReflexes>(options: {
         [K in keyof R]?: Inline<R[K]> | undefined;
     } | undefined;
     adapter: Adapter;
+    platform?: W.Platform | undefined;
 }): Promise<Project<R>>;

package/dist/project.js

@@ -7,7 +7,7 @@
 import { realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { answered } from "./adapter.js";
-import { facts, scratch, status } from "./contain.js";
+import { PLATFORM, facts, scratch, status } from "./contain.js";
 import { bug, call, command, fromCode, misnamed, problem, reply } from "./core.js";
 import { DiagnosticError, FailureError } from "./errors.js";
 import { entry, snapshot, text } from "./files.js";
@@ -93,7 +93,8 @@ export async function load(options) {
         vocab[name] = call("vocabulary", { doc: { file: { type: "vocab", name }, toml } }, "load()");
     }
     const installed = { reflexes, vocab, adapter: adapter.id, evoke: call("version", {}) };
-    return make({ installed, adapter, dirs, bodies, shipped, local }, "load()");
+    const platform = options.platform ?? PLATFORM;
+    return make({ installed, adapter, platform, dirs, bodies, shipped, local }, "load()");
 }
 /** The adapter evoke.toml names, from its own subpath; a recording is never resolved by name. */
 async function named(project, root) {
@@ -169,17 +170,19 @@ function shown(input) {
 function key(asked) {
     return JSON.stringify([asked.text, asked.tags ?? [], asked.only ?? null]);
 }
-/** What the planner asked to decide a step, as its repair tells: a fragment narrowed to its neighbour's reflex, or
- *  spliced into its words, was decided under that reflex alone; any other step over the tags. */
+/** What the planner asked to decide a step, as its repair and its shared words tell: a fragment narrowed to its
+ *  neighbour's reflex, or spliced into its words, was decided under that reflex alone, and so were words a shared word
+ *  was written into; any other step over the tags. */
 function askedFor(step, tags) {
-    const own = step.repair === "narrowed" || step.repair === "spliced" ? step.reflex : undefined;
+    const narrowed = step.repair === "narrowed" || step.repair === "spliced" || Object.values(step.shared ?? {}).some(shared => shared.via === "rewrite");
+    const own = narrowed ? step.reflex : undefined;
     return own === undefined ? { text: step.text, tags } : { text: step.text, only: own };
 }
 /** The project over its ground: the set compiled, every reflex's status read off the plan. The implementation
  *  speaks the wire's shapes; the app's R lives on the interface alone. */
 function make(ground, invoked) {
-    const { installed, adapter, dirs, bodies, shipped, local } = ground;
-    const plan = call("compile", { set: installed, ...(adapter.limits === undefined ? {} : { limits: adapter.limits }) }, invoked);
+    const { installed, adapter, platform, dirs, bodies, shipped, local } = ground;
+    const plan = call("compile", { set: installed, platform, ...(adapter.limits === undefined ? {} : { limits: adapter.limits }) }, invoked);
     if (adapter.plan !== undefined && adapter.plan !== plan.digest) {
         const message = `the recording was made against plan ${adapter.plan}, not ${plan.digest}`;
         throw new DiagnosticError([{ message, fix: { type: "rerun" }, command: "replay(file, { record: jev() })" }]);
@@ -248,27 +251,18 @@ function make(ground, invoked) {
             }
             if (outcome !== "run" && outcome !== "confirm")
                 throw new TypeError(`a ${outcome} decision cannot run`);
-            const active = plan.active[chosen.reflex];
-            if (active === undefined)
-                throw refused(chosen.reflex, `${chosen.reflex} is not active`, { type: "rerun" }, "run(d)");
-            const spent = chosen.trace.reduce((sum, entry) => sum + entry.ms, 0);
-            // The whole decision crosses: the core reads the fields of a Chosen and ignores the SDK's own.
-            const wire = chosen;
-            const envelope = call("envelope", { chosen: wire, active, input: chosen.input, deadline: Math.max(plan.deadline - spent, 0), home: homedir() });
-            const what = `running ${chosen.reflex}`;
-            const body = bodies[chosen.reflex];
-            if (body !== undefined)
-                return inline(what, body, envelope, options.signal);
-            const dir = dirs[chosen.reflex];
-            if (dir === undefined)
-                throw refused(chosen.reflex, `${chosen.reflex} has no body to run`, { type: "sync" }, "run(d)");
-            return contained(what, chosen, active, dir, envelope, options.signal);
+            // A whole result is handed by the plan alone: a call that takes one runs only as a step of a weave.
+            taker(chosen);
+            return running(chosen, {}, options);
         },
         async handle(input, options = {}) {
             nonEmpty(input, "handle");
-            const readied = await ready(await project.decide(input, options), options);
+            const decision = await project.decide(input, options);
+            if (decision.outcome !== "abstain")
+                taker(decision);
+            const readied = await ready(decision, options);
             if (readied.ready)
-                return { outcome: "ran", decision: readied.decision, result: await bodied(readied.decision, options.signal) };
+                return { outcome: "ran", decision: readied.decision, result: await running(readied.decision, {}, signalled(options.signal)) };
             if (readied.status === "refused")
                 return { outcome: "abstained", decision: readied.decision };
             return { outcome: readied.status, decision: readied.decision };
@@ -308,7 +302,7 @@ function make(ground, invoked) {
     async function planned(input, options, answers, traces) {
         const invoked = `steps(${JSON.stringify(shown(input))})`;
         for (;;) {
-            const planning = call("weave.plan", { plan, input, tags: options.tags ?? [], answers }, invoked);
+            const planning = call("weave.plan", { plan, ...gate, input, tags: options.tags ?? [], answers }, invoked);
             if (planning.type === "done")
                 return planning.weave;
             const { need } = planning;
@@ -446,7 +440,7 @@ function make(ground, invoked) {
                     record(handling, readied.decision, { status: readied.status, why: readied.why });
                     continue;
                 }
-                bodies.push(ran(readied.decision, signal).then(became => record(handling, readied.decision, became)));
+                bodies.push(ran(readied.decision, handling.taken ?? {}, signal).then(became => record(handling, readied.decision, became)));
             }
             await Promise.all(bodies);
         }
@@ -506,16 +500,40 @@ function make(ground, invoked) {
             ...(ask === undefined ? {} : { ask: (decision) => ask(decision, turn) }),
         };
     }
-    /** A decision ready to run, run: a confirm once confirmed. */
-    function bodied(decision, signal) {
-        const options = signal === undefined ? {} : { signal };
-        return decision.outcome === "confirm" ? project.run(decision, { ...options, confirmed: true }) : project.run(decision, options);
+    /** A reflex that takes a whole result, met outside a weave: refused before any confirm, since only a request of
+     *  several steps hands one. */
+    function taker(decision) {
+        const takes = Object.values(plan.active[decision.reflex]?.takes ?? {});
+        if (takes.length === 0)
+            return;
+        throw refused(decision.reflex, `${decision.reflex} takes ${words(takes)}, which a step before it in the same request returns`, { type: "rerun" }, 'weave("<input>")');
     }
-    /** One body run for a weave: what it returned, or its failure as the step's own outcome, never the weave's; a
-     *  body the signal ended is the round cancelled. */
-    async function ran(decision, signal) {
+    /** The chosen call's body — in-process, in a child through the loader, or as an argv — with the whole results it
+     *  takes beside its values, which only the weave hands; one the plan did not hand is refused by the envelope, the
+     *  last guard. What `run` does for a call that takes none, and every step of a weave for its round. */
+    async function running(decision, taken, options) {
+        const chosen = own(decision, "run");
+        const active = plan.active[chosen.reflex];
+        if (active === undefined)
+            throw refused(chosen.reflex, `${chosen.reflex} is not active`, { type: "rerun" }, "run(d)");
+        const spent = chosen.trace.reduce((sum, entry) => sum + entry.ms, 0);
+        // The whole decision crosses: the core reads the fields of a Chosen and ignores the SDK's own.
+        const wire = chosen;
+        const envelope = call("envelope", { chosen: wire, active, taken, input: chosen.input, deadline: Math.max(plan.deadline - spent, 0), home: homedir() }, "run(d)");
+        const what = `running ${chosen.reflex}`;
+        const body = bodies[chosen.reflex];
+        if (body !== undefined)
+            return inline(what, body, envelope, options.signal);
+        const dir = dirs[chosen.reflex];
+        if (dir === undefined)
+            throw refused(chosen.reflex, `${chosen.reflex} has no body to run`, { type: "sync" }, "run(d)");
+        return contained(what, chosen, active, dir, envelope, options.signal);
+    }
+    /** One body run for a weave, the whole results its step takes beside it: what it returned, or its failure as the
+     *  step's own outcome, never the weave's; a body the signal ended is the round cancelled. */
+    async function ran(decision, taken, signal) {
         try {
-            return { status: "ran", result: await bodied(decision, signal) };
+            return { status: "ran", result: await running(decision, taken, signalled(signal)) };
         }
         catch (error) {
             if (signal?.aborted && error === signal.reason)
@@ -604,6 +622,15 @@ function carrying(reason, woven) {
     }
     return reason;
 }
+/** A signal as run options: none when there is none. */
+function signalled(signal) {
+    return signal === undefined ? {} : { signal };
+}
+/** `a`, `a and b`, `a, b and c`. */
+function words(names) {
+    const last = names.at(-1) ?? "";
+    return names.length < 2 ? last : `${names.slice(0, -1).join(", ")} and ${last}`;
+}
 /** Whether two asks want the same things for the same reasons. */
 function same(after, before) {
     return JSON.stringify(after) === JSON.stringify(before);

package/dist/reflex.d.ts

@@ -10,17 +10,21 @@ export interface InlineManifest {
     effect?: Effect;
     /** The one-line template a person confirms, naming required arguments only. */
     confirm: string;
+    /** The arguments: a question and one source each, or a whole result an earlier step returns, taken by its name. */
     args?: Record<string, InlineArg>;
     /** What the body's `data` yields for a later step to take: per field, the recognizer that reads it, or a list of
      *  records with such fields. */
     yields?: Record<string, Recognizer | {
         each: Record<string, Recognizer>;
     }>;
+    /** The name the body's whole `data` goes by, for a later step to take. */
+    returns?: string;
     examples?: InlineRecords;
     tests?: InlineRecords;
 }
-/** An argument: its question and exactly one source; a flag is optional by nature. */
-export type InlineArg = {
+/** An argument: its question and exactly one source, a flag optional by nature; or `takes` alone, a whole result
+ *  an earlier step returns, by the name that result goes by — filled by the plan, never asked. */
+export type InlineArg = ({
     ask: string;
 } & ({
     options: Record<string, string>;
@@ -37,7 +41,9 @@ export type InlineArg = {
     optional?: boolean;
 } | {
     flag: true;
-});
+})) | {
+    takes: string;
+};
 /** Utterances with what they assert: a record per argument — the text, or `false` for unstated, `true` for a flag —
  *  or `false` for never this reflex. */
 export type InlineRecords = Record<string, Record<string, string | boolean> | false>;
@@ -57,23 +63,34 @@ type Absent<A> = A extends {
 } | {
     flag: true;
 } ? true : false;
+type Taken<A> = A extends {
+    takes: string;
+} ? true : false;
 type Flat<T> = {
     [K in keyof T]: T[K];
 } & {};
 type ArgsOf<M extends InlineManifest> = NonNullable<M["args"]> extends Record<string, InlineArg> ? NonNullable<M["args"]> : Record<never, InlineArg>;
-/** What a decision carries for a reflex handed as code: its arguments as the wire types them, optional ones optional. */
+/** The asked arguments alone: a taken one never travels in a decision. */
+type AskedOf<M extends InlineManifest> = {
+    [N in keyof ArgsOf<M> as Taken<ArgsOf<M>[N]> extends true ? never : N]: ArgsOf<M>[N];
+};
+/** What a decision carries for a reflex handed as code: its asked arguments as the wire types them, optional ones
+ *  optional. */
 export type Carried<M extends InlineManifest> = Flat<{
-    [N in keyof ArgsOf<M> as Absent<ArgsOf<M>[N]> extends true ? never : N]: Typed<ArgsOf<M>[N]>;
+    [N in keyof AskedOf<M> as Absent<AskedOf<M>[N]> extends true ? never : N]: Typed<AskedOf<M>[N]>;
 } & {
-    [N in keyof ArgsOf<M> as Absent<ArgsOf<M>[N]> extends true ? N : never]?: Typed<ArgsOf<M>[N]>;
+    [N in keyof AskedOf<M> as Absent<AskedOf<M>[N]> extends true ? N : never]?: Typed<AskedOf<M>[N]>;
 }>;
 /** What decisions carry for a map of reflexes handed as code: `load<Reflexes & ReflexesOf<typeof own>>` when a
  *  project has installed reflexes beside them. */
 export type ReflexesOf<I> = {
     [K in keyof I]: I[K] extends Inline<infer S> ? S : never;
 };
-/** The body's arguments, plain: what `reflex`'s body receives. */
-export type Args<M extends InlineManifest> = Values<Carried<M>>;
+/** The body's arguments, plain: what `reflex`'s body receives — the asked arguments' values, and each whole result
+ *  it takes as `unknown`, since evoke checks no shape. */
+export type Args<M extends InlineManifest> = Flat<Values<Carried<M>> & {
+    [N in keyof ArgsOf<M> as Taken<ArgsOf<M>[N]> extends true ? N : never]: unknown;
+}>;
 /** What `reflex` returns and `load` takes; `shape` never holds a value — it is what a decision carries, for inference. */
 export interface Inline<S = Record<string, Value>> {
     readonly manifest: InlineManifest;

package/dist/runtime.js

@@ -25,13 +25,17 @@ const LOADER = fileURLToPath(new URL("../runtime/loader.mjs", import.meta.url));
 const KEPT = ["PATH", "HOME", "TMPDIR", "LANG", "TERM"];
 /** What a body gets to settle after its signal aborts, and a group after SIGTERM before SIGKILL, in milliseconds. */
 const GRACE = 1000;
+/** Milliseconds as a person reads them: `30 s`, `1.5 s`, `0.05 s`. */
+function seconds(ms) {
+    return `${ms < 1000 ? (ms / 1000).toFixed(2) : Math.round(ms / 100) / 10} s`;
+}
 /** A function body, in-process: its arguments as the envelope carries them, the deadline as its signal. */
 export async function inline(what, body, envelope, signal) {
     signal?.throwIfAborted();
     const config = resolved(what, envelope.config);
     // Referenced timers: a body that hangs holding no handle cannot let the process exit before the deadline.
     const timeout = new AbortController();
-    const timer = setTimeout(() => timeout.abort(new DOMException(`no answer within ${envelope.deadline} ms`, "TimeoutError")), envelope.deadline);
+    const timer = setTimeout(() => timeout.abort(new DOMException(`no answer within ${seconds(envelope.deadline)}`, "TimeoutError")), envelope.deadline);
     const own = signal === undefined ? timeout.signal : AbortSignal.any([signal, timeout.signal]);
     let grace;
     const abandoned = new Promise(resolve => {
@@ -49,7 +53,7 @@ export async function inline(what, body, envelope, signal) {
         if (signal?.aborted)
             throw signal.reason;
         if ("abandoned" in outcome)
-            throw failed(what, `did not finish within ${envelope.deadline} ms`);
+            throw failed(what, `did not finish within ${seconds(envelope.deadline)}`);
         if ("threw" in outcome) {
             throw failed(what, outcome.threw instanceof Error ? outcome.threw.message : String(outcome.threw), undefined, outcome.threw);
         }
@@ -91,7 +95,7 @@ export async function child(what, dir, envelope, layers, signal) {
     if (error !== undefined)
         throw failed(what, error.message);
     if (timedOut)
-        throw failed(what, `did not finish within ${envelope.deadline} ms`);
+        throw failed(what, `did not finish within ${seconds(envelope.deadline)}`);
     const line = output.split("\n")[0] ?? "";
     let parsed;
     try {
@@ -105,7 +109,8 @@ export async function child(what, dir, envelope, layers, signal) {
         if (refused !== null && typeof refused === "object" && "what" in refused && "path" in refused) {
             throw new Refusal(String(parsed.error), { what: String(refused.what), path: String(refused.path) });
         }
-        throw failed(what, String(parsed.error));
+        const frames = "frames" in parsed && Array.isArray(parsed.frames) ? parsed.frames.map(String) : [];
+        throw failed(what, String(parsed.error), undefined, undefined, frames);
     }
     return result(what, parsed);
 }
@@ -139,7 +144,7 @@ export async function program(what, argv, envelope, layers, signal) {
     if (error !== undefined)
         throw failed(what, error.message);
     if (timedOut)
-        throw failed(what, `did not finish within ${envelope.deadline} ms`);
+        throw failed(what, `did not finish within ${seconds(envelope.deadline)}`);
     if (code !== 0)
         throw failed(what, refusedProfile(code) ?? ended(code));
     return { text: output.endsWith("\n") ? output.slice(0, -1) : output };
@@ -249,6 +254,6 @@ function describe(value) {
 function ended(code) {
     return code === null ? "was killed" : `exited ${code}`;
 }
-function failed(what, why, fix = { type: "rerun" }, cause) {
-    return new FailureError(what, why, fix, command(fix, `run(d)`), cause === undefined ? undefined : { cause });
+function failed(what, why, fix = { type: "rerun" }, cause, frames = []) {
+    return new FailureError(what, why, fix, command(fix, `run(d)`), cause === undefined ? undefined : { cause }, frames);
 }

package/dist/types.d.ts

@@ -91,6 +91,13 @@ export type File = {
 export type Fix = {
     type: "vocab_add";
     vocab: VocabName;
+} | {
+    type: "vocab_value";
+    vocab: VocabName;
+    word: Word;
+} | {
+    type: "make_dir";
+    path: string;
 } | {
     type: "vocab_remove";
     vocab: VocabName;
@@ -172,12 +179,19 @@ export interface Manifest {
     confirm: Template;
     /** Absent: inline, a function the SDK holds. */
     run?: Run;
+    /** Where the body runs, when not anywhere; elsewhere the reflex is inactive. Absent when anywhere. Contract, like `run`. */
+    platforms?: Platform[];
     /** What the body may touch; absent, the tightest declaration. Contract, like `run`. */
     needs?: Needs;
     config: Record<ConfigKey, ConfigSpec>;
+    /** The arguments the classifier is asked about: `ask` and one source each. */
     args: Record<ArgName, Argument>;
+    /** The arguments an earlier step's whole result fills, by the name that result goes by; absent when none. Contract. */
+    takes?: Record<ArgName, FieldName>;
     /** What the body's `data` yields for a later step to take, per field. */
     yields: Record<FieldName, Yield>;
+    /** The name the body's whole `data` goes by, for a later step to take; absent when none. Contract. */
+    returns?: FieldName;
     examples: Records;
     tests: Records;
     /** Keys the format does not know: reported, never fatal. */
@@ -604,9 +618,14 @@ export interface Active {
     /** Absent: the tightest declaration. */
     needs?: Needs;
     confirm: Template;
+    /** The arguments the classifier is asked about. */
     args: Record<ArgName, Argument>;
+    /** The arguments an earlier step's whole result fills, by the name that result goes by; absent when none. */
+    takes?: Record<ArgName, FieldName>;
     /** What the body's `data` yields for a later step to take, per field. */
     yields: Record<FieldName, Yield>;
+    /** The name the body's whole `data` goes by, for a later step to take; absent when none. */
+    returns?: FieldName;
     config: Record<ConfigKey, Setting>;
     tags: Tag[];
 }
@@ -640,7 +659,7 @@ export type PickValue = {
     value: Clean;
 };
 /** What a request asks: everything, or the route alone — the conflict test at `add`. */
-export type Scope = "full" | "route";
+export type Scope = "full" | "route" | "fits";
 /** What the answers said: the reflexes ranked, every choice read, and the winner with its values. */
 export interface Reading {
     /** Sorted by route probability; `try` prints it. */
@@ -799,8 +818,9 @@ export interface Envelope {
     reflex: LocalName;
     /** Absent for an inline body. */
     run?: Run;
-    /** An option key, a word's `value` if set else the word, a pick's value, `true` for a flag. */
-    args: Record<ArgName, string | number | true>;
+    /** An option key, a word's `value` if set else the word, a pick's value, `true` for a flag, and a whole result as
+     *  its source returned it. */
+    args: Record<ArgName, Json>;
     input: Input;
     /** An `env` setting stays a reference; the host resolves it. */
     config: Record<ConfigKey, Setting>;
@@ -866,8 +886,16 @@ export interface Ref {
     many?: boolean;
     p?: Prob;
 }
-/** How a segment that matched nothing on its own was settled. */
-export type Repair = "narrowed" | "spliced" | "merged";
+/** How a step came to be that is not one part decided on its own: a segment that matched nothing settled narrowed to
+ *  its neighbour's reflex, spliced into its words, or merged back; or a part the engine kept whole split, its parts each
+ *  a reflex of their own. */
+export type Repair = "narrowed" | "spliced" | "merged" | "split";
+/** A word of a vocabulary the request stated for several steps, as it reached one of them: a required argument filled
+ *  as a person's answer would fill it, or an optional one written into the step's words and decided again narrowed. */
+export interface Shared {
+    word: Word;
+    via: Via;
+}
 /** One step of the plan: a segment's text and the foundation's decision on it, in the order it is to happen. */
 export interface Step {
     /** From 1, as the plan prints it. */
@@ -880,18 +908,24 @@ export interface Step {
     effect?: Effect;
     refs?: Ref[];
     repair?: Repair;
+    /** The words the request stated once for several steps that reached this one's arguments, by argument. */
+    shared?: Record<ArgName, Shared>;
     /** The steps this one must follow: an explicit `then`, or a binding. */
     after?: number[];
 }
-/** How a bound value reaches its step: answering its own ask, or the step decided again with the value in its words. */
-export type Via = "fill" | "rewrite";
-/** A value of one step's result taken by a later step: which field, into which argument, how. */
+/** How a bound value reaches its step: answering its own ask; the step decided again with the value in its words; or a
+ *  whole result handed beside the decision, never through its words. */
+export type Via = "fill" | "rewrite" | "takes";
+/** A value of one step's result taken by a later step: which field, into which argument, how; or the whole result, by
+ *  the name it goes by. */
 export interface Binding {
     from: number;
     to: number;
     arg: ArgName;
+    /** The field taken; for `takes`, the name the whole result goes by. */
     field: FieldName;
-    kind: Recognizer;
+    /** The recognizer the field is read with; absent for a whole result. */
+    kind?: Recognizer;
     via: Via;
     /** The list field of the source's result whose records carry `field`: the step runs once per record. */
     each?: FieldName;
@@ -920,6 +954,19 @@ export type Because = {
     type: "takes_nothing";
     step: number;
     sources: number[];
+}
+/** A whole result the step takes by name that no step before it returns: refused, nothing answers it. */
+ | {
+    type: "no_source";
+    step: number;
+    name: FieldName;
+}
+/** What the step takes one of that several steps return, or one step once per record: refused. */
+ | {
+    type: "several_sources";
+    step: number;
+    name: FieldName;
+    sources: number[];
 };
 /** The verdict before anything runs, with every reason. */
 export interface Verdict {
@@ -940,19 +987,20 @@ export interface Weave {
     stages: number[][];
     verdict: Verdict;
 }
-/** A value bound into a step at its turn. */
+/** A value bound into a step at its turn; a whole result carries no value here, it stays on its source's line. */
 export interface Bound {
     arg: ArgName;
     from: number;
     field: FieldName;
-    value: string;
+    value?: string;
 }
 /** What a body returned: its text, and data when it gave some. */
 export interface Returned {
     text: string;
     data?: Json;
 }
-/** One round of a step for a host to take through the foundation's loop, the bound values in place. */
+/** One round of a step for a host to take through the foundation's loop, the bound values in place and the whole
+ *  results the body receives beside them. */
 export interface Handling {
     step: number;
     /** From 0; a step bound to a list runs one round per record. */
@@ -960,14 +1008,24 @@ export interface Handling {
     decision: Decision;
     input: string;
     bound?: Bound[];
+    /** Per taken argument, its source's whole `data`: the same for every round of the step. */
+    taken?: Record<ArgName, Json>;
 }
 /** What became of a step, or of one of its rounds. */
 export type Status = "ran" | "failed" | "declined" | "refused" | "skipped" | "unanswered";
 /** Why a step did not run, or did not finish. */
 export type WeaveWhy = {
     type: "earlier_step";
-} | {
+}
+/** The step it names yielded nothing it can take: no such field, no data, or null. */
+ | {
     type: "nothing_to_take";
+    from: number;
+}
+/** The step it names returned a whole result over the cap, a mebibyte of JSON. */
+ | {
+    type: "too_large";
+    from: number;
 } | {
     type: "found_nothing";
 } | {
@@ -1035,7 +1093,7 @@ export interface ContractDiff {
 }
 /** `same`: nothing but wording, or a declaration narrowed. `minor`: additions, a declaration widened, and a config key gone. `major`: something a person's files or calls may not survive. */
 export type Level = "same" | "minor" | "major";
-/** One change to the contract, in the order the diff walks: the previous arguments, the added ones, the body, what it may touch, config, then what the result yields. */
+/** One change to the contract, in the order the diff walks: the previous arguments, the added ones, the body, what it may touch, config, what the result yields, what the reflex takes, then what it returns. */
 export type Change = {
     type: "arg_removed";
     arg: ArgName;
@@ -1061,6 +1119,12 @@ export type Change = {
 } | {
     type: "needs_narrowed";
     removed: Needs;
+} | {
+    type: "platform_added";
+    platform: Platform;
+} | {
+    type: "platform_removed";
+    platform: Platform;
 } | {
     type: "required";
     arg: ArgName;
@@ -1093,6 +1157,27 @@ export type Change = {
 } | {
     type: "yield_changed";
     field: FieldName;
+} | {
+    type: "takes_added";
+    arg: ArgName;
+    name: FieldName;
+} | {
+    type: "takes_removed";
+    arg: ArgName;
+    name: FieldName;
+} | {
+    type: "takes_changed";
+    arg: ArgName;
+    name: FieldName;
+} | {
+    type: "returns_added";
+    name: FieldName;
+} | {
+    type: "returns_removed";
+    name: FieldName;
+} | {
+    type: "returns_changed";
+    name: FieldName;
 };
 /** `was` is flat and cumulative: a retired name never returns as a live argument, and never leaves the lists. */
 export type WasViolation = {
@@ -1200,6 +1285,14 @@ export interface Theft {
     phrase: Utterance;
     owner: LocalName;
     thief: LocalName;
+    /** Present when the newcomer did not win the phrase but fits it at or over the floor. */
+    fits?: Prob;
+}
+/** An installed case routed over the new set at `add`: who won, and every reflex offered with its `fits`. */
+export interface Routed {
+    case: Case;
+    winner?: LocalName;
+    ranking?: Contender[];
 }
 /** The report `evoke calibrate` prints: every record of the active reflexes decided once, or `repeats` times, and judged; each input counts once, by its first decision, the repeats measuring stability. */
 export interface Calibration {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evoke-build/evoke",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "You invoke a function; you evoke a reflex. The SDK: load a project of reflexes, decide with Jev, run.",
   "keywords": [
     "jev",

package/runtime/loader.mjs

@@ -1,11 +1,11 @@
 // The loader: one envelope line on stdin — { run, args, input, config, deadline } — the body `run` names imported
 // and its default export called with (args, { input, config, signal }), then one result line on stdout:
-// { text, data? } or { error, refused? } — `refused` when the error is a refusal by Node's permission model or the
-// kernel: what was refused, a permission or a syscall, and the path, so the host names the declaration's key. It
-// exits when stdin closes before a body, and during one aborts the body's `signal` first, so its life is bounded
-// by its parent's and the body still hears the end. The body's console and stdout go to stderr, as do the frames
-// of an error it throws — the frames alone, without the message the host reports, and without the frames inside
-// Node itself; an error thrown from a callback ends the body as a rejection does. SIGTERM, the deadline and
+// { text, data? } or { error, refused?, frames? } — `refused` when the error is a refusal by Node's permission
+// model or the kernel: what was refused, a permission or a syscall, and the path, so the host names the
+// declaration's key; `frames` the frames of an error the body threw, without the message and without the frames
+// inside Node itself, for the host to keep. It exits when stdin closes before a body, and during one aborts the
+// body's `signal` first, so its life is bounded by its parent's and the body still hears the end. The body's
+// console and stdout go to stderr; an error thrown from a callback ends the body as a rejection does. SIGTERM, the deadline and
 // stdin's end abort `signal`; a body that has not settled a second later is abandoned. The SDK ships this same
 // file.
 import { writeSync } from "node:fs";
@@ -43,8 +43,8 @@ const out = (value) => {
     }
   }
 };
-const fail = (message, refused) => {
-  out(refused === undefined ? { error: message } : { error: message, refused });
+const fail = (message, refused, frames) => {
+  out({ error: message, ...(refused === undefined ? {} : { refused }), ...(frames?.length ? { frames } : {}) });
   process.exit(1);
 };
 
@@ -76,7 +76,7 @@ async function run(line) {
   const { run, args, input, config, deadline } = envelope;
   process.on("SIGTERM", () => stop("terminated", true));
   process.on("uncaughtException", thrown);
-  const timer = setTimeout(() => stop(`timed out after ${deadline} ms`, true), deadline);
+  const timer = setTimeout(() => stop(`timed out after ${seconds(deadline)}`, true), deadline);
   try {
     const module = await import(pathToFileURL(run).href);
     if (module.default === undefined) throw new Error(`${run} has no default export`);
@@ -94,12 +94,11 @@ async function run(line) {
   }
 }
 
-// A body's error, whether its promise rejected with it or a callback threw it: the frames on stderr, then the
-// message and what refused the body, when something did, as the one line.
+// A body's error, whether its promise rejected with it or a callback threw it: the message, what refused the
+// body, when something did, and its frames, as the one line.
 function thrown(error) {
-  const frames = error instanceof Error && error.stack ? where(error.stack) : "";
-  if (frames) process.stderr.write(`${frames}\n`);
-  fail(error instanceof Error ? error.message : String(error), refusal(error));
+  const frames = error instanceof Error && error.stack ? where(error.stack) : [];
+  fail(error instanceof Error ? error.message : String(error), refusal(error), frames);
 }
 
 // What refused the body, when something did. A lookup names the host, whether Node's permission model refused it
@@ -117,12 +116,18 @@ function refusal(error) {
   return { what: text(e.syscall), path: text(e.path) || address };
 }
 
+// The frames of a stack, from the first, each without its indent; none from inside Node.
 function where(stack) {
   const lines = stack.split("\n");
   const first = lines.findIndex((line) => line.startsWith("    at "));
   return (first < 0 ? [] : lines.slice(first))
     .filter((line) => !/[( ]node:/.test(line) && !line.includes("[eval"))
-    .join("\n");
+    .map((line) => line.trim());
+}
+
+// Milliseconds as a person reads them: `30 s`, `1.5 s`, `0.05 s`.
+function seconds(ms) {
+  return `${ms < 1000 ? (ms / 1000).toFixed(2) : Math.round(ms / 100) / 10} s`;
 }
 
 function describe(value) {