@openmbee/opensysml 0.10.0 → 0.10.2-nightly.20261019.ge8607989d

package/README.md

@@ -181,10 +181,16 @@ while another origin is not.
 `connectWasm()` uses the same `Connection`, `Model`, values and errors over the
 combined `sysml-wasm` module. It serves `ParseFile`, `ParseSources`,
 `GetDiagnostics`, `GetSymbol`, `Evaluate`, `Instantiate`, `ExecuteAction`,
-`ExecuteState` and `GetServerInfo`. Those are the module's complete RPC surface;
+`ExecuteState`, `RenderView` and `GetServerInfo`. Those are the module's complete RPC surface;
 other capability-gated operations fail with `MissingCapabilityError`, and a
 direct unsupported RPC fails with `UNIMPLEMENTED`.
 The adapter uses JSON encoding; requesting protobuf encoding is refused.
+The module answers `RenderView` as the service's protojson `RenderViewResponse` and
+advertises `render_view`, so `connection.renderView()` returns the same `RenderedView`
+over either; `renderedViewFromJson()` decodes such a response saved as JSON (a snapshot a
+page paints before its module has loaded). A traced `ExecuteState` answers the service's
+`DocumentEvent` records and the module advertises `state_trace`, so
+`connection.executeState(…, { trace: true })` returns the same typed trace over either.
 
 In Node, install the optional `@openmbee/opensysml-wasm` package at the same
 version as this client. `connectWasm()` resolves its module and matching Go
@@ -257,9 +263,12 @@ https://cdn.jsdelivr.net/npm/@openmbee/opensysml-wasm@<version>/sysml-wasm.wasm
 https://cdn.jsdelivr.net/npm/@openmbee/opensysml-wasm@<version>/wasm_exec.js
 ```
 
+The same package carries `sysml-prod.wasm.gz`, the gzip-compressed browser build of the
+`sysml` REPL for pages that run the REPL itself; `connectWasm()` does not use it.
+
 Browser callers pass those URLs as `wasm` and `wasmExec`; browser package
-resolution is not automatic. The combined module measures about 7.8 MB gzipped
-and 5.5 MB with Brotli.
+resolution is not automatic. The combined module measures about 8.7 MB gzipped
+and 6.1 MB with Brotli.
 
 ## Protobuf, not JSON
 
@@ -518,7 +527,7 @@ verb, and `save` writes what it answers with its image files beside it:
 
 ```ts
 const migration = await connection.migrate("sysml", { path: "Model.mdzip" }, { report: true });
-console.log(migration.report.summary);            // migrated 93 element(s): 78 mapped, 12 approximated, …
+console.log(migration.report.summary);            // migrated 95 element(s): 77 mapped, 15 approximated, …
 for (const entry of migration.report.byVerdict("unmapped")) {
   console.log(`${entry.kind} ${entry.name}: ${entry.note}`);
 }

package/dist/browser/wasm.js

@@ -83,7 +83,10 @@ async function browserWasmSource(wasm) {
     if (wasm instanceof Response && wasm.bodyUsed) {
         throw new Error("the WebAssembly Response body has already been read");
     }
-    return loadWasmSource(wasm instanceof Response ? wasm : wasm instanceof URL ? wasm : resourceUrl(wasm));
+    if (wasm instanceof Response || wasm instanceof URL) {
+        return loadWasmSource(wasm);
+    }
+    return loadWasmSource(resourceUrl(wasm));
 }
 function resourceUrl(value) {
     if (value instanceof URL) {

package/dist/core/capabilities.d.ts

@@ -31,6 +31,9 @@ export declare const CAPABILITY_TENSOR_VALUES = "tensor_values";
 export declare const CAPABILITY_METAOBJECT_VALUES = "metaobject_values";
 /** `finalTime` on an execution response: the run's simulation clock when it ended, in seconds. */
 export declare const CAPABILITY_FINAL_TIME = "final_time";
+/** `orderDependent` on an execution response and a feature value, and `orderDependent`/`independent`
+ * on a choice-point diagnostic: what a run's values stand only up to. */
+export declare const CAPABILITY_ORDER_DEPENDENCE = "order_dependence";
 /** `ParseFileRequest.language`, which declares the language of inline content. */
 export declare const CAPABILITY_INLINE_LANGUAGE = "inline_language";
 /** `ParseFileRequest.strict_conformance`. */
@@ -57,6 +60,10 @@ export declare const CAPABILITY_RENDER_DOCUMENT_HTML = "render_document_html";
 export declare const CAPABILITY_RENDER_VIEW = "render_view";
 /** The `ExportGraphs` RPC, exporting a behavior's lowered graph as `graphs:1` JSON. */
 export declare const CAPABILITY_EXPORT_GRAPHS = "export_graphs";
+export declare const CAPABILITY_IMPORT_DATA = "import_data";
+export declare const CAPABILITY_COMPARE_RESULTS = "compare_results";
+/** The `CheckBehavior` RPC, searching every schedule of a behavior for violations and divergent values. */
+export declare const CAPABILITY_CHECK = "check";
 /** What the body of a verification case answered, as `verification_verdicts`. */
 export declare const CAPABILITY_VERIFICATION_VERDICTS = "verification_verdicts";
 /** `RunAnalysisResponse.evaluations`: each call the run made to a calc held as a value, such as a trade study's evaluation of every alternative. */
@@ -123,6 +130,8 @@ export declare const CAPABILITY_CONVERT_DOCUMENTS = "convert_documents";
 export declare const CAPABILITY_CONVERT_COMPACT = "convert_compact";
 /** `ParseSourcesRequest.baseModelHash` and `ParseSourcesResponse.affected`: the documents whose results may differ from the base model's, so a client re-reads only those after an edit. */
 export declare const CAPABILITY_PARSE_SOURCES_AFFECTED = "parse_sources_affected";
+/** `RenderDocumentResponse.fileName`: the file a rendered set writes the document to, which the other documents' links to it name. */
+export declare const CAPABILITY_RENDER_DOCUMENT_FILE_NAME = "render_document_file_name";
 /**
  * Orders capability names by code unit, the order the service reports them in.
  * Locale-aware collation ignores the underscores that separate their words.
@@ -173,3 +182,9 @@ export declare function mismatchReason(info: ServerInfo, options?: {
  * than arriving as a generic unsupported-operation error.
  */
 export declare function capabilityRefusal(info: ServerInfo, capabilities: readonly string[]): ((details: string) => MissingCapabilityError) | undefined;
+/** The `RunRuns` RPC: an action or a Monte Carlo case run repeatedly, the runs tabled. */
+export declare const CAPABILITY_RUNS = "runs";
+/** The `SelfCheck` RPC: the reflective SysMLValidation check of every element. */
+export declare const CAPABILITY_SELF_CHECK = "self_check";
+/** The `RecordRun` RPC: runs of an analysis case recorded into the model. */
+export declare const CAPABILITY_RECORD_RUN = "record_run";

package/dist/core/capabilities.js

@@ -35,6 +35,9 @@ export const CAPABILITY_TENSOR_VALUES = "tensor_values";
 export const CAPABILITY_METAOBJECT_VALUES = "metaobject_values";
 /** `finalTime` on an execution response: the run's simulation clock when it ended, in seconds. */
 export const CAPABILITY_FINAL_TIME = "final_time";
+/** `orderDependent` on an execution response and a feature value, and `orderDependent`/`independent`
+ * on a choice-point diagnostic: what a run's values stand only up to. */
+export const CAPABILITY_ORDER_DEPENDENCE = "order_dependence";
 /** `ParseFileRequest.language`, which declares the language of inline content. */
 export const CAPABILITY_INLINE_LANGUAGE = "inline_language";
 /** `ParseFileRequest.strict_conformance`. */
@@ -61,6 +64,10 @@ export const CAPABILITY_RENDER_DOCUMENT_HTML = "render_document_html";
 export const CAPABILITY_RENDER_VIEW = "render_view";
 /** The `ExportGraphs` RPC, exporting a behavior's lowered graph as `graphs:1` JSON. */
 export const CAPABILITY_EXPORT_GRAPHS = "export_graphs";
+export const CAPABILITY_IMPORT_DATA = "import_data";
+export const CAPABILITY_COMPARE_RESULTS = "compare_results";
+/** The `CheckBehavior` RPC, searching every schedule of a behavior for violations and divergent values. */
+export const CAPABILITY_CHECK = "check";
 /** What the body of a verification case answered, as `verification_verdicts`. */
 export const CAPABILITY_VERIFICATION_VERDICTS = "verification_verdicts";
 /** `RunAnalysisResponse.evaluations`: each call the run made to a calc held as a value, such as a trade study's evaluation of every alternative. */
@@ -127,6 +134,8 @@ export const CAPABILITY_CONVERT_DOCUMENTS = "convert_documents";
 export const CAPABILITY_CONVERT_COMPACT = "convert_compact";
 /** `ParseSourcesRequest.baseModelHash` and `ParseSourcesResponse.affected`: the documents whose results may differ from the base model's, so a client re-reads only those after an edit. */
 export const CAPABILITY_PARSE_SOURCES_AFFECTED = "parse_sources_affected";
+/** `RenderDocumentResponse.fileName`: the file a rendered set writes the document to, which the other documents' links to it name. */
+export const CAPABILITY_RENDER_DOCUMENT_FILE_NAME = "render_document_file_name";
 /**
  * Orders capability names by code unit, the order the service reports them in.
  * Locale-aware collation ignores the underscores that separate their words.
@@ -229,3 +238,9 @@ export function capabilityRefusal(info, capabilities) {
         return new MissingCapabilityError(capability, info, upgradeRemedy(capability));
     };
 }
+/** The `RunRuns` RPC: an action or a Monte Carlo case run repeatedly, the runs tabled. */
+export const CAPABILITY_RUNS = "runs";
+/** The `SelfCheck` RPC: the reflective SysMLValidation check of every element. */
+export const CAPABILITY_SELF_CHECK = "self_check";
+/** The `RecordRun` RPC: runs of an analysis case recorded into the model. */
+export const CAPABILITY_RECORD_RUN = "record_run";

package/dist/core/check.d.ts

@@ -0,0 +1,90 @@
+import type { CheckBehaviorResponse } from "../generated/sysml_pb.js";
+import { type Standing } from "./engines.js";
+/** One schedule replayed: pass `schedule` as a run's schedule to follow it. */
+export interface CheckWitness {
+    schedule: string;
+    draws: readonly string[];
+    choices: readonly string[];
+    inputs: readonly string[];
+    /** The witness file's name and content when one was asked for, else empty. */
+    fileName: string;
+    fileContent: string;
+}
+/** One violation witnessed: a property false at a state, a deadlock or a failure. */
+export interface CheckViolation {
+    kind: string;
+    property: string;
+    error: string;
+    depth: number;
+    probability: number;
+    witness: CheckWitness | undefined;
+    text: string;
+}
+/** A feature whose final value the schedule decides. */
+export interface CheckDivergence {
+    feature: string;
+    values: readonly {
+        value: string;
+        witness: CheckWitness | undefined;
+    }[];
+}
+/** One final outcome of an exhaustive search. */
+export interface CheckFinal {
+    outcome: string;
+    values: ReadonlyMap<string, string>;
+    witness: CheckWitness | undefined;
+}
+/** The explicit-state search's statistics. */
+export interface CheckSearch {
+    states: number;
+    moves: number;
+    maxDepth: number;
+    boundsHit: readonly string[];
+    horizon: number;
+    horizonSet: boolean;
+    massBounded: boolean;
+    notes: readonly string[];
+    scope: readonly string[];
+    status: string;
+}
+/** What `CheckBehavior` answered: the verdict over every schedule, each finding witnessed. */
+export interface CheckResult {
+    /** `holds`, `fails` or `undecided`. */
+    verdict: string;
+    /** The report as `sysml -check-property` prints it. */
+    lines: readonly string[];
+    search: CheckSearch | undefined;
+    violations: readonly CheckViolation[];
+    divergences: readonly CheckDivergence[];
+    finals: readonly CheckFinal[];
+    claim: string;
+    freeInputs: readonly string[];
+    assumptions: readonly string[];
+    witness: CheckWitness | undefined;
+    contrast: CheckWitness | undefined;
+    standing: Standing;
+    reason: string;
+}
+/** The options of `Model.checkAction` and `Model.checkStateMachine`. */
+export interface CheckOptions {
+    /** Constraints or requirements evaluated at every stable state. */
+    properties?: readonly string[];
+    /** Features whose final value the schedule may decide. */
+    diverge?: readonly string[];
+    /** Inputs the symbolic engine ranges over. */
+    freeInputs?: readonly string[];
+    /** Constraints or requirements the symbolic engine assumes. */
+    assume?: readonly string[];
+    /** Carry each witness's file in the answer. */
+    witness?: boolean;
+    /** Bounds on moves per schedule, states visited, loop unrollings and seconds; 0 is the default. */
+    depth?: number;
+    states?: number;
+    unroll?: number;
+    timeout?: number;
+    /** The engine asked: `check` (the default), `smt` or one `listEngines` names. */
+    engine?: string;
+    /** The part or usage whose object performs the behavior. */
+    performer?: string;
+}
+export declare function checkResultOf(response: CheckBehaviorResponse): CheckResult;

package/dist/core/check.js

@@ -0,0 +1,70 @@
+import { standingOf } from "./engines.js";
+function witnessOf(pb) {
+    if (pb === undefined)
+        return undefined;
+    return {
+        schedule: pb.schedule,
+        draws: pb.draws,
+        choices: pb.choices,
+        inputs: pb.inputs,
+        fileName: pb.fileName,
+        fileContent: pb.fileContent,
+    };
+}
+function violationOf(pb) {
+    return {
+        kind: pb.kind,
+        property: pb.property,
+        error: pb.error,
+        depth: pb.depth,
+        probability: pb.probability,
+        witness: witnessOf(pb.witness),
+        text: pb.text,
+    };
+}
+function divergenceOf(pb) {
+    return {
+        feature: pb.feature,
+        values: pb.values.map((v) => ({ value: v.value, witness: witnessOf(v.witness) })),
+    };
+}
+function finalOf(pb) {
+    return {
+        outcome: pb.outcome,
+        values: new Map(Object.entries(pb.values)),
+        witness: witnessOf(pb.witness),
+    };
+}
+function searchOf(pb) {
+    if (pb === undefined)
+        return undefined;
+    return {
+        states: pb.states,
+        moves: pb.moves,
+        maxDepth: pb.maxDepth,
+        boundsHit: pb.boundsHit,
+        horizon: pb.horizon,
+        horizonSet: pb.horizonSet,
+        massBounded: pb.massBounded,
+        notes: pb.notes,
+        scope: pb.scope,
+        status: pb.status,
+    };
+}
+export function checkResultOf(response) {
+    return {
+        verdict: response.verdict,
+        lines: response.lines,
+        search: searchOf(response.search),
+        violations: response.violations.map(violationOf),
+        divergences: response.divergences.map(divergenceOf),
+        finals: response.finals.map(finalOf),
+        claim: response.claim,
+        freeInputs: response.freeInputs,
+        assumptions: response.assumptions,
+        witness: witnessOf(response.witness),
+        contrast: witnessOf(response.contrast),
+        standing: standingOf(response),
+        reason: response.reason,
+    };
+}

package/dist/core/connection.d.ts

@@ -10,10 +10,11 @@ import type { MigrateOptions } from "./conversion.js";
 import { type QueryElement, type QueryForm, type QueryPayload } from "./query.js";
 import { DocumentEvent, type BindingValues, type DocumentQueryResult } from "./document.js";
 import { type RenderedView } from "./render-view.js";
+import { type CheckOptions, type CheckResult } from "./check.js";
 import { type Graphs } from "./graphs.js";
 import { type EngineInfo } from "./engines.js";
 import { Exploration } from "./exploration.js";
-import { CalcResult, type AnalysisResult, type SweepTable, type Validation, type Verdict } from "./verdict.js";
+import { RunsResult, SelfCheckResult, Recording, CalcResult, type AnalysisResult, type SweepTable, type Validation, type Verdict, type ImportResult, type Comparison } from "./verdict.js";
 import { type SysMLValue, type ValueInput } from "./values.js";
 import { Editor, type EditOperationData, type EditResult } from "./edit.js";
 /** Wire encoding of the request and response bodies. Protobuf is the default. */
@@ -163,10 +164,25 @@ export declare class Connection {
     renderDocument(modelHash: string, documentId: string, options?: {
         form?: string;
     }): Promise<string>;
-    /** Renders a named view or targeted pseudo-view as diagram data. */
+    /**
+     * Renders a named view or targeted pseudo-view as diagram data. `show` names
+     * the optional notation elements to draw besides those the view's rendering
+     * shows (`"edge-labels"`, `"all"`, ...); the service refuses a name it does
+     * not know. `depth`, above 0, bounds how many levels of nested elements are
+     * drawn below each exposed element, overriding the view's own depth.
+     */
     renderView(modelHash: string, viewName: string, options?: {
         ports?: "minimal" | "full";
+        show?: readonly string[];
+        depth?: number;
     }): Promise<RenderedView>;
+    /** Searches every schedule of an action for a violated property, a deadlock, a failure or a divergent value. */
+    checkAction(modelHash: string, actionSymbolId: string, options?: CheckOptions & {
+        inputs?: Readonly<Record<string, ValueInput>>;
+    }): Promise<CheckResult>;
+    /** Searches every schedule of a state machine; see {@link checkAction}. */
+    checkStateMachine(modelHash: string, stateMachineSymbolId: string, options?: CheckOptions): Promise<CheckResult>;
+    private checkBehavior;
     /**
      * Exports the lowered graph of an action or state machine, and of every
      * behavior it performs, as the canonical `graphs:1` JSON an external
@@ -178,10 +194,22 @@ export declare class Connection {
         inputs?: Readonly<Record<string, ValueInput>>;
         schedule?: string;
         performer?: string;
+        /** Simulated seconds to run for (`sysml -advance`); unset runs to completion. */
+        advance?: number;
+        /** Seed of the model's own draws (`sysml -seed`). */
+        seed?: bigint;
+        /** How RandomFunctions draws resolve (`sysml -draws`): random, min, max or average. */
+        draws?: string;
+        /** Seconds the run's clock ticks by (`sysml -clock-step`); 0 is continuous. */
+        clockStep?: number;
     }): Promise<{
         outputs: ReadonlyMap<string, SysMLValue | UnsupportedValueError>;
         performer: ReadonlyMap<string, SysMLValue | UnsupportedValueError>;
         finalTime: number;
+        /** Output name → how many of the run's unresolved choice points touch it; the
+         * value then stands only up to the order the run took, and `exploreAction`
+         * shows the set. Absent for an output nothing order-dependent wrote. */
+        orderDependent: ReadonlyMap<string, number>;
     }>;
     /** Runs an action once per valid order of its choice points, within a budget. */
     exploreAction(modelHash: string, actionSymbolId: string, options?: {
@@ -196,12 +224,22 @@ export declare class Connection {
         schedule?: string;
         performer?: string;
         trace?: boolean;
+        /** Simulated seconds to run for (`sysml -advance`); unset runs to completion. */
+        advance?: number;
+        /** Seed of the model's own draws (`sysml -seed`). */
+        seed?: bigint;
+        /** How RandomFunctions draws resolve (`sysml -draws`): random, min, max or average. */
+        draws?: string;
+        /** Seconds the run's clock ticks by (`sysml -clock-step`); 0 is continuous. */
+        clockStep?: number;
     }): Promise<{
         statesVisited: string[];
         finalContext: ReadonlyMap<string, SysMLValue | UnsupportedValueError>;
         finalTime: number;
         trace: DocumentEvent[];
         traceDropped: number;
+        /** Final-context key → how many of the run's unresolved choice points touch it. */
+        orderDependent: ReadonlyMap<string, number>;
     }>;
     /** Runs a state machine over the events once per valid order of its choice points. */
     exploreState(modelHash: string, stateMachineSymbolId: string, options?: {
@@ -212,7 +250,9 @@ export declare class Connection {
     private sendExecuteState;
     private explorationOf;
     /** Lists the analysis engines the service answers with, as `sysml -engines` does. */
-    listEngines(): Promise<EngineInfo[]>;
+    listEngines(options?: {
+        probe?: boolean;
+    }): Promise<EngineInfo[]>;
     /** Asks whether a constraint holds. */
     verifyConstraint(modelHash: string, symbolId: string, options?: VerifyOptions): Promise<Verdict>;
     /** Asks whether a requirement is satisfied. */
@@ -239,6 +279,8 @@ export declare class Connection {
         namedArguments?: Readonly<Record<string, ValueInput>>;
         schedule?: string;
         engine?: string;
+        /** Preview the first external tool call instead of making it (`sysml -tool-dry-run`). */
+        toolDryRun?: boolean;
     }): Promise<AnalysisResult>;
     /** Runs an analysis case once per valid order of its choice points. */
     exploreAnalysis(modelHash: string, symbolId: string, options?: {
@@ -248,6 +290,38 @@ export declare class Connection {
         schedule?: string;
     }): Promise<Exploration>;
     private sendRunAnalysis;
+    /** Runs an action, or a Simulation::MonteCarlo case, `runs` times, each in
+     * a context of its own, and tables what the runs observed. */
+    runRuns(modelHash: string, options: {
+        action?: string;
+        analysis?: string;
+        runs: bigint | number;
+        seed?: bigint | number;
+        draws?: string;
+        clockStep?: number;
+        observe?: readonly string[];
+        inputs?: Readonly<Record<string, ValueInput>>;
+        performer?: string;
+        subject?: string;
+        arguments?: readonly ValueInput[];
+        namedArguments?: Readonly<Record<string, ValueInput>>;
+        engine?: string;
+    }): Promise<RunsResult>;
+    /** Applies the SysMLValidation constraints, and those of the rule packages
+     * named, reflectively to every element of the model. */
+    selfCheck(modelHash: string, packages?: readonly string[]): Promise<SelfCheckResult>;
+    /** Runs an analysis case once, over the rows of `ranges` or as a Monte
+     * Carlo sample of `runs`, and records the runs into the model. */
+    recordRun(modelHash: string, symbolId: string, options?: {
+        subject?: string;
+        arguments?: readonly ValueInput[];
+        namedArguments?: Readonly<Record<string, ValueInput>>;
+        into?: string;
+        ranges?: Readonly<Record<string, readonly [ValueInput, ValueInput] | readonly [ValueInput, ValueInput, ValueInput]>>;
+        runs?: bigint | number;
+        seed?: bigint | number;
+        engine?: string;
+    }): Promise<Recording>;
     /** Runs an analysis case or calc once per row of a parameter sweep. */
     runSweep(modelHash: string, symbolId: string, ranges: Readonly<Record<string, readonly [ValueInput, ValueInput] | readonly [ValueInput, ValueInput, ValueInput]>>, options?: {
         subject?: string;
@@ -259,6 +333,30 @@ export declare class Connection {
     }): Promise<SweepTable>;
     private sweepRange;
     private verdictOf;
+    /** Sets the feature values data files assign, one edit of the model per
+     * file, as `sysml -import` does. */
+    importData(modelHash: string, imports: readonly {
+        name: string;
+        content: string;
+        format?: string;
+        map?: string;
+    }[], options?: {
+        importAs?: string;
+        dryRun?: boolean;
+        acceptDocuments?: boolean;
+    }): Promise<ImportResult>;
+    /** Runs the configurations a SysML v1 tool's results sidecar indexes against
+     * the model and tables the tool's distributions beside the runs', as
+     * `sysml -compare-results` does. */
+    compareResults(modelHash: string, results: string, options?: {
+        actions?: readonly string[];
+        runs?: bigint | number;
+        seed?: bigint | number;
+        draws?: string;
+        clockStep?: number;
+        observe?: readonly (string | readonly [string, string])[];
+        engine?: string;
+    }): Promise<Comparison>;
     private instancesOf;
     private requireVerification;
     private requireEngines;