@evoke-build/evoke 0.6.0

package/dist/core.js

@@ -0,0 +1,102 @@
+// The loader: core.wasm instantiated once, on first use, and one function over its three exports — the op and
+// the input written as UTF-8 into buffers the module allocates, the call, the reply read back, every buffer freed.
+// Synchronous: a rule costs microseconds and nothing here waits on the world. Nothing else in the SDK touches the
+// module. In: an op name and one JSON argument object. Out: the raw reply, or the value with its error thrown.
+import { readFileSync } from "node:fs";
+import { DiagnosticError, FaultError } from "./errors.js";
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+let loaded;
+/** The module, instantiated once; after a trap it is instantiated again, since a trap leaves its memory as it was. */
+function core() {
+    if (loaded === undefined) {
+        const module = new WebAssembly.Module(readFileSync(new URL("../core.wasm", import.meta.url)));
+        loaded = new WebAssembly.Instance(module, {}).exports;
+    }
+    return loaded;
+}
+/** One op on one input: the raw reply. A trap in the core is a bug in evoke, thrown as one. A lone surrogate in
+ *  any string — `JSON.stringify` writes it as an escape, and no Rust string can hold it — crosses as U+FFFD. */
+export function reply(op, input) {
+    const wasm = core();
+    const opBytes = encoder.encode(op);
+    const inputBytes = encoder.encode(JSON.stringify(input).replace(/\\u(d[89a-f][0-9a-f]{2})/gi, "\\ufffd"));
+    try {
+        const opPtr = wasm.alloc(opBytes.length);
+        const inputPtr = wasm.alloc(inputBytes.length);
+        // Both views are made after both allocations: growing the memory detaches an earlier view.
+        new Uint8Array(wasm.memory.buffer, opPtr, opBytes.length).set(opBytes);
+        new Uint8Array(wasm.memory.buffer, inputPtr, inputBytes.length).set(inputBytes);
+        const packed = wasm.call(opPtr, opBytes.length, inputPtr, inputBytes.length);
+        const ptr = Number(packed >> 32n);
+        const len = Number(packed & 0xffffffffn);
+        const text = decoder.decode(new Uint8Array(wasm.memory.buffer, ptr, len));
+        wasm.free(ptr, len);
+        wasm.free(opPtr, opBytes.length);
+        wasm.free(inputPtr, inputBytes.length);
+        return JSON.parse(text);
+    }
+    catch (error) {
+        if (error instanceof WebAssembly.RuntimeError) {
+            loaded = undefined;
+            throw new Error(`evoke's core hit a bug in ${op}: ${error.message}`, { cause: error });
+        }
+        throw error;
+    }
+}
+/**
+ * One op, typed: the value, or the op's own error thrown as the CLI would print it — a `DiagnosticError` for
+ * diagnostics, a `FaultError` for a fault. `invoked` names the SDK call for a fix that says to try again.
+ */
+export function call(op, input, invoked = "") {
+    const answer = reply(op, input);
+    if ("ok" in answer)
+        return answer.ok;
+    if ("bug" in answer)
+        throw bug(answer.bug);
+    throw raised(answer.err, invoked);
+}
+/** The command that fixes a problem, rendered by the core. */
+export function command(fix, invoked = "") {
+    return call("fix", { fix, invoked });
+}
+/** A diagnostic with its command rendered. */
+export function problem(diagnostic, invoked = "") {
+    return { ...diagnostic, command: command(diagnostic.fix, invoked) };
+}
+/** Diagnostics over something given in code — a manifest, words, a gate — where the core's `evoke check`, meant
+ *  for a file, cannot apply: the fix is the call itself. */
+export function fromCode(diagnostics, invoked) {
+    return new DiagnosticError(diagnostics.map(diagnostic => ({ ...diagnostic, command: diagnostic.fix.type === "check" ? invoked : command(diagnostic.fix, invoked) })));
+}
+/** A fault as the error it is, its words and command rendered by the core. */
+export function faulted(fault, invoked = "") {
+    const { message, command } = call("fault", { fault, invoked });
+    return new FaultError(fault, message, command);
+}
+/** Why a text is no local or vocabulary name by the core's grammar, or nothing when it is one. */
+export function misnamed(text, kind) {
+    const answer = reply("name", { text, kind });
+    if ("ok" in answer)
+        return undefined;
+    if ("bug" in answer)
+        throw bug(answer.bug);
+    return String(answer.err);
+}
+/** A bug in evoke — never a user error. */
+export function bug(message) {
+    return new Error(`evoke's core hit a bug: ${message}`);
+}
+/** An op's `err` as the error it is: one diagnostic or several, or a fault; anything else is a bug in the SDK. */
+function raised(err, invoked) {
+    if (Array.isArray(err)) {
+        return new DiagnosticError(err.map(diagnostic => problem(diagnostic, invoked)));
+    }
+    if (err !== null && typeof err === "object") {
+        if ("fix" in err)
+            return new DiagnosticError([problem(err, invoked)]);
+        if ("type" in err)
+            return faulted(err, invoked);
+    }
+    return bug(`an error of an unknown shape: ${JSON.stringify(err)}`);
+}

package/dist/decision.d.ts

@@ -0,0 +1,109 @@
+import type { Trace } from "./adapter.ts";
+import type { Result } from "./runtime.ts";
+import type * as W from "./types.ts";
+/** The four shapes evoke.d.ts declares, so a generated Reflexes and an inline one are one kind of thing. */
+export type Option<K extends string = string> = {
+    type: "option";
+    key: K;
+};
+export type Word = {
+    type: "word";
+    word: string;
+    value?: string;
+};
+export type Pick<T extends W.Recognizer = W.Recognizer, V = number | string> = {
+    type: "pick";
+    span: W.Span;
+    value: {
+        type: T;
+        value: V;
+    };
+};
+export type Flag = {
+    type: "flag";
+};
+/** An argument's value as the wire carries it. */
+export type Value = W.Value;
+/** What a decision's args carry per reflex when nothing narrows it: any reflex, any arguments. */
+export type AnyReflexes = Record<string, Record<string, Value>>;
+/** A value as a body receives it: the key, the word's value else the word, the number or text, `true`. */
+export type Plain<V> = V extends Option<infer K> ? K : V extends Word ? string : V extends Pick<W.Recognizer, infer X> ? X : V extends Flag ? true : never;
+/** Plain values per argument; an optional argument stays optional. */
+export type Values<A> = {
+    [N in keyof A]: Plain<NonNullable<A[N]>>;
+};
+/** What every decision carries beside the core's fields. */
+export interface Line {
+    /** The input as decided. */
+    input: string;
+    /** The digest of the plan it was decided under: `fill` and `run` refuse another. */
+    plan: string;
+    /** One entry per adapter call. */
+    trace: Trace[];
+}
+/** A complete call: the typed args as read, the plain values a body receives, the one call grammar, the effect. */
+export type Chosen<R, K extends keyof R & string> = Line & W.Judged & {
+    reflex: K;
+    args: R[K];
+    values: Values<R[K]>;
+    /** `lights room="den" state="off"` */
+    call: string;
+    effect: W.Effect;
+};
+/** A complete call over the floor: run it. */
+export type Run<R = AnyReflexes> = {
+    [K in keyof R & string]: {
+        outcome: "run";
+    } & Chosen<R, K>;
+}[keyof R & string];
+/** A complete call that needs a yes: the prompt, and every reason in a fixed order. */
+export type Confirm<R = AnyReflexes> = {
+    [K in keyof R & string]: {
+        outcome: "confirm";
+        prompt: W.Prompt;
+        because: W.NonEmpty<W.Cap>;
+    } & Chosen<R, K>;
+}[keyof R & string];
+/** A winner with required arguments missing: what was read so far, and what to ask. */
+export type Ask<R = AnyReflexes> = {
+    [K in keyof R & string]: Line & W.Judged & {
+        outcome: "ask";
+        reflex: K;
+        args: Partial<R[K]>;
+        values: Partial<Values<R[K]>>;
+        unconsumed: W.Span[];
+        missing: W.NonEmpty<W.Missing>;
+    };
+}[keyof R & string];
+/** `none` won or the route is under its floor: the ranking, and every judgment. */
+export type Abstain = Line & {
+    outcome: "abstain";
+    contenders: W.Contender[];
+    judgments: W.Judgment[];
+};
+/** One input decided. */
+export type Decision<R = AnyReflexes> = Abstain | Run<R> | Confirm<R> | Ask<R>;
+/** What an ask takes back for one value: an option's key, else the text a person typed. A flag is never asked. */
+type Answer<P> = P extends true ? never : P extends string ? P : string;
+/** What an ask is answered with, by argument name. */
+export type Given<D> = D extends {
+    values: Partial<infer V>;
+} ? {
+    [N in keyof V as NonNullable<V[N]> extends true ? never : N]?: Answer<NonNullable<V[N]>> | undefined;
+} : never;
+/** What `handle` returns; a failure of any kind throws. */
+export type Handled<R = AnyReflexes> = {
+    outcome: "ran";
+    decision: Run<R> | Confirm<R>;
+    result: Result;
+} | {
+    outcome: "abstained";
+    decision: Abstain;
+} | {
+    outcome: "declined";
+    decision: Confirm<R> | Ask<R>;
+} | {
+    outcome: "unanswered";
+    decision: Confirm<R> | Ask<R>;
+};
+export {};

package/dist/decision.js

@@ -0,0 +1,5 @@
+// The decision as an app reads it: the CLI's --json line — the wire decision tagged by outcome — plus what the SDK
+// knows around it: the input as decided, the plan it was decided under, one trace entry per adapter call, and the
+// plain values a body receives beside the typed args. A union narrowed by `outcome`, then by `reflex`. R is what
+// each reflex's arguments carry — `Reflexes` from evoke.d.ts, or inferred from reflexes handed as code.
+export {};

package/dist/errors.d.ts

@@ -0,0 +1,32 @@
+import type { Diagnostic, Fault, Fix } from "./types.ts";
+/** Every error evoke raises: its kind, and the command or line that fixes it. */
+export declare abstract class EvokeError extends Error {
+    abstract readonly kind: "diagnostic" | "fault" | "failure";
+    /** The literal command or line that fixes it; empty when nothing but trying again applies. */
+    readonly command: string;
+    protected constructor(message: string, command: string, options?: ErrorOptions);
+}
+/** A diagnostic with its command rendered. */
+export type Problem = Diagnostic & {
+    command: string;
+};
+/** Something a person fixes in the files or the environment: every problem the core found, each with its fix. */
+export declare class DiagnosticError extends EvokeError {
+    readonly kind = "diagnostic";
+    readonly problems: readonly Problem[];
+    constructor(problems: readonly Problem[]);
+}
+/** The adapter failed, or its answers did not validate. */
+export declare class FaultError extends EvokeError {
+    readonly kind = "fault";
+    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`. */
+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);
+}

package/dist/errors.js

@@ -0,0 +1,50 @@
+// The three errors, as the CLI's exits 3, 4 and 1: what went wrong as data, and the line that fixes it, rendered
+// by the core. In: the core's diagnostics or fault, or a host's failure, each with its fixing command already
+// rendered. Out: an Error whose message is the CLI's own line — `<reflex>: <what>  →  <fix>`, one per problem.
+// `fix` is always the structured value, `command` always the rendered line.
+/** Every error evoke raises: its kind, and the command or line that fixes it. */
+export class EvokeError extends Error {
+    /** The literal command or line that fixes it; empty when nothing but trying again applies. */
+    command;
+    constructor(message, command, options) {
+        super(message, options);
+        this.name = new.target.name;
+        this.command = command;
+    }
+}
+/** Something a person fixes in the files or the environment: every problem the core found, each with its fix. */
+export class DiagnosticError extends EvokeError {
+    kind = "diagnostic";
+    problems;
+    constructor(problems) {
+        super(problems.map(line).join("\n"), problems[0]?.command ?? "");
+        this.problems = problems;
+    }
+}
+/** The adapter failed, or its answers did not validate. */
+export class FaultError extends EvokeError {
+    kind = "fault";
+    fault;
+    constructor(fault, message, command) {
+        super(command === "" ? message : `${message}  →  ${command}`, command);
+        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`. */
+export class FailureError extends EvokeError {
+    kind = "failure";
+    what;
+    why;
+    fix;
+    constructor(what, why, fix, command, options) {
+        super(`${what}${why === undefined ? "" : `: ${why}`}  →  ${command}`, command, options);
+        this.what = what;
+        this.why = why;
+        this.fix = fix;
+    }
+}
+/** The CLI's line for one problem. */
+function line(problem) {
+    const where = problem.reflex === undefined ? "" : `${problem.reflex}: `;
+    return `${where}${problem.message}  →  ${problem.command}`;
+}

package/dist/files.d.ts

@@ -0,0 +1,13 @@
+/** The owned texts as found: absent when the file is. */
+export interface Snapshot {
+    project?: string;
+    lock?: string;
+    overlays: Record<string, string>;
+    vocab: Record<string, string>;
+}
+/** The owned files under the root. */
+export declare function snapshot(root: string): Snapshot;
+/** A file's text, or nothing when there is no such file; one that will not read is a failure naming it. */
+export declare function text(path: string): string | undefined;
+/** A store entry's directory when every file under it still hashes to the digest; else nothing — `evoke sync`. */
+export declare function entry(h1: string): string | undefined;

package/dist/files.js

@@ -0,0 +1,100 @@
+// The project as files: the owned texts under a root — evoke.toml, evoke.lock, every overlay and vocabulary — a
+// local reflex's directory with its manifest, and a remote reflex's store entry, every file re-hashed and the
+// digest composed by the core so it runs only while it still hashes to the lock. Read whole, once; nothing here
+// is written. In: a root, a path, a digest. Out: texts and directories, or their absence.
+import { createHash } from "node:crypto";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { call, misnamed } from "./core.js";
+import { FailureError } from "./errors.js";
+/** The owned files under the root. */
+export function snapshot(root) {
+    const project = text(join(root, "evoke.toml"));
+    const lock = text(join(root, "evoke.lock"));
+    return {
+        ...(project === undefined ? {} : { project }),
+        ...(lock === undefined ? {} : { lock }),
+        overlays: named(join(root, "overlays"), "local"),
+        vocab: named(join(root, "vocab"), "vocab"),
+    };
+}
+/** A file's text, or nothing when there is no such file; one that will not read is a failure naming it. */
+export function text(path) {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw unreadable(path, error);
+    }
+}
+/** Every `<name>.toml` in a directory by name, in name order; none when there is no directory. A file whose stem
+ *  is no name is not an owned file and is left alone, as the CLI leaves it. */
+function named(dir, kind) {
+    const files = {};
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return files;
+        throw unreadable(dir, error);
+    }
+    for (const entry of entries.sort()) {
+        if (!entry.endsWith(".toml"))
+            continue;
+        const stem = entry.slice(0, -5);
+        if (misnamed(stem, kind) !== undefined)
+            continue;
+        const path = join(dir, entry);
+        try {
+            files[stem] = readFileSync(path, "utf8");
+        }
+        catch (error) {
+            throw unreadable(path, error);
+        }
+    }
+    return files;
+}
+/** A path that exists and will not read — a directory where a file should be, a permission missing. */
+function unreadable(path, error) {
+    const why = error instanceof Error ? error.message : String(error);
+    return new FailureError(`reading ${path}`, why, { type: "rerun" }, "load()");
+}
+/** The store: fetched trees under `$XDG_CACHE_HOME/evoke/store/<hex>/`. */
+function store() {
+    const base = process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache");
+    return join(base, "evoke", "store");
+}
+/** A store entry's directory when every file under it still hashes to the digest; else nothing — `evoke sync`. */
+export function entry(h1) {
+    const dir = join(store(), h1.replace(/^h1:/, ""));
+    try {
+        if (!statSync(dir).isDirectory())
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    const hashed = [];
+    const walk = (at, prefix) => {
+        for (const name of readdirSync(at).sort()) {
+            const path = join(at, name);
+            const relative = prefix === "" ? name : `${prefix}/${name}`;
+            if (statSync(path).isDirectory())
+                walk(path, relative);
+            else
+                hashed.push([relative, `h1:${createHash("sha256").update(readFileSync(path)).digest("hex")}`]);
+        }
+    };
+    try {
+        walk(dir, "");
+    }
+    catch (error) {
+        throw unreadable(dir, error);
+    }
+    return call("digest", { hashed }) === h1 ? dir : undefined;
+}

package/dist/https.d.ts

@@ -0,0 +1,20 @@
+import type { Agent } from "node:https";
+/** What the server answered; with a 429, the pause it asked for before the next attempt, in milliseconds. */
+export interface Response {
+    status: number;
+    body: string;
+    retryAfter?: number | undefined;
+}
+/** The pause a 429 asks for: `Retry-After` in seconds, at least one, so a service that says "now" is still paced;
+ * an HTTP date, which no engine sends, names no pause. */
+export declare function pause(header: string | string[] | undefined): number | undefined;
+/** Why nothing was answered, and whether a connection was made first. */
+export declare class Unanswered extends Error {
+    readonly connected: boolean;
+    constructor(message: string, connected: boolean);
+}
+/** `POST url` with a bearer token and a JSON body; `via` is the proxy's host when one carries the connection. */
+export declare function post(url: string, bearer: string, body: string, agent: Agent, signal: AbortSignal, timeout: number, via?: string): Promise<Response>;
+/** What went wrong, in plain words: the host named, or the proxy when one carries the connection; the system's
+ * own cause, no code and no number. */
+export declare function describe(error: NodeJS.ErrnoException, host: string, connected: boolean, via?: string): string;

package/dist/https.js

@@ -0,0 +1,109 @@
+// One HTTPS POST, one attempt, over a kept-alive agent: the signal bounds the whole attempt, the timeout each
+// step after connect; never retries. In: the url, a bearer, a JSON body, an agent, a signal, the step timeout.
+// Out: the status and body, or a Unanswered saying in plain words what went wrong and whether a connection had
+// been made — an attempt that never connected, or a pooled socket the server had already closed, is safe to
+// repeat.
+import { request } from "node:https";
+import { getSystemErrorMessage } from "node:util";
+/** The most a response may carry: a decision's answers are kilobytes, so anything beyond is not the classifier. */
+const LIMIT = 10 * 1024 * 1024;
+/** The pause a 429 asks for: `Retry-After` in seconds, at least one, so a service that says "now" is still paced;
+ * an HTTP date, which no engine sends, names no pause. */
+export function pause(header) {
+    const text = Array.isArray(header) ? header[0] : header;
+    if (text === undefined || !/^\s*\d+\s*$/.test(text))
+        return undefined;
+    return Math.max(1, Number.parseInt(text, 10)) * 1000;
+}
+/** Why nothing was answered, and whether a connection was made first. */
+export class Unanswered extends Error {
+    connected;
+    constructor(message, connected) {
+        super(message);
+        this.name = "Unanswered";
+        this.connected = connected;
+    }
+}
+/** `POST url` with a bearer token and a JSON body; `via` is the proxy's host when one carries the connection. */
+export function post(url, bearer, body, agent, signal, timeout, via) {
+    const host = new URL(url).host;
+    return new Promise((resolve, reject) => {
+        let connected = false;
+        const sent = request(url, {
+            method: "POST",
+            agent,
+            signal,
+            headers: {
+                authorization: `Bearer ${bearer}`,
+                "content-type": "application/json",
+                "content-length": Buffer.byteLength(body),
+            },
+        }, response => {
+            connected = true;
+            let text = "";
+            let received = 0;
+            response.setEncoding("utf8");
+            response.on("data", (chunk) => {
+                received += Buffer.byteLength(chunk);
+                if (received > LIMIT)
+                    response.destroy(new Error(`more than ${LIMIT} bytes`));
+                else
+                    text += chunk;
+            });
+            response.on("end", () => {
+                const status = response.statusCode ?? 0;
+                const retryAfter = status === 429 ? pause(response.headers["retry-after"]) : undefined;
+                resolve({ status, body: text, ...(retryAfter === undefined ? {} : { retryAfter }) });
+            });
+            response.on("error", error => reject(new Unanswered(`reading the response from ${host}: ${reason(error)}`, true)));
+        });
+        // The step timeout is armed once the socket is connected; Node removes it when the socket returns to the pool.
+        sent.setTimeout(timeout, () => sent.destroy(new Error(`no answer within ${timeout / 1000} s`)));
+        sent.on("socket", socket => {
+            if (socket.connecting)
+                socket.once("connect", () => (connected = true));
+            else
+                connected = true;
+        });
+        sent.on("error", (error) => {
+            // A pooled socket the server closed while idle: nothing was received, so the attempt is safe to repeat.
+            const stale = sent.reusedSocket && error.code === "ECONNRESET";
+            const made = connected && !stale;
+            reject(new Unanswered(describe(error, host, made, via), made));
+        });
+        sent.end(body);
+    });
+}
+/** What went wrong, in plain words: the host named, or the proxy when one carries the connection; the system's
+ * own cause, no code and no number. */
+export function describe(error, host, connected, via) {
+    if (error.code === "ERR_PROXY_TUNNEL") {
+        const status = "statusCode" in error && typeof error.statusCode === "number" ? `: ${error.statusCode}` : "";
+        return `the proxy ${via ?? "the environment names"} refused the connection${status}`;
+    }
+    if (error.syscall === "getaddrinfo") {
+        const named = "hostname" in error && typeof error.hostname === "string" ? error.hostname : (via ?? host);
+        return `could not resolve ${named}`;
+    }
+    const cause = reason(error);
+    if (connected)
+        return `${host}: ${cause}`;
+    return via === undefined ? `could not connect to ${host}: ${cause}` : `could not connect to the proxy ${via}: ${cause}`;
+}
+/** The system's words for the error's number, the first of an aggregate's; a reset by its name; else the message,
+ * else the code. */
+function reason(error) {
+    const first = error instanceof AggregateError ? error.errors[0] : undefined;
+    const errno = error.errno ?? first?.errno;
+    if (typeof errno === "number") {
+        try {
+            return getSystemErrorMessage(errno);
+        }
+        catch {
+            // Not a number the system names: the words below say it.
+        }
+    }
+    if ((error.code ?? first?.code) === "ECONNRESET")
+        return "connection reset";
+    return error.message || first?.message || error.code || first?.code || "no reason given";
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { load } from "./project.ts";
+export type { DecideOptions, Handlers, LoadOptions, Project, ReflexStatus, RunOptions, Turn, Vocab, WeaveOptions, Woven, WovenRound, WovenStep } from "./project.ts";
+export { reflex } from "./reflex.ts";
+export type { Args, Carried, Inline, InlineArg, InlineManifest, InlineRecords, ReflexesOf } from "./reflex.ts";
+export type { Abstain, Ask, Confirm, Decision, Flag, Given, Handled, Option, Pick, Plain, AnyReflexes, Run, Value, Values, Word } from "./decision.ts";
+export type { Context, Reflex, Result } from "./runtime.ts";
+export type { Adapter, Trace } from "./adapter.ts";
+export { DiagnosticError, EvokeError, FailureError, FaultError } from "./errors.ts";
+export type { Problem } from "./errors.ts";
+export type { Because, Binding, Bound, Cap, Choices, Contained, Contender, Diagnostic, Effect, Fault, Fix, Gate, Judgment, Limits, Missing, Needs, Prompt, Question, NonEmpty, Raw, Recognizer, Span, State, Status, Step, Text, Verdict, Weave, WeaveWhy, Why, Yield, } from "./types.ts";

package/dist/index.js

@@ -0,0 +1,6 @@
+// @evoke-build/evoke: load a project, decide, run. Six things to learn, in order: reflex() · load() · handle() ·
+// a Decision · run() · replay() — the last under ./testing, and the two doors to Jev under ./jev and ./openjev, so
+// this entry imports no engine.
+export { load } from "./project.js";
+export { reflex } from "./reflex.js";
+export { DiagnosticError, EvokeError, FailureError, FaultError } from "./errors.js";

package/dist/jev.d.ts

@@ -0,0 +1,6 @@
+import type { Adapter } from "./adapter.ts";
+import { type DoorOptions } from "./systemone.ts";
+export type JevOptions = DoorOptions;
+/** Jev, ready to answer; throws at once when no key is set, an override is not a probability, or the proxy named
+ * in the environment is no proxy address. */
+export declare function jev(options?: JevOptions): Adapter;

package/dist/jev.js

@@ -0,0 +1,8 @@
+// @evoke-build/evoke/jev: the first adapter, Jev at TypeSafe AI's own address, under TYPESAFE_API_KEY. The wire
+// and the transport are ./systemone's; this entry names the door. In: options. Out: an Adapter.
+import { through } from "./systemone.js";
+/** Jev, ready to answer; throws at once when no key is set, an override is not a probability, or the proxy named
+ * in the environment is no proxy address. */
+export function jev(options = {}) {
+    return through("jev", options);
+}

package/dist/openjev.d.ts

@@ -0,0 +1,6 @@
+import type { Adapter } from "./adapter.ts";
+import { type DoorOptions } from "./systemone.ts";
+export type OpenJevOptions = DoorOptions;
+/** Jev through OpenJEV, ready to answer; throws at once when no key is set, an override is not a probability, or
+ * the proxy named in the environment is no proxy address. */
+export declare function openjev(options?: OpenJevOptions): Adapter;

package/dist/openjev.js

@@ -0,0 +1,9 @@
+// @evoke-build/evoke/openjev: the same model through OpenJEV, an independent service that forwards requests to
+// Jev, under OPENJEV_API_KEY. The wire and the transport are ./systemone's; this entry names the door. In:
+// options. Out: an Adapter.
+import { through } from "./systemone.js";
+/** Jev through OpenJEV, ready to answer; throws at once when no key is set, an override is not a probability, or
+ * the proxy named in the environment is no proxy address. */
+export function openjev(options = {}) {
+    return through("openjev", options);
+}