@openmbee/opensysml 0.9.2 → 0.10.1

package/dist/core/verdict.js

@@ -0,0 +1,567 @@
+// Verdicts of the verification the service performs, and the results that carry
+// them: validations, calc results, analysis results and sweep tables.
+import { FailureReason } from "../generated/sysml_pb.js";
+import { AnalysisRunError, ExecutionError, UnsupportedValueError, WrongKindError, } from "./errors.js";
+import { emptyStanding, standingOf } from "./engines.js";
+import { decodeValue, decodeVerdict, formatValue, } from "./values.js";
+/** Verdict kinds, as the service reports them. */
+export const KIND_CONSTRAINT = "constraint";
+export const KIND_REQUIREMENT = "requirement";
+export const KIND_SATISFY = "satisfy";
+export const KIND_OBJECTIVE = "objective";
+export const KIND_ASSERTION = "assertion";
+export const KIND_OBJECT = "object";
+/** VerdictKind values a verification case's body produces. */
+export const VERDICT_PASS = "pass";
+export const VERDICT_FAIL = "fail";
+export const VERDICT_INCONCLUSIVE = "inconclusive";
+export const VERDICT_ERROR = "error";
+/** The questions a verification answers. */
+export const QUESTION_EVALUATE = "evaluate";
+export const QUESTION_HOLDS = "holds";
+export const QUESTION_SATISFIABLE = "satisfiable";
+/** The statuses a verdict reports, as the service spells them. */
+export const STATUS_HOLDS = "holds";
+export const STATUS_VIOLATED = "violated";
+export const STATUS_UNDECIDED = "undecided";
+export const STATUS_SATISFIABLE = "satisfiable";
+export const STATUS_UNSATISFIABLE = "unsatisfiable";
+/** The mark a verification verdict's line opens with. */
+function verificationMark(kind) {
+    if (kind === VERDICT_PASS) {
+        return "✓";
+    }
+    return kind === VERDICT_FAIL ? "✗" : "?";
+}
+/** Whether a verdict's condition holds: the arm it decoded to. */
+export function verdictHolds(verdict) {
+    return verdict.kind === "holds";
+}
+/** Whether the verdict is an answer about the model at all: not undecided. */
+export function verdictEvaluated(verdict) {
+    return verdict.kind !== "undecided";
+}
+function named(verdict) {
+    const { subject } = verdict;
+    const element = subject.element !== "" ? subject.element : subject.elementId;
+    let out = element.split(" ").includes(subject.kind) ? element : `${subject.kind} ${element}`;
+    if (subject.instancePath !== undefined) {
+        out += ` at ${subject.instancePath}`;
+    }
+    return out;
+}
+/** Raise an {@link ExecutionError} when the verdict is undecided; else return it. */
+export function raiseVerdictError(verdict) {
+    if (verdict.kind === "undecided") {
+        throw new ExecutionError(`${named(verdict)}: ${verdict.error}`);
+    }
+    return verdict;
+}
+/** One line saying what the verdict is and why, then its standing when reported. */
+export function explainVerdict(verdict) {
+    const { subject } = verdict;
+    let subject_ = "";
+    if (subject.instanceId !== undefined) {
+        subject_ = ` (on ${subject.instanceTypeId ?? "instance"} ID: ${subject.instanceId.toString()})`;
+    }
+    let line;
+    if (verdict.kind === "undecided") {
+        line = `? ${named(verdict)}${subject_}: ${verdict.error}`;
+    }
+    else if (verdict.kind === "holds") {
+        line = `✓ ${named(verdict)} holds${subject_}`;
+    }
+    else {
+        const detail = verdict.condition !== ""
+            ? `: condition evaluated to false: ${verdict.condition}`
+            : ": condition evaluated to false";
+        line = `✗ ${named(verdict)} fails${subject_}${detail}`;
+    }
+    const standing = explainVerdictStanding(verdict.standing);
+    return standing === "" ? line : `${line} — ${standing}`;
+}
+function explainVerdictStanding(standing) {
+    if (standing.strength === "") {
+        return "";
+    }
+    let line = standing.strength;
+    if (standing.engine !== "") {
+        line += ` by ${standing.engine}`;
+    }
+    const reached = standing.bounds
+        .filter((bound) => bound.reached)
+        .map((b) => `${b.name} ${b.limit.toString()} reached`);
+    if (reached.length > 0) {
+        line += ` (${reached.join(", ")})`;
+    }
+    return line;
+}
+/** One line saying what a verification case's body answered and why. */
+export function explainVerificationVerdict(verdict) {
+    let line = `${verificationMark(verdict.kind)} verification ${verdict.caseId} verdict: ${verdict.kind}`;
+    if (verdict.subcase) {
+        line += " (subcase)";
+    }
+    if (verdict.detail !== "") {
+        line += ` — ${verdict.detail}`;
+    }
+    return line;
+}
+/** Whether a verification-case verdict is a pass. */
+export function verificationPassed(verdict) {
+    return verdict.kind === VERDICT_PASS;
+}
+/** Read a wire `VerificationVerdict`. */
+export function decodeVerificationVerdict(pb) {
+    return {
+        caseId: pb.caseId,
+        kind: pb.kind,
+        detail: pb.detail,
+        subcase: pb.subcase,
+        requirementId: pb.requirementId,
+    };
+}
+/** The arm of a `Verdict`, for callers that switch on it directly. */
+export function armOf(verdict) {
+    return verdict.verdict;
+}
+/** Whether the verdict's condition holds. */
+export function holds(verdict) {
+    return verdict.verdict.kind === "holds";
+}
+/** Raise when the verdict reports the named element is of another kind. */
+export function raiseWrongKind(pbVerdict, diagnostics) {
+    if (pbVerdict?.failureReason === FailureReason.WRONG_KIND) {
+        throw new WrongKindError(pbVerdict.error, "wrong_kind", diagnostics);
+    }
+}
+/** Raise the error a failure the service classified: wrong kind, else a run failure. */
+export function raiseFailure(message, failureReason, diagnostics) {
+    if (failureReason === FailureReason.WRONG_KIND) {
+        throw new WrongKindError(message, "wrong_kind", diagnostics);
+    }
+    throw new ExecutionError(message, "unspecified", diagnostics);
+}
+/** Read the error-or-result of an outputs map: undecodable values stay errors in place. */
+export function valuesMap(entries) {
+    const out = new Map();
+    for (const [name, pb] of entries) {
+        try {
+            out.set(name, decodeValue(pb));
+        }
+        catch (error) {
+            out.set(name, asUnsupported(error));
+        }
+    }
+    return out;
+}
+/** The verifications the requirement of `pbVerdict` was reported for. */
+export function verificationsFor(verifications, pbVerdict) {
+    if (pbVerdict.requirementId === "") {
+        return [];
+    }
+    return verifications.filter((v) => v.requirementId === pbVerdict.requirementId);
+}
+/** Wrap a wire verdict with the instances and diagnostics its response carried,
+ * attaching the verifications of its own requirement — every one the response
+ * carried when `attachAll` is set, as a single-verdict response asks for. */
+export function verdictOf(pbVerdict, instances, diagnostics, verifications, attachAll = false) {
+    return {
+        verdict: decodeVerdict(pbVerdict, attachAll ? verifications : verificationsFor(verifications, pbVerdict)),
+        instances,
+        diagnostics,
+    };
+}
+/** The outputs an invocation computed, or the features a calc usage wrote. */
+export class CalcResult {
+    /** The value an invocation returned; undefined when `outputs` carries the answer. */
+    value;
+    /** Output features a calc usage computed. */
+    outputs;
+    diagnostics;
+    standing;
+    constructor(init) {
+        this.value = init.value;
+        this.outputs = init.outputs;
+        this.diagnostics = init.diagnostics ?? [];
+        this.standing = init.standing ?? emptyStanding();
+    }
+    get engine() {
+        return this.standing.engine;
+    }
+    /** Strength of the evidence the answer rests on; empty when unreported. */
+    get strength() {
+        return this.standing.strength;
+    }
+    /** The bounds the engine ran under. */
+    get bounds() {
+        return this.standing.bounds;
+    }
+    toString() {
+        if (this.outputs.size > 0) {
+            return [...this.outputs.entries()]
+                .map(([name, val]) => `${name} = ${render(val)}`)
+                .join(", ");
+        }
+        return render(this.value);
+    }
+}
+function render(value) {
+    if (value === undefined) {
+        return "undefined";
+    }
+    return value instanceof UnsupportedValueError ? `<unsupported: ${value.message}>` : formatValue(value);
+}
+/** One application an analysis case made of one of its own calcs as a value. */
+export class CaseEvaluation {
+    /** FQN of the calc applied. */
+    functionId;
+    /** What it was applied to; an alternative is the instance it is. */
+    arguments;
+    /** What it computed; undefined when `error` says why nothing was. */
+    result;
+    /** Why the evaluation computed nothing; empty when it did. */
+    error;
+    /** Whether the case returned this evaluation's argument: a trade study's selection. */
+    selected;
+    /** Whether it computed what the selected one did without being selected. */
+    tied;
+    constructor(init) {
+        this.functionId = init.functionId;
+        this.arguments = init.arguments;
+        this.result = init.result;
+        this.error = init.error ?? "";
+        this.selected = init.selected ?? false;
+        this.tied = init.tied ?? false;
+    }
+    /** Whether the evaluation computed a result. */
+    get evaluated() {
+        return this.error === "";
+    }
+    /** One line saying what was evaluated, what it gave, and whether it was selected. */
+    explain() {
+        const call = `${this.functionId}(${this.arguments.map(render).join(", ")})`;
+        let line = this.error !== "" ? `${call}: error: ${this.error}` : `${call} = ${render(this.result)}`;
+        if (this.selected) {
+            line += " [selected]";
+        }
+        else if (this.tied) {
+            line += " [tied]";
+        }
+        return line;
+    }
+    toString() {
+        return this.explain();
+    }
+}
+/** What an analysis case computed and decided. */
+export class AnalysisResult {
+    /** Output features the case computed, by name. */
+    outputs;
+    /** The objective and assertion verdicts, in the order the case states them. */
+    verdicts;
+    /** The subject the case ran on and the objects reachable from it. */
+    instances;
+    diagnostics;
+    /** For a verification case, what its body answered and each subcase's. */
+    verifications;
+    /** Each application the run made of one of the case's calcs as a value. */
+    evaluations;
+    standing;
+    constructor(init) {
+        this.outputs = init.outputs;
+        this.verdicts = init.verdicts;
+        this.instances = init.instances ?? [];
+        this.diagnostics = init.diagnostics ?? [];
+        this.verifications = init.verifications ?? [];
+        this.evaluations = init.evaluations ?? [];
+        this.standing = init.standing ?? emptyStanding();
+    }
+    get engine() {
+        return this.standing.engine;
+    }
+    /** Strength of the evidence the answer rests on; empty when unreported. */
+    get strength() {
+        return this.standing.strength;
+    }
+    /** The bounds the engine ran under. */
+    get bounds() {
+        return this.standing.bounds;
+    }
+    /** The evaluations of the alternatives the case selected; one for a trade study. */
+    get selected() {
+        return this.evaluations.filter((evaluation) => evaluation.selected);
+    }
+    /** Whether every objective and assertion holds; a case stating none is satisfied. */
+    get satisfied() {
+        return this.verdicts.every((verdict) => verdict.verdict.kind === "holds");
+    }
+    toString() {
+        const lines = [
+            ...[...this.outputs.entries()].map(([name, val]) => `${name} = ${render(val)}`),
+            ...this.verdicts.map((verdict) => explainVerdict(verdict.verdict)),
+            ...this.verifications.map(explainVerificationVerdict),
+            ...this.evaluations.map((evaluation) => evaluation.explain()),
+        ];
+        return lines.join("\n");
+    }
+}
+/** Every assertion about one object and the objects it holds, answered. */
+export class Validation {
+    /** One per assertion, root first then each held object in traversal order. */
+    verdicts;
+    /** The object's own verdict, of kind 'object'; undefined when the service sent none. */
+    summary;
+    /** The object validated and every object reachable from it. */
+    instances;
+    /** Whether traversal stopped at its bound before reaching every held object. */
+    bounded;
+    diagnostics;
+    /** What the bodies of the verification cases of the requirements met answered. */
+    verifications;
+    constructor(init) {
+        this.verdicts = init.verdicts;
+        this.summary = init.summary;
+        this.instances = init.instances ?? [];
+        this.bounded = init.bounded ?? false;
+        this.diagnostics = init.diagnostics ?? [];
+        this.verifications = init.verifications ?? [];
+    }
+    /** The standing of the summary's engine; unreported when the service sent none. */
+    get standing() {
+        return this.summary?.verdict.standing ?? emptyStanding();
+    }
+    get engine() {
+        return this.standing.engine;
+    }
+    /** Strength of the evidence the answer rests on; empty when unreported. */
+    get strength() {
+        return this.standing.strength;
+    }
+    /** The bounds the engine ran under. */
+    get bounds() {
+        return this.standing.bounds;
+    }
+    /** Whether the object is shown valid: at least one assertion, every one holding, all reached. */
+    get valid() {
+        return this.summary?.verdict.kind === "holds" && !this.bounded;
+    }
+    /** The verdicts the model answered false, as opposed to undecided ones. */
+    get violated() {
+        return this.verdicts.filter((verdict) => verdict.verdict.kind === "fails");
+    }
+    /** The verdicts whose condition could not be evaluated. */
+    get undecided() {
+        return this.verdicts.filter((verdict) => verdict.verdict.kind === "undecided");
+    }
+    /** Raise an {@link ExecutionError} if any assertion could not be decided. */
+    raiseForError() {
+        for (const verdict of this.undecided) {
+            raiseVerdictError(verdict.verdict);
+        }
+        return this;
+    }
+    get length() {
+        return this.verdicts.length;
+    }
+    [Symbol.iterator]() {
+        return this.verdicts[Symbol.iterator]();
+    }
+    toString() {
+        const lines = this.verdicts.map((verdict) => explainVerdict(verdict.verdict));
+        if (this.summary !== undefined) {
+            lines.push(explainVerdict(this.summary.verdict));
+        }
+        return lines.join("\n");
+    }
+}
+/** One run of a sweep: what it bound, what it produced, and how long it took. */
+export class SweepRow {
+    /** The swept parameters as this run bound them, by name. */
+    inputs;
+    /** What the run produced, by name; a calc's return is named "result". */
+    outputs;
+    /** The objective and assertion verdicts of an analysis case; empty for a calc. */
+    verdicts;
+    /** Wall time of this run, in seconds. */
+    seconds;
+    /** Why this run failed; empty when it did not. */
+    error;
+    /** Each application this run made of one of the case's calcs as a value. */
+    evaluations;
+    constructor(init) {
+        this.inputs = init.inputs;
+        this.outputs = init.outputs;
+        this.verdicts = init.verdicts;
+        this.seconds = init.seconds;
+        this.error = init.error ?? "";
+        this.evaluations = init.evaluations ?? [];
+    }
+    /** The evaluations of the alternatives this run selected; one for a trade study. */
+    get selected() {
+        return this.evaluations.filter((evaluation) => evaluation.selected);
+    }
+    /** Whether this run failed rather than producing outputs. */
+    get failed() {
+        return this.error !== "";
+    }
+    toString() {
+        const inputs = [...this.inputs.entries()].map(([n, v]) => `${n}=${render(v)}`).join(", ");
+        if (this.failed) {
+            return `${inputs}: ${this.error}`;
+        }
+        const outputs = [...this.outputs.entries()].map(([n, v]) => `${n} = ${render(v)}`).join(", ");
+        return `${inputs}: ${outputs}`;
+    }
+}
+/** Every run of one sweep, in the order the runs were made. */
+export class SweepTable {
+    /** One row per run. */
+    rows;
+    /** The swept parameters, in the order their ranges were given. */
+    parameters;
+    /** Whether the rows were drawn rather than stepped through. */
+    sampled;
+    /** The seed the rows were drawn from; 0 for a swept table. */
+    seed;
+    /** The subjects the runs were about and the objects reachable from them. */
+    instances;
+    diagnostics;
+    standing;
+    constructor(init) {
+        this.rows = init.rows;
+        this.parameters = init.parameters;
+        this.sampled = init.sampled ?? false;
+        this.seed = init.seed ?? 0n;
+        this.instances = init.instances ?? [];
+        this.diagnostics = init.diagnostics ?? [];
+        this.standing = init.standing ?? emptyStanding();
+    }
+    get engine() {
+        return this.standing.engine;
+    }
+    /** Strength of the evidence the answer rests on; empty when unreported. */
+    get strength() {
+        return this.standing.strength;
+    }
+    /** The bounds the engine ran under. */
+    get bounds() {
+        return this.standing.bounds;
+    }
+    /** The runs that failed. */
+    get failures() {
+        return this.rows.filter((row) => row.failed);
+    }
+    get length() {
+        return this.rows.length;
+    }
+    [Symbol.iterator]() {
+        return this.rows[Symbol.iterator]();
+    }
+    row(index) {
+        if (index < 0 || index >= this.rows.length) {
+            throw new RangeError(`the table has ${this.rows.length} rows, not ${index + 1}`);
+        }
+        return this.rows[index];
+    }
+    toString() {
+        return this.rows.map((row) => row.toString()).join("\n");
+    }
+}
+/** Read the case evaluations of a response, undecodable values kept as errors. */
+export function evaluationsOf(evals) {
+    return evals.map((pb) => new CaseEvaluation({
+        functionId: pb.functionId,
+        arguments: pb.arguments.map((argument) => valueOrError(argument)),
+        ...(pb.error === "" && pb.result !== undefined
+            ? { result: valueOrError(pb.result) }
+            : {}),
+        error: pb.error,
+        selected: pb.selected,
+        tied: pb.tied,
+    }));
+}
+/** Decode one wire `Value`, keeping a decode failure as the error it raised. */
+export function valueOrError(pb) {
+    try {
+        return decodeValue(pb);
+    }
+    catch (error) {
+        return asUnsupported(error);
+    }
+}
+/** A decode failure as the UnsupportedValueError it is, or one carrying its message. */
+function asUnsupported(error) {
+    if (error instanceof UnsupportedValueError) {
+        return error;
+    }
+    return new UnsupportedValueError(error instanceof Error ? error.message : String(error));
+}
+/** Read the verdicts a validation response carries, and its summary. */
+export function validationOf(response, instances, diagnostics) {
+    const verifications = response.verificationVerdicts.map(decodeVerificationVerdict);
+    const verdicts = response.verdicts.map((pbVerdict) => verdictOf(pbVerdict, instances, diagnostics, verifications));
+    return new Validation({
+        verdicts,
+        ...(response.summary === undefined
+            ? {}
+            : { summary: verdictOf(response.summary, instances, diagnostics, verifications, true) }),
+        instances,
+        bounded: response.bounded,
+        diagnostics,
+        verifications,
+    });
+}
+/** Read a RunAnalysis response, or raise its failure. */
+export function analysisResultOf(response, instances, diagnostics) {
+    const verifications = response.verificationVerdicts.map(decodeVerificationVerdict);
+    const outputs = new Map();
+    for (const output of response.outputs) {
+        outputs.set(output.name, valueOrError(output.value));
+    }
+    const result = new AnalysisResult({
+        outputs,
+        verdicts: response.verdicts.map((pbVerdict) => verdictOf(pbVerdict, instances, diagnostics, [])),
+        instances,
+        diagnostics,
+        verifications,
+        evaluations: evaluationsOf(response.evaluations),
+        standing: standingOf(response),
+    });
+    if (response.error !== "") {
+        throw new AnalysisRunError(response.error, result, { diagnostics });
+    }
+    return result;
+}
+/** Read a RunSweep response into a SweepTable. */
+export function sweepTableOf(response, instances, diagnostics) {
+    const rows = response.rows.map((row) => sweepRowOf(row, instances, diagnostics));
+    return new SweepTable({
+        rows,
+        parameters: [...response.parameters],
+        sampled: response.sampled,
+        seed: response.seed,
+        instances,
+        diagnostics,
+        standing: standingOf(response),
+    });
+}
+function sweepRowOf(row, instances, diagnostics) {
+    const inputs = new Map();
+    const outputs = new Map();
+    for (const entry of row.inputs) {
+        inputs.set(entry.name, valueOrError(entry.value));
+    }
+    for (const entry of row.outputs) {
+        outputs.set(entry.name, valueOrError(entry.value));
+    }
+    const verifications = [];
+    return new SweepRow({
+        inputs,
+        outputs,
+        verdicts: row.verdicts.map((pbVerdict) => verdictOf(pbVerdict, instances, diagnostics, verifications)),
+        seconds: Number(row.elapsedMicros) / 1e6,
+        error: row.error,
+        evaluations: evaluationsOf(row.evaluations),
+    });
+}

package/dist/core/wasm.d.ts

@@ -0,0 +1,114 @@
+import { type Transport } from "@connectrpc/connect";
+import { Connection } from "./connection.js";
+import type { TransportOptions } from "./connection.js";
+/** A host surface implemented by an inline Go runtime or a worker. */
+export interface WasmHost {
+    readonly version: string;
+    call(method: string, params: string, signal?: AbortSignal): Promise<string>;
+    close(): Promise<void>;
+}
+/** The Go runtime interface exposed by wasm_exec.js. */
+export interface GoRuntime {
+    readonly importObject: WebAssembly.Imports;
+    run(instance: WebAssembly.Instance): Promise<unknown>;
+}
+/** A constructor exported globally by wasm_exec.js. */
+export type GoConstructor = new () => GoRuntime;
+export type WorkerWasmSource = string | ArrayBuffer | Uint8Array | WebAssembly.Module;
+export type WasmWorkerRequest = {
+    type: "init";
+    wasm: WorkerWasmSource;
+    wasmExec?: string;
+} | {
+    type: "call";
+    id: number;
+    method: string;
+    params: string;
+} | {
+    type: "close";
+};
+export type WasmWorkerResponse = {
+    type: "ready";
+    version: string;
+} | {
+    type: "failed";
+    message: string;
+} | {
+    type: "answer";
+    id: number;
+    envelope: string;
+};
+/** The platform-specific message and lifecycle surface of a WASM worker. */
+export interface WasmWorkerEndpoint {
+    post(message: WasmWorkerRequest, transfer: readonly Transferable[]): void;
+    onMessage(listener: (message: WasmWorkerResponse) => void): void;
+    onFailure(listener: (reason: Error) => void): void;
+    terminate(): Promise<void> | void;
+}
+/** The message port surface shared by browser and Node workers. */
+export interface WasmPortLike {
+    postMessage(message: WasmWorkerResponse): void;
+    addEventListener(type: "message", listener: (event: MessageEvent<WasmWorkerRequest>) => void): void;
+    start?(): void;
+}
+/** Optional platform loaders for worker runtimes that need local file access. */
+export interface WasmPortLoaders {
+    loadWasm?(source: WorkerWasmSource): Promise<BufferSource | WebAssembly.Module>;
+    loadGo?(wasmExec: string | undefined): Promise<GoConstructor>;
+}
+/** Connection settings shared by the Node and browser WASM clients. */
+export interface WasmConnectionOptions extends TransportOptions {
+    version?: string;
+    requireCapabilities?: readonly string[];
+}
+interface GlobalWasmSurface {
+    readonly version: string;
+    call(method: string, params: string): string;
+}
+/**
+ * Adapts the Go host global to the asynchronous host interface.
+ */
+export declare function wasmHostFromGlobal(surface?: GlobalWasmSurface): WasmHost;
+/**
+ * Starts a Go WebAssembly module in this realm and captures its host global.
+ */
+export declare function instantiateInline(module: BufferSource | WebAssembly.Module, Go: GoConstructor): Promise<WasmHost>;
+/**
+ * Creates a Connect transport for the JSON envelope served by sysml-wasm.
+ */
+export declare function createWasmTransport(host: WasmHost, options: TransportOptions): Transport;
+/**
+ * Opens a Connection over a WASM host, negotiating its version and capabilities.
+ */
+export declare function connectWasmHost(host: WasmHost, options?: WasmConnectionOptions): Promise<Connection>;
+/** Adapts a platform worker endpoint to the shared WASM host protocol. */
+export declare class WorkerWasmHost implements WasmHost {
+    private readonly endpoint;
+    version: string;
+    private readonly pending;
+    private readonly ready;
+    private resolveReady;
+    private rejectReady;
+    private nextId;
+    private failure;
+    private closed;
+    constructor(endpoint: WasmWorkerEndpoint);
+    start(request: Extract<WasmWorkerRequest, {
+        type: "init";
+    }>, transfer: readonly Transferable[]): Promise<this>;
+    call(method: string, params: string, signal?: AbortSignal): Promise<string>;
+    close(): Promise<void>;
+    private receive;
+    private fail;
+    private removePending;
+    private throwIfFailed;
+    private throwIfClosed;
+}
+/**
+ * Serves the shared init/call protocol on a Node or browser worker port.
+ */
+export declare function serveWasmPort(port: WasmPortLike, loaders?: WasmPortLoaders): void;
+/** Loads and caches the Go constructor installed by wasm_exec.js. */
+export declare function loadGoConstructor(wasmExec?: string): Promise<GoConstructor>;
+export declare function loadWasmSource(source: WorkerWasmSource | URL | Response): Promise<BufferSource | WebAssembly.Module>;
+export {};