@openmbee/opensysml 0.9.2 → 0.10.1

package/dist/core/query.js

@@ -0,0 +1,197 @@
+// Querying a model the way the SysML v2 API & Services standard queries one:
+// scope / select / where, where `where` is a primitive or composite constraint.
+// Accepts the standard's JSON verbatim, or the same thing as options.
+import { create } from "@bufbuild/protobuf";
+import { CompositeOperator, ConstraintSchema, PrimitiveOperator, QuerySchema, } from "../generated/sysml_pb.js";
+import { byCodeUnit } from "./capabilities.js";
+import { QueryError } from "./errors.js";
+const TYPE_KEY = "@type";
+/** `@type` of the standard's query resource. */
+export const TYPE_QUERY = "Query";
+/** `@type` of a single-property constraint. */
+export const TYPE_PRIMITIVE_CONSTRAINT = "PrimitiveConstraint";
+/** `@type` of a constraint over nested constraints. */
+export const TYPE_COMPOSITE_CONSTRAINT = "CompositeConstraint";
+const PRIMITIVE_OPERATORS = new Map([
+    ["=", PrimitiveOperator.EQUAL],
+    [">", PrimitiveOperator.GREATER],
+    ["<", PrimitiveOperator.LESS],
+]);
+const COMPOSITE_OPERATORS = new Map([
+    ["and", CompositeOperator.AND],
+    ["or", CompositeOperator.OR],
+]);
+/** An element a query selected. */
+export class QueryElement {
+    /** Qualified name of the element, which is what a scope names it by. */
+    id;
+    /** The element's metamodel type, e.g. `PartUsage`. */
+    type;
+    /** The selected properties it has; one it does not have is absent. */
+    properties;
+    constructor(init) {
+        this.id = init.id;
+        this.type = init.type;
+        this.properties = { ...init.properties };
+    }
+    /** Value of a selected property, or `fallback` if the element has none. */
+    get(propertyName, fallback) {
+        return this.properties[propertyName] ?? fallback;
+    }
+    /** The element as the standard's JSON names it: `@id`, `@type`, properties. */
+    asDict() {
+        return { "@id": this.id, "@type": this.type, ...this.properties };
+    }
+    toString() {
+        return `${this.id} (${this.type})`;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Translate a query, given as the standard's JSON or as keywords, to protobuf. */
+export function buildQuery(options = {}) {
+    const { payload } = options;
+    let { scope, select, where } = options;
+    if (payload !== undefined) {
+        if (scope !== undefined || select !== undefined || where !== undefined) {
+            throw new QueryError("pass a query payload or scope/select/where keywords, not both");
+        }
+        if (!isRecord(payload)) {
+            throw new QueryError("a query is an object, not a " + typeof payload);
+        }
+        const declared = payload[TYPE_KEY] ?? TYPE_QUERY;
+        if (declared !== TYPE_QUERY) {
+            throw new QueryError(`expected a ${JSON.stringify(TYPE_QUERY)} payload, got ${JSON.stringify(declared)}`);
+        }
+        const unknown = Object.keys(payload).filter((key) => ![TYPE_KEY, "@id", "owningProject", "scope", "select", "where"].includes(key));
+        if (unknown.length > 0) {
+            unknown.sort(byCodeUnit);
+            throw new QueryError(`a query has no ${unknown.join(", ")}; the standard's query is scope, select and where`);
+        }
+        scope = payload.scope;
+        select = payload.select;
+        where = payload.where;
+    }
+    const query = create(QuerySchema, {
+        scope: sequence("scope", scope).map(scopeId),
+        select: sequence("select", select).map(propertyName),
+    });
+    if (where !== undefined) {
+        query.where = constraint(where);
+    }
+    return query;
+}
+function scopeId(entry) {
+    if (typeof entry === "string") {
+        return entry;
+    }
+    if (isRecord(entry) && typeof entry["@id"] === "string") {
+        return entry["@id"];
+    }
+    throw new QueryError(`a scope entry is an element's qualified name or a {'@id': ...} reference, not ${JSON.stringify(entry)}`);
+}
+function propertyName(entry) {
+    if (typeof entry !== "string") {
+        throw new QueryError(`a selected property is a name, not ${JSON.stringify(entry)}`);
+    }
+    return entry;
+}
+function sequence(field, value) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (typeof value === "string" || isRecord(value)) {
+        return [value];
+    }
+    if (!Array.isArray(value)) {
+        throw new QueryError(`${field} is a list, not ${typeof value}`);
+    }
+    return value;
+}
+function constraint(payload) {
+    if (!isRecord(payload)) {
+        throw new QueryError(`a constraint is an object, not ${typeof payload}`);
+    }
+    let declared = payload[TYPE_KEY];
+    if (declared === undefined) {
+        declared = "constraint" in payload ? TYPE_COMPOSITE_CONSTRAINT : TYPE_PRIMITIVE_CONSTRAINT;
+    }
+    if (declared === TYPE_PRIMITIVE_CONSTRAINT) {
+        return create(ConstraintSchema, {
+            constraint: { case: "primitive", value: primitive(payload) },
+        });
+    }
+    if (declared === TYPE_COMPOSITE_CONSTRAINT) {
+        return create(ConstraintSchema, {
+            constraint: { case: "composite", value: composite(payload) },
+        });
+    }
+    throw new QueryError(`unknown constraint type ${JSON.stringify(declared)}; the standard's constraints are ` +
+        `${TYPE_PRIMITIVE_CONSTRAINT} and ${TYPE_COMPOSITE_CONSTRAINT}`);
+}
+function rejectUnknown(payload, known, what) {
+    const unknown = Object.keys(payload).filter((key) => !known.includes(key));
+    if (unknown.length > 0) {
+        unknown.sort(byCodeUnit);
+        throw new QueryError(`a ${what} has no ${unknown.join(", ")}`);
+    }
+}
+function primitive(payload) {
+    rejectUnknown(payload, [TYPE_KEY, "@id", "inverse", "property", "operator", "value"], TYPE_PRIMITIVE_CONSTRAINT);
+    const operator = payload.operator;
+    const mapped = typeof operator === "string" ? PRIMITIVE_OPERATORS.get(operator) : undefined;
+    if (mapped === undefined) {
+        throw new QueryError(`unknown primitive operator ${JSON.stringify(operator)}; expected one of ` +
+            [...PRIMITIVE_OPERATORS.keys()].sort(byCodeUnit).join(", "));
+    }
+    const name = payload.property;
+    if (typeof name !== "string" || name === "") {
+        throw new QueryError(`a primitive constraint names one property, not ${JSON.stringify(name)}`);
+    }
+    return {
+        inverse: payload.inverse === true,
+        property: name,
+        operator: mapped,
+        value: values(payload.value),
+    };
+}
+function composite(payload) {
+    rejectUnknown(payload, [TYPE_KEY, "@id", "constraint", "operator"], TYPE_COMPOSITE_CONSTRAINT);
+    const operator = payload.operator;
+    const mapped = typeof operator === "string" ? COMPOSITE_OPERATORS.get(operator) : undefined;
+    if (mapped === undefined) {
+        throw new QueryError(`unknown composite operator ${JSON.stringify(operator)}; expected one of ` +
+            [...COMPOSITE_OPERATORS.keys()].sort(byCodeUnit).join(", "));
+    }
+    const nested = payload.constraint;
+    if (!Array.isArray(nested) || nested.length === 0) {
+        throw new QueryError(`a composite constraint combines a non-empty list of constraints, not ${JSON.stringify(nested)}`);
+    }
+    return {
+        operator: mapped,
+        constraint: nested.map(constraint),
+    };
+}
+function values(value) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value.map(compared);
+    }
+    return [compared(value)];
+}
+function compared(value) {
+    if (typeof value === "boolean") {
+        return value ? "true" : "false";
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "bigint") {
+        return String(value);
+    }
+    throw new QueryError(`cannot compare against ${JSON.stringify(value)}`);
+}
+/** The elements a `QueryResponse` reports, as `QueryElement` records. */
+export function elementsOf(response) {
+    return response.elements.map((element) => new QueryElement({ id: element.id, type: element.type, properties: element.properties }));
+}

package/dist/core/render-view.d.ts

@@ -0,0 +1,97 @@
+import type { RenderViewResponse } from "../generated/sysml_pb.js";
+export interface RenderSpan {
+    file: string;
+    startLine: number;
+    startCol: number;
+    endLine: number;
+    endCol: number;
+}
+export interface RenderPort {
+    id: string;
+    name: string;
+    type: string;
+    direction: string;
+}
+export interface RenderGeometry {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    hasSize: boolean;
+    collapsed: boolean;
+}
+export interface RenderStyle {
+    fill: string;
+    line: string;
+    text: string;
+    font: string;
+    fontSize: number;
+    bold: boolean;
+    italic: boolean;
+}
+export interface RenderPoint {
+    x: number;
+    y: number;
+}
+export interface RenderNode {
+    id: string;
+    kind: string;
+    name: string;
+    nameSynthesized: boolean;
+    type: string;
+    detail: string;
+    text: string;
+    standIn: boolean;
+    parent: string;
+    ports: readonly RenderPort[];
+    origin?: RenderSpan;
+    geometry?: RenderGeometry;
+    style?: RenderStyle;
+}
+export interface RenderEdge {
+    from: string;
+    to: string;
+    fromPort: string;
+    toPort: string;
+    label: string;
+    name: string;
+    kind: string;
+    origin?: RenderSpan;
+    route: readonly RenderPoint[];
+    style?: RenderStyle;
+}
+export interface RenderCanvas {
+    unit: string;
+    width: number;
+    height: number;
+    hasSize: boolean;
+}
+export interface RenderRow {
+    cells: readonly string[];
+    origin?: RenderSpan;
+}
+export interface RenderNote {
+    text: string;
+    anchor: string;
+    edgeFrom: string;
+    edgeTo: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    hasSize: boolean;
+    origin?: RenderSpan;
+}
+export interface RenderedView {
+    view: string;
+    kind: string;
+    stated: string;
+    nodes: readonly RenderNode[];
+    edges: readonly RenderEdge[];
+    columns: readonly string[];
+    rows: readonly RenderRow[];
+    canvas?: RenderCanvas;
+    notes: readonly RenderNote[];
+    notices: readonly string[];
+}
+export declare function renderedViewOf(response: RenderViewResponse): RenderedView;

package/dist/core/render-view.js

@@ -0,0 +1,120 @@
+function spanOf(span) {
+    return span === undefined
+        ? undefined
+        : {
+            file: span.file,
+            startLine: span.startLine,
+            startCol: span.startCol,
+            endLine: span.endLine,
+            endCol: span.endCol,
+        };
+}
+function geometryOf(geometry) {
+    return geometry === undefined
+        ? undefined
+        : {
+            x: geometry.x,
+            y: geometry.y,
+            width: geometry.width,
+            height: geometry.height,
+            hasSize: geometry.hasSize,
+            collapsed: geometry.collapsed,
+        };
+}
+function styleOf(style) {
+    return style === undefined
+        ? undefined
+        : {
+            fill: style.fill,
+            line: style.line,
+            text: style.text,
+            font: style.font,
+            fontSize: style.fontSize,
+            bold: style.bold,
+            italic: style.italic,
+        };
+}
+function portOf(port) {
+    return { id: port.id, name: port.name, type: port.type, direction: port.direction };
+}
+function pointOf(point) {
+    return { x: point.x, y: point.y };
+}
+function nodeOf(node) {
+    const origin = spanOf(node.origin);
+    const geometry = geometryOf(node.geometry);
+    const style = styleOf(node.style);
+    return {
+        id: node.id,
+        kind: node.kind,
+        name: node.name,
+        nameSynthesized: node.nameSynthesized,
+        type: node.type,
+        detail: node.detail,
+        text: node.text,
+        standIn: node.standIn,
+        parent: node.parent,
+        ports: node.ports.map(portOf),
+        ...(origin === undefined ? {} : { origin }),
+        ...(geometry === undefined ? {} : { geometry }),
+        ...(style === undefined ? {} : { style }),
+    };
+}
+function edgeOf(edge) {
+    const origin = spanOf(edge.origin);
+    const style = styleOf(edge.style);
+    return {
+        from: edge.from,
+        to: edge.to,
+        fromPort: edge.fromPort,
+        toPort: edge.toPort,
+        label: edge.label,
+        name: edge.name,
+        kind: edge.kind,
+        route: edge.route.map(pointOf),
+        ...(origin === undefined ? {} : { origin }),
+        ...(style === undefined ? {} : { style }),
+    };
+}
+function rowOf(row) {
+    const origin = spanOf(row.origin);
+    return {
+        cells: [...row.cells],
+        ...(origin === undefined ? {} : { origin }),
+    };
+}
+function noteOf(note) {
+    const origin = spanOf(note.origin);
+    return {
+        text: note.text,
+        anchor: note.anchor,
+        edgeFrom: note.edgeFrom,
+        edgeTo: note.edgeTo,
+        x: note.x,
+        y: note.y,
+        width: note.width,
+        height: note.height,
+        hasSize: note.hasSize,
+        ...(origin === undefined ? {} : { origin }),
+    };
+}
+function canvasOf(canvas) {
+    return canvas === undefined
+        ? undefined
+        : { unit: canvas.unit, width: canvas.width, height: canvas.height, hasSize: canvas.hasSize };
+}
+export function renderedViewOf(response) {
+    const canvas = canvasOf(response.canvas);
+    return {
+        view: response.view,
+        kind: response.kind,
+        stated: response.stated,
+        nodes: response.nodes.map(nodeOf),
+        edges: response.edges.map(edgeOf),
+        columns: [...response.columns],
+        rows: response.rows.map(rowOf),
+        notes: response.notes.map(noteOf),
+        notices: [...response.notices],
+        ...(canvas === undefined ? {} : { canvas }),
+    };
+}

package/dist/core/sources.d.ts

@@ -0,0 +1,34 @@
+import type { SourceDocument as PbSourceDocument } from "../generated/sysml_pb.js";
+/** Languages inline content may be declared in. */
+export declare const LANGUAGES: readonly ["sysml", "kerml"];
+/** Refuses a `language` option that names no language, before any call. */
+export declare function requireLanguage(language: string): void;
+/** One document of a model parsed from several. Build with `file` or `inline`. */
+export declare class SourceDocument {
+    /** File the service reads; its extension says which notation it is. */
+    readonly path: string | undefined;
+    /** Inline model source, parsed under `name`. */
+    readonly content: string | undefined;
+    /** What diagnostics call inline content; empty for a file, named by its path. */
+    readonly name: string;
+    /** Notation of inline content; `sysml` when unset. */
+    readonly language: string | undefined;
+    private constructor();
+    /** A file the service reads, named by its path. */
+    static file(path: string): SourceDocument;
+    /** Inline content, reported and indexed under `name`. */
+    static inline(name: string, content: string, options?: {
+        language?: string;
+    }): SourceDocument;
+    /** The name diagnostics report this document under: the path or name. */
+    get documentName(): string;
+    /** The `sysml.SourceDocument` message that sends this document. */
+    toPb(): PbSourceDocument;
+}
+/** What `parseSources` accepts for one document. */
+export type Source = string | readonly [name: string, content: string] | SourceDocument;
+/**
+ * The `SourceDocument` for each of `documents`, validated as Python's
+ * `source_documents` does: a sequence of at least one, no two named alike.
+ */
+export declare function sourceDocuments(documents: readonly Source[]): SourceDocument[];

package/dist/core/sources.js

@@ -0,0 +1,134 @@
+// The documents of a model parsed from several sources at once. Each is a file
+// the service reads, or inline content under a name; both forms also have a
+// SourceDocument the `inline`/`file` factories build.
+import { create } from "@bufbuild/protobuf";
+import { requireSourceText, requireString } from "./arguments.js";
+import { SourceDocumentSchema } from "../generated/sysml_pb.js";
+/** Languages inline content may be declared in. */
+export const LANGUAGES = ["sysml", "kerml"];
+/** Refuses a `language` option that names no language, before any call. */
+export function requireLanguage(language) {
+    if (!LANGUAGES.includes(language)) {
+        throw new RangeError(`language must be "sysml" or "kerml", got "${language}"`);
+    }
+}
+/** One document of a model parsed from several. Build with `file` or `inline`. */
+export class SourceDocument {
+    /** File the service reads; its extension says which notation it is. */
+    path;
+    /** Inline model source, parsed under `name`. */
+    content;
+    /** What diagnostics call inline content; empty for a file, named by its path. */
+    name;
+    /** Notation of inline content; `sysml` when unset. */
+    language;
+    constructor(init) {
+        if (init.name !== undefined) {
+            requireString("name", init.name);
+        }
+        for (const [field, value] of [
+            ["path", init.path],
+            ["content", init.content],
+            ["language", init.language],
+        ]) {
+            if (value !== undefined) {
+                requireString(field, value);
+            }
+        }
+        if (init.content !== undefined) {
+            requireSourceText("content", init.content);
+        }
+        if ((init.path === undefined) === (init.content === undefined)) {
+            throw new RangeError("a SourceDocument is either a file path or inline content, not both");
+        }
+        if (init.path !== undefined) {
+            if (init.path === "") {
+                throw new RangeError("a file document needs a path");
+            }
+            if (init.name !== undefined && init.name !== "") {
+                throw new RangeError("a file document is named by its path; name applies to inline content");
+            }
+            if (init.language !== undefined) {
+                throw new RangeError("a file's extension says which language it is; language applies to inline content");
+            }
+        }
+        else {
+            if (init.name === undefined || init.name === "") {
+                throw new RangeError("inline content needs a name; diagnostics report it under that name");
+            }
+            if (init.language !== undefined) {
+                requireLanguage(init.language);
+            }
+        }
+        this.path = init.path;
+        this.content = init.content;
+        this.name = init.name ?? "";
+        this.language = init.language;
+    }
+    /** A file the service reads, named by its path. */
+    static file(path) {
+        return new SourceDocument({ path });
+    }
+    /** Inline content, reported and indexed under `name`. */
+    static inline(name, content, options = {}) {
+        return new SourceDocument({ content, name, ...(options.language === undefined ? {} : { language: options.language }) });
+    }
+    /** The name diagnostics report this document under: the path or name. */
+    get documentName() {
+        return this.path ?? this.name;
+    }
+    /** The `sysml.SourceDocument` message that sends this document. */
+    toPb() {
+        if (this.path !== undefined) {
+            return create(SourceDocumentSchema, { source: { case: "filePath", value: this.path } });
+        }
+        return create(SourceDocumentSchema, {
+            source: { case: "content", value: this.content ?? "" },
+            name: this.name,
+            language: this.language ?? "",
+        });
+    }
+}
+function isNamedContent(document) {
+    return (Array.isArray(document) &&
+        document.length === 2 &&
+        typeof document[0] === "string" &&
+        typeof document[1] === "string");
+}
+/**
+ * The `SourceDocument` for each of `documents`, validated as Python's
+ * `source_documents` does: a sequence of at least one, no two named alike.
+ */
+export function sourceDocuments(documents) {
+    if (!Array.isArray(documents)) {
+        throw new TypeError("parseSources takes a sequence of documents; write one document as [document]");
+    }
+    const result = [];
+    for (const [position, document] of documents.entries()) {
+        if (document instanceof SourceDocument) {
+            result.push(document);
+        }
+        else if (typeof document === "string") {
+            result.push(SourceDocument.file(document));
+        }
+        else if (isNamedContent(document)) {
+            result.push(SourceDocument.inline(document[0], document[1]));
+        }
+        else {
+            throw new TypeError(`document ${position} is of an unexpected form; expected a path, a ` +
+                `(name, content) pair or a SourceDocument`);
+        }
+    }
+    if (result.length === 0) {
+        throw new RangeError("parseSources needs at least one document");
+    }
+    const seen = new Set();
+    for (const document of result) {
+        const name = document.documentName;
+        if (seen.has(name)) {
+            throw new RangeError(`two documents are named ${JSON.stringify(name)}`);
+        }
+        seen.add(name);
+    }
+    return result;
+}

package/dist/core/status.d.ts

@@ -7,9 +7,16 @@ export declare function statusName(code: Code): string;
  * knows what it asked about: a path, or a model held under a hash.
  */
 export type NotFoundSubject = "model" | "file";
+/**
+ * What to make of an UNIMPLEMENTED the service answered with anyway, such as a
+ * capability-gated call refused by a service that checked its own list: the
+ * capabilities the call required, mapped to the MissingCapabilityError the
+ * preflight check meant to raise.
+ */
+export type UnimplementedMapping = (details: string) => OpenSysMLError;
 /** Translates a failed call into the error for its status. */
-export declare function fromRpcError(error: unknown, notFound?: NotFoundSubject): OpenSysMLError;
+export declare function fromRpcError(error: unknown, notFound?: NotFoundSubject, unimplemented?: UnimplementedMapping): 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>;
+export declare function callRpc<T>(call: Promise<T>, notFound?: NotFoundSubject, unimplemented?: UnimplementedMapping): Promise<T>;

package/dist/core/status.js

@@ -1,7 +1,7 @@
 // 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";
+import { InvalidRequestError, ModelFileNotFoundError, ModelNotFoundError, OpenSysMLError, ServiceError, ServiceTimeoutError, ServiceUnavailableError, SymbolNotFoundError, UnsupportedOperationError, } from "./errors.js";
 /** A status code as the service's conformance scenarios spell it. */
 const STATUS_NAMES = new Map([
     [Code.Canceled, "CANCELLED"],
@@ -33,10 +33,11 @@ const CODE_ERRORS = new Map([
     [Code.OutOfRange, InvalidRequestError],
     [Code.DeadlineExceeded, ServiceTimeoutError],
     [Code.Canceled, ServiceTimeoutError],
+    [Code.Unavailable, ServiceUnavailableError],
     [Code.Unimplemented, UnsupportedOperationError],
 ]);
 /** Translates a failed call into the error for its status. */
-export function fromRpcError(error, notFound = "model") {
+export function fromRpcError(error, notFound = "model", unimplemented) {
     // A capability refusal or a closed connection is already this client's own.
     if (error instanceof OpenSysMLError) {
         return error;
@@ -49,26 +50,41 @@ export function fromRpcError(error, notFound = "model") {
     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;
+    if (connectError.code === Code.Unimplemented && unimplemented !== undefined) {
+        const refusal = unimplemented(connectError.rawMessage);
+        refusal.cause = connectError;
+        return refusal;
+    }
+    const unreachable = fetchRefused(connectError);
+    const cls = CODE_ERRORS.get(connectError.code) ??
+        (unreachable ? ServiceUnavailableError : ServiceError);
+    const described = connectError.code === Code.Unavailable || unreachable
+        ? `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;
+    const cls = CODE_ERRORS.get(connectError.code) ??
+        (fetchRefused(connectError) ? ServiceUnavailableError : ServiceError);
     return new cls(`the sysml-grpc service at ${origin} did not answer: ${connectError.message}`, {
         cause: connectError,
         code: statusName(connectError.code),
     });
 }
+// A browser fetch that never reached the service rejects with a TypeError,
+// which ConnectError.from reports as UNKNOWN with that TypeError as its cause.
+function fetchRefused(connectError) {
+    return (connectError.code === Code.Unknown && connectError.cause instanceof TypeError);
+}
 /** Awaits a call, translating whatever status it fails with. */
-export async function callRpc(call, notFound = "model") {
+export async function callRpc(call, notFound = "model", unimplemented) {
     try {
         return await call;
     }
     catch (error) {
-        throw fromRpcError(error, notFound);
+        throw fromRpcError(error, notFound, unimplemented);
     }
 }
 // The service answers NOT_FOUND for a source file it cannot read, a model hash
@@ -82,7 +98,7 @@ function notFoundError(message, status, notFound, cause) {
         return new ModelNotFoundError(message, { cause, code: status });
     }
     if (lowered.includes("symbol not found")) {
-        return new SymbolNotFoundError(symbolNameIn(message));
+        return new SymbolNotFoundError(symbolNameIn(message), [], { cause });
     }
     const cls = notFound === "file" ? ModelFileNotFoundError : ModelNotFoundError;
     return new cls(message, { cause, code: status });