@openmbee/opensysml 0.9.1

package/dist/core/model.d.ts

@@ -0,0 +1,139 @@
+import type { Connection } from "./connection.js";
+import type { ModelDiagnostic } from "./errors.js";
+import type { Instance as PbInstance, ParseFileRequest, SymbolInfo } from "../generated/sysml_pb.js";
+import { type SysMLValue } from "./values.js";
+/** How a source is parsed. */
+export interface ParseOptions {
+    /** Language of inline content ("sysml" or "kerml"); requires `inline_language`. */
+    language?: string;
+    /** Reject the OpenSysML notation extensions; requires `strict_conformance`. */
+    strict?: boolean;
+}
+/** Where an expression is evaluated. */
+export interface EvalOptions {
+    /** FQN of the symbol whose scope the expression's names resolve in. */
+    context?: string;
+    /** FQN of a usage to instantiate and evaluate against; requires `evaluate_subject`. */
+    subject?: string;
+}
+/** A model the service has parsed and holds under its hash. */
+export declare class Model {
+    readonly connection: Connection;
+    /** The hash the service holds this model under; every later call names it. */
+    readonly hash: string;
+    /** Diagnostics the parse reported, in the order the service reported them. */
+    readonly diagnostics: readonly ModelDiagnostic[];
+    private readonly rootSymbol;
+    private readonly ownsConnection;
+    private constructor();
+    /** Adopts a model the service already holds, by the hash it holds it under. */
+    static adopt(connection: Connection, hash: string): Model;
+    /** Whether this model was parsed here, and so knows its root symbol. */
+    get parsed(): boolean;
+    /** The model's root namespace. An adopted model has none: look symbols up by id. */
+    get root(): ModelSymbol;
+    /** Parses a source over `connection`. Used by Connection.load / Connection.loads. */
+    static parse(connection: Connection, source: Pick<ParseFileRequest, "source">, options?: ParseOptions, ownsConnection?: boolean): Promise<Model>;
+    /** Whether the parse reported an error-severity diagnostic. */
+    get hasErrors(): boolean;
+    /** Evaluates a SysML expression against this model. */
+    eval(expression: string, options?: EvalOptions): Promise<SysMLValue>;
+    /** Looks a symbol up by short name, FQN or id; throws when the model declares none. */
+    symbol(name: string): Promise<ModelSymbol>;
+    /** Looks a symbol up by its qualified name, in one call. */
+    symbolById(id: string): Promise<ModelSymbol>;
+    /** Looks a symbol up by short name, FQN or id, breadth-first from the root. */
+    find(name: string): Promise<ModelSymbol | undefined>;
+    /** Every symbol of the model, breadth-first from the root. */
+    walk(): AsyncGenerator<ModelSymbol>;
+    /** Instantiates a part or usage, by short name, FQN or id. */
+    instantiate(name: string): Promise<InstanceTree>;
+    /** Releases the model. Closes the connection only when this model opened it. */
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+    /** Whether a name is one the service can resolve directly, without a search. */
+    private looksQualified;
+    /** The names of the model closest to one it has not got, best first. */
+    private nearNames;
+}
+/** Static type facts about a symbol, as the service reports them. */
+export interface TypeFacts {
+    declared: string;
+    resolvedId: string;
+    resolvedKind: string;
+    primitive: string;
+    primitiveSource: string;
+    quantity: boolean;
+    unit: string;
+}
+/** One attribute of a symbol, with its declared default when it has one. */
+export interface AttributeFacts {
+    name: string;
+    type: string;
+    unit: string;
+    value: SysMLValue;
+}
+/** One specialization relationship a symbol declares or inherits. */
+export interface SpecializationFacts {
+    kind: string;
+    declared: string;
+    targetId: string;
+    targetKind: string;
+}
+/** A symbol of a loaded model. */
+export declare class ModelSymbol {
+    readonly id: string;
+    readonly name: string;
+    readonly kind: string;
+    readonly metadata: Readonly<Record<string, string>>;
+    readonly childIds: readonly string[];
+    readonly attributes: readonly AttributeFacts[];
+    readonly type: TypeFacts | undefined;
+    readonly multiplicity: {
+        lower: string;
+        upper: string;
+    } | undefined;
+    readonly specializations: readonly SpecializationFacts[];
+    /** Library attributes the service did not send, when it withheld any. */
+    readonly withheldLibraryAttributes: number;
+    private readonly connection;
+    private readonly modelHash;
+    constructor(connection: Connection, modelHash: string, info: SymbolInfo);
+    /** The symbols this one owns, fetched one call each. */
+    children(): Promise<ModelSymbol[]>;
+    /** The value of one attribute, or undefined when the symbol declares no such attribute. */
+    attribute(name: string): AttributeFacts | undefined;
+}
+/** One feature's value on an instantiated object. */
+export type FeatureValue = {
+    kind: "single";
+    value: SysMLValue;
+    materialized: boolean;
+} | {
+    kind: "many";
+    values: SysMLValue[];
+} | {
+    kind: "error";
+    error: string;
+};
+/** An instantiated object. */
+export declare class Instance {
+    readonly id: bigint;
+    readonly typeId: string;
+    readonly features: ReadonlyMap<string, FeatureValue>;
+    constructor(instance: PbInstance);
+    /** The value of one feature, or undefined when the object has no such feature. */
+    get(name: string): FeatureValue | undefined;
+}
+/** What one instantiation produced: the root object and every object it owns. */
+export declare class InstanceTree {
+    readonly root: Instance;
+    /** Every object the instantiation produced, the root included when the service sent it. */
+    readonly all: readonly Instance[];
+    readonly diagnostics: readonly ModelDiagnostic[];
+    constructor(root: Instance, all: readonly Instance[], diagnostics: readonly ModelDiagnostic[]);
+    /** The value of one feature of the root object. */
+    get(name: string): FeatureValue | undefined;
+    /** The object with this id, or undefined when the instantiation produced none. */
+    byId(id: bigint): Instance | undefined;
+}

package/dist/core/model.js

@@ -0,0 +1,339 @@
+// The ergonomic surface: a loaded model, its symbols, and the objects it
+// instantiates. Everything here is built on Connection.rpc.
+import { CAPABILITY_EVALUATE_SUBJECT, CAPABILITY_INLINE_LANGUAGE, CAPABILITY_STRICT_CONFORMANCE, requireCapability, upgradeRemedy, } from "./capabilities.js";
+import { EvaluationError, OpenSysMLError, ParseError, SymbolNotFoundError } from "./errors.js";
+import { callRpc } from "./status.js";
+import { decodeValue } from "./values.js";
+/** How alike two names must be for one to be suggested for the other. */
+const NEAR_ENOUGH = 0.6;
+/** Symbols a search for near names reads before giving up, so a big model is cheap. */
+const NEAR_SEARCH_LIMIT = 500;
+/** How alike two names are, from 0 to 1, by edit distance over the longer one. */
+function similarity(left, right) {
+    const longest = Math.max(left.length, right.length);
+    if (longest === 0) {
+        return 1;
+    }
+    return 1 - editDistance(left, right) / longest;
+}
+/** Levenshtein distance, one row of the matrix at a time. */
+function editDistance(left, right) {
+    let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+    for (let row = 1; row <= left.length; row += 1) {
+        const current = [row];
+        for (let column = 1; column <= right.length; column += 1) {
+            const substitution = (previous[column - 1] ?? 0) + (left[row - 1] === right[column - 1] ? 0 : 1);
+            const deletion = (previous[column] ?? 0) + 1;
+            const insertion = (current[column - 1] ?? 0) + 1;
+            current.push(Math.min(substitution, deletion, insertion));
+        }
+        previous = current;
+    }
+    return previous[right.length] ?? 0;
+}
+/** A model the service has parsed and holds under its hash. */
+export class Model {
+    connection;
+    /** The hash the service holds this model under; every later call names it. */
+    hash;
+    /** Diagnostics the parse reported, in the order the service reported them. */
+    diagnostics;
+    rootSymbol;
+    ownsConnection;
+    constructor(init) {
+        this.connection = init.connection;
+        this.hash = init.hash;
+        this.rootSymbol = init.root;
+        this.diagnostics = init.diagnostics;
+        this.ownsConnection = init.ownsConnection;
+    }
+    /** Adopts a model the service already holds, by the hash it holds it under. */
+    static adopt(connection, hash) {
+        return new Model({ connection, hash, diagnostics: [], ownsConnection: false });
+    }
+    /** Whether this model was parsed here, and so knows its root symbol. */
+    get parsed() {
+        return this.rootSymbol !== undefined;
+    }
+    /** The model's root namespace. An adopted model has none: look symbols up by id. */
+    get root() {
+        if (this.rootSymbol === undefined) {
+            throw new OpenSysMLError(`model ${this.hash} was adopted by hash, not parsed here, so its root is unknown; ` +
+                "look a symbol up by its qualified name with symbolById()");
+        }
+        return this.rootSymbol;
+    }
+    /** Parses a source over `connection`. Used by Connection.load / Connection.loads. */
+    static async parse(connection, source, options = {}, ownsConnection = false) {
+        if (options.language !== undefined) {
+            requireCapability(connection.info, CAPABILITY_INLINE_LANGUAGE, upgradeRemedy(CAPABILITY_INLINE_LANGUAGE));
+        }
+        if (options.strict === true) {
+            requireCapability(connection.info, CAPABILITY_STRICT_CONFORMANCE, upgradeRemedy(CAPABILITY_STRICT_CONFORMANCE));
+        }
+        const response = await callRpc(connection.rpc.parseFile({
+            source: source.source,
+            ...(options.language === undefined ? {} : { language: options.language }),
+            ...(options.strict === undefined ? {} : { strictConformance: options.strict }),
+        }, connection.callOptions()), source.source.case === "filePath" ? "file" : "model");
+        const diagnostics = response.diagnostics.map(decodeDiagnostic);
+        if (response.error !== "") {
+            throw new ParseError(response.error, diagnostics);
+        }
+        if (response.root === undefined) {
+            throw new ParseError("the service parsed the source but returned no root symbol", diagnostics);
+        }
+        return new Model({
+            connection,
+            hash: response.modelHash,
+            root: new ModelSymbol(connection, response.modelHash, response.root),
+            diagnostics,
+            ownsConnection,
+        });
+    }
+    /** Whether the parse reported an error-severity diagnostic. */
+    get hasErrors() {
+        return this.diagnostics.some((diagnostic) => diagnostic.severity === "error");
+    }
+    /** Evaluates a SysML expression against this model. */
+    async eval(expression, options = {}) {
+        if (options.subject !== undefined) {
+            requireCapability(this.connection.info, CAPABILITY_EVALUATE_SUBJECT, upgradeRemedy(CAPABILITY_EVALUATE_SUBJECT));
+        }
+        const response = await callRpc(this.connection.rpc.evaluate({
+            modelHash: this.hash,
+            expression,
+            ...(options.context === undefined ? {} : { contextSymbolId: options.context }),
+            ...(options.subject === undefined ? {} : { subjectSymbolId: options.subject }),
+        }, this.connection.callOptions()));
+        if (response.error !== "") {
+            throw new EvaluationError(response.error, "unspecified", response.diagnostics.map(decodeDiagnostic));
+        }
+        return decodeValue(response.result);
+    }
+    /** Looks a symbol up by short name, FQN or id; throws when the model declares none. */
+    async symbol(name) {
+        if (this.looksQualified(name)) {
+            return this.symbolById(name);
+        }
+        // A short name is searched for from the root, which an adopted model has not
+        // got; the service resolves a name the model declares at its top level.
+        if (this.rootSymbol === undefined) {
+            return this.symbolById(name);
+        }
+        const found = await this.find(name);
+        if (found === undefined) {
+            throw new SymbolNotFoundError(name, await this.nearNames(name));
+        }
+        return found;
+    }
+    /** Looks a symbol up by its qualified name, in one call. */
+    async symbolById(id) {
+        const response = await callRpc(this.connection.rpc.getSymbol({ modelHash: this.hash, symbolId: id }, this.connection.callOptions()));
+        if (response.symbol === undefined) {
+            throw new SymbolNotFoundError(id);
+        }
+        return new ModelSymbol(this.connection, this.hash, response.symbol);
+    }
+    /** Looks a symbol up by short name, FQN or id, breadth-first from the root. */
+    async find(name) {
+        for await (const symbol of this.walk()) {
+            if (symbol.name === name || symbol.id === name) {
+                return symbol;
+            }
+        }
+        return undefined;
+    }
+    /** Every symbol of the model, breadth-first from the root. */
+    async *walk() {
+        const queue = [this.root];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (current === undefined) {
+                break;
+            }
+            yield current;
+            queue.push(...(await current.children()));
+        }
+    }
+    /** Instantiates a part or usage, by short name, FQN or id. */
+    async instantiate(name) {
+        const id = this.looksQualified(name) ? name : (await this.symbol(name)).id;
+        const response = await callRpc(this.connection.rpc.instantiate({ modelHash: this.hash, symbolId: id }, this.connection.callOptions()));
+        if (response.error !== "") {
+            throw new EvaluationError(response.error, "unspecified", response.diagnostics.map(decodeDiagnostic));
+        }
+        if (response.instance === undefined) {
+            throw new EvaluationError(`the service instantiated ${id} but returned no object`);
+        }
+        return new InstanceTree(new Instance(response.instance), response.instances.map((instance) => new Instance(instance)), response.diagnostics.map(decodeDiagnostic));
+    }
+    /** Releases the model. Closes the connection only when this model opened it. */
+    async close() {
+        if (this.ownsConnection) {
+            await this.connection.close();
+        }
+    }
+    async [Symbol.asyncDispose]() {
+        await this.close();
+    }
+    /** Whether a name is one the service can resolve directly, without a search. */
+    looksQualified(name) {
+        return name.includes("::") || name === this.rootSymbol?.id;
+    }
+    /** The names of the model closest to one it has not got, best first. */
+    async nearNames(name) {
+        const scored = [];
+        let seen = 0;
+        for await (const symbol of this.walk()) {
+            // An unnamed symbol, the root among them, is near nothing.
+            if (symbol.name === "") {
+                continue;
+            }
+            const score = similarity(name.toLowerCase(), symbol.name.toLowerCase());
+            if (score >= NEAR_ENOUGH) {
+                scored.push({ id: symbol.id, score });
+            }
+            seen += 1;
+            if (seen === NEAR_SEARCH_LIMIT) {
+                break;
+            }
+        }
+        scored.sort((left, right) => right.score - left.score);
+        return scored.slice(0, 3).map((one) => one.id);
+    }
+}
+/** A symbol of a loaded model. */
+export class ModelSymbol {
+    id;
+    name;
+    kind;
+    metadata;
+    childIds;
+    attributes;
+    type;
+    multiplicity;
+    specializations;
+    /** Library attributes the service did not send, when it withheld any. */
+    withheldLibraryAttributes;
+    connection;
+    modelHash;
+    constructor(connection, modelHash, info) {
+        this.connection = connection;
+        this.modelHash = modelHash;
+        this.id = info.id;
+        this.name = info.name;
+        this.kind = info.kind;
+        this.metadata = { ...info.metadata };
+        this.childIds = [...info.childIds];
+        this.attributes = info.attributes.map((attribute) => ({
+            name: attribute.name,
+            type: attribute.type,
+            unit: attribute.unit,
+            value: decodeValue(attribute.value),
+        }));
+        this.type =
+            info.typeInfo === undefined
+                ? undefined
+                : {
+                    declared: info.typeInfo.declared,
+                    resolvedId: info.typeInfo.resolvedId,
+                    resolvedKind: info.typeInfo.resolvedKind,
+                    primitive: info.typeInfo.primitive,
+                    primitiveSource: info.typeInfo.primitiveSource,
+                    quantity: info.typeInfo.quantity,
+                    unit: info.typeInfo.unit,
+                };
+        this.multiplicity =
+            info.multiplicity === undefined
+                ? undefined
+                : { lower: info.multiplicity.lower, upper: info.multiplicity.upper };
+        this.specializations = info.specializations.map((specialization) => ({
+            kind: specialization.kind,
+            declared: specialization.declared,
+            targetId: specialization.targetId,
+            targetKind: specialization.targetKind,
+        }));
+        this.withheldLibraryAttributes = info.withheldLibraryAttributes;
+    }
+    /** The symbols this one owns, fetched one call each. */
+    async children() {
+        const children = [];
+        for (const id of this.childIds) {
+            const response = await callRpc(this.connection.rpc.getSymbol({ modelHash: this.modelHash, symbolId: id }, this.connection.callOptions()));
+            if (response.symbol !== undefined) {
+                children.push(new ModelSymbol(this.connection, this.modelHash, response.symbol));
+            }
+        }
+        return children;
+    }
+    /** The value of one attribute, or undefined when the symbol declares no such attribute. */
+    attribute(name) {
+        return this.attributes.find((attribute) => attribute.name === name);
+    }
+}
+/** An instantiated object. */
+export class Instance {
+    id;
+    typeId;
+    features;
+    constructor(instance) {
+        this.id = instance.id;
+        this.typeId = instance.typeSymbolId;
+        const features = new Map();
+        for (const [name, value] of Object.entries(instance.featureValues)) {
+            features.set(name, decodeFeatureValue(value));
+        }
+        this.features = features;
+    }
+    /** The value of one feature, or undefined when the object has no such feature. */
+    get(name) {
+        return this.features.get(name);
+    }
+}
+/** What one instantiation produced: the root object and every object it owns. */
+export class InstanceTree {
+    root;
+    /** Every object the instantiation produced, the root included when the service sent it. */
+    all;
+    diagnostics;
+    constructor(root, all, diagnostics) {
+        this.root = root;
+        this.all = all;
+        this.diagnostics = diagnostics;
+    }
+    /** The value of one feature of the root object. */
+    get(name) {
+        return this.root.get(name);
+    }
+    /** The object with this id, or undefined when the instantiation produced none. */
+    byId(id) {
+        return this.all.find((instance) => instance.id === id) ?? (this.root.id === id ? this.root : undefined);
+    }
+}
+function decodeFeatureValue(value) {
+    if (value.error !== "") {
+        return { kind: "error", error: value.error };
+    }
+    if (value.values.length > 0) {
+        return { kind: "many", values: value.values.map((element) => decodeValue(element)) };
+    }
+    return { kind: "single", value: decodeValue(value.value), materialized: value.materialized };
+}
+function decodeDiagnostic(diagnostic) {
+    const span = diagnostic.span;
+    return {
+        severity: diagnostic.severity,
+        message: diagnostic.message,
+        code: diagnostic.code,
+        ...(span === undefined
+            ? {}
+            : {
+                file: span.file,
+                startLine: span.startLine,
+                startColumn: span.startCol,
+                endLine: span.endLine,
+                endColumn: span.endCol,
+            }),
+    };
+}

package/dist/core/package.d.ts

@@ -0,0 +1,4 @@
+/** The npm name this client is published under; package.json's "name" must match it. */
+export declare const PACKAGE_NAME = "@openmbee/opensysml";
+/** Prefix of the per-platform packages that carry sysml-grpc: `${prefix}<os>-<cpu>`. */
+export declare const PLATFORM_PACKAGE_PREFIX = "@openmbee/opensysml-sysml-grpc-";

package/dist/core/package.js

@@ -0,0 +1,4 @@
+/** The npm name this client is published under; package.json's "name" must match it. */
+export const PACKAGE_NAME = "@openmbee/opensysml";
+/** Prefix of the per-platform packages that carry sysml-grpc: `${prefix}<os>-<cpu>`. */
+export const PLATFORM_PACKAGE_PREFIX = `${PACKAGE_NAME}-sysml-grpc-`;

package/dist/core/status.d.ts

@@ -0,0 +1,15 @@
+import { Code } from "@connectrpc/connect";
+import { OpenSysMLError, ServiceError } from "./errors.js";
+/** The name of a status code, as a scenario and an error message spell it. */
+export declare function statusName(code: Code): string;
+/**
+ * What a NOT_FOUND names when the service's message does not say. The call site
+ * knows what it asked about: a path, or a model held under a hash.
+ */
+export type NotFoundSubject = "model" | "file";
+/** Translates a failed call into the error for its status. */
+export declare function fromRpcError(error: unknown, notFound?: NotFoundSubject): OpenSysMLError;
+/** Translates a failed handshake, which says which service would not answer. */
+export declare function fromHandshakeError(error: unknown, origin: string): ServiceError;
+/** Awaits a call, translating whatever status it fails with. */
+export declare function callRpc<T>(call: Promise<T>, notFound?: NotFoundSubject): Promise<T>;

package/dist/core/status.js

@@ -0,0 +1,94 @@
+// The client boundary for the service's statuses: a failed call is translated
+// into this client's error hierarchy, keeping the ConnectError as its cause.
+import { Code, ConnectError } from "@connectrpc/connect";
+import { InvalidRequestError, ModelFileNotFoundError, ModelNotFoundError, OpenSysMLError, ServiceError, ServiceTimeoutError, SymbolNotFoundError, UnsupportedOperationError, } from "./errors.js";
+/** A status code as the service's conformance scenarios spell it. */
+const STATUS_NAMES = new Map([
+    [Code.Canceled, "CANCELLED"],
+    [Code.Unknown, "UNKNOWN"],
+    [Code.InvalidArgument, "INVALID_ARGUMENT"],
+    [Code.DeadlineExceeded, "DEADLINE_EXCEEDED"],
+    [Code.NotFound, "NOT_FOUND"],
+    [Code.AlreadyExists, "ALREADY_EXISTS"],
+    [Code.PermissionDenied, "PERMISSION_DENIED"],
+    [Code.ResourceExhausted, "RESOURCE_EXHAUSTED"],
+    [Code.FailedPrecondition, "FAILED_PRECONDITION"],
+    [Code.Aborted, "ABORTED"],
+    [Code.OutOfRange, "OUT_OF_RANGE"],
+    [Code.Unimplemented, "UNIMPLEMENTED"],
+    [Code.Internal, "INTERNAL"],
+    [Code.Unavailable, "UNAVAILABLE"],
+    [Code.DataLoss, "DATA_LOSS"],
+    [Code.Unauthenticated, "UNAUTHENTICATED"],
+]);
+/** The name of a status code, as a scenario and an error message spell it. */
+export function statusName(code) {
+    return STATUS_NAMES.get(code) ?? String(code);
+}
+// Statuses that name a distinct failure. Anything else stays a ServiceError, so
+// a status this client has never seen still arrives inside the hierarchy.
+const CODE_ERRORS = new Map([
+    [Code.InvalidArgument, InvalidRequestError],
+    [Code.FailedPrecondition, InvalidRequestError],
+    [Code.OutOfRange, InvalidRequestError],
+    [Code.DeadlineExceeded, ServiceTimeoutError],
+    [Code.Canceled, ServiceTimeoutError],
+    [Code.Unimplemented, UnsupportedOperationError],
+]);
+/** Translates a failed call into the error for its status. */
+export function fromRpcError(error, notFound = "model") {
+    // A capability refusal or a closed connection is already this client's own.
+    if (error instanceof OpenSysMLError) {
+        return error;
+    }
+    const connectError = ConnectError.from(error);
+    const status = statusName(connectError.code);
+    const message = connectError.rawMessage === ""
+        ? `the sysml-grpc service failed the call with ${status}`
+        : connectError.rawMessage;
+    if (connectError.code === Code.NotFound) {
+        return notFoundError(message, status, notFound, connectError);
+    }
+    const cls = CODE_ERRORS.get(connectError.code) ?? ServiceError;
+    const described = connectError.code === Code.Unavailable ? `sysml-grpc service unavailable: ${message}` : message;
+    return new cls(described, { cause: connectError, code: status });
+}
+/** Translates a failed handshake, which says which service would not answer. */
+export function fromHandshakeError(error, origin) {
+    const connectError = ConnectError.from(error);
+    const cls = CODE_ERRORS.get(connectError.code) ?? ServiceError;
+    return new cls(`the sysml-grpc service at ${origin} did not answer: ${connectError.message}`, {
+        cause: connectError,
+        code: statusName(connectError.code),
+    });
+}
+/** Awaits a call, translating whatever status it fails with. */
+export async function callRpc(call, notFound = "model") {
+    try {
+        return await call;
+    }
+    catch (error) {
+        throw fromRpcError(error, notFound);
+    }
+}
+// The service answers NOT_FOUND for a source file it cannot read, a model hash
+// it no longer holds and a symbol a model does not declare; it says which.
+function notFoundError(message, status, notFound, cause) {
+    const lowered = message.toLowerCase();
+    if (lowered.includes("file not found") || lowered.includes("no such file")) {
+        return new ModelFileNotFoundError(message, { cause, code: status });
+    }
+    if (lowered.includes("model not found")) {
+        return new ModelNotFoundError(message, { cause, code: status });
+    }
+    if (lowered.includes("symbol not found")) {
+        return new SymbolNotFoundError(symbolNameIn(message));
+    }
+    const cls = notFound === "file" ? ModelFileNotFoundError : ModelNotFoundError;
+    return new cls(message, { cause, code: status });
+}
+function symbolNameIn(message) {
+    const marker = "symbol not found: ";
+    const at = message.lastIndexOf(marker);
+    return at === -1 ? message : message.slice(at + marker.length);
+}

package/dist/core/transport.d.ts

@@ -0,0 +1,10 @@
+import type { Interceptor } from "@connectrpc/connect";
+import type { Encoding, TransportOptions } from "./connection.js";
+/** Turns `host:port`, `http://host:port` or a full URL into a Connect base URL. */
+export declare function baseUrl(address: string): string;
+/** The interceptors a connection installs for its headers and its response tap. */
+export declare function interceptors(options: TransportOptions): Interceptor[];
+/** Protobuf unless the caller asked for JSON. */
+export declare function encodingOf(options: TransportOptions): Encoding;
+/** The deadline every call carries, checked: one that cannot elapse is a mistake. */
+export declare function timeoutOf(options: TransportOptions): number | undefined;

package/dist/core/transport.js

@@ -0,0 +1,69 @@
+// Pieces both entry points share: how an address becomes a base URL, and the
+// interceptors a connection installs.
+import { OpenSysMLError } from "./errors.js";
+/** Turns `host:port`, `http://host:port` or a full URL into a Connect base URL. */
+export function baseUrl(address) {
+    const trimmed = address.trim();
+    if (trimmed === "") {
+        throw new OpenSysMLError("the service address is empty");
+    }
+    const withScheme = /^https?:\/\//.test(trimmed) ? trimmed : `http://${trimmed}`;
+    let url;
+    try {
+        url = new URL(withScheme);
+    }
+    catch (cause) {
+        throw new OpenSysMLError(`${JSON.stringify(address)} is not a service address`, { cause });
+    }
+    if (url.port === "" && !/^https?:\/\//.test(trimmed)) {
+        throw new OpenSysMLError(`${JSON.stringify(address)} names no port; a sysml-grpc address is host:port`);
+    }
+    return url.origin + url.pathname.replace(/\/$/, "");
+}
+/** The interceptors a connection installs for its headers and its response tap. */
+export function interceptors(options) {
+    const built = [];
+    const headers = options.headers;
+    if (headers !== undefined) {
+        built.push((next) => (request) => {
+            for (const [name, value] of Object.entries(headers)) {
+                request.header.set(name, value);
+            }
+            return next(request);
+        });
+    }
+    const tap = options.onResponse;
+    if (tap !== undefined) {
+        built.push(responseTap(tap));
+    }
+    return built;
+}
+const ENCODINGS = new Set(["protobuf", "json"]);
+/** Protobuf unless the caller asked for JSON. */
+export function encodingOf(options) {
+    const encoding = options.encoding ?? "protobuf";
+    if (!ENCODINGS.has(encoding)) {
+        throw new OpenSysMLError(`${JSON.stringify(encoding)} is not a body encoding; a connection carries "protobuf" or "json"`);
+    }
+    return encoding;
+}
+/** The deadline every call carries, checked: one that cannot elapse is a mistake. */
+export function timeoutOf(options) {
+    const timeoutMs = options.timeoutMs;
+    if (timeoutMs === undefined) {
+        return undefined;
+    }
+    if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        throw new OpenSysMLError(`timeoutMs is a deadline in milliseconds and must be positive, not ${JSON.stringify(timeoutMs)}`);
+    }
+    return timeoutMs;
+}
+function responseTap(tap) {
+    return (next) => async (request) => {
+        const response = await next(request);
+        if (!response.stream) {
+            tap({ method: request.method.name, response: response.message });
+        }
+        return response;
+    };
+}