@archont561/qgis-sdk-bridge 0.1.1 → 0.2.0

package/dist/shared/chunk-a7bjgeve.js

@@ -0,0 +1,422 @@
+import {
+  QgisSdkError2,
+  isPlainRecord2
+} from "./chunk-0fknax6w.js";
+
+// src/bridge.ts
+var BRIDGE_PROTOCOL_VERSION2 = 1;
+var MAX_CALL_ID_LENGTH2 = 128;
+
+class QgisSdkBridgeProtocolError2 extends QgisSdkError2 {
+  constructor(message) {
+    super(message, "invalid_bridge_message");
+  }
+}
+
+class QgisSdkBridgeTimeoutError2 extends QgisSdkError2 {
+  callId;
+  constructor(callId, timeoutMs) {
+    super(`Call ${JSON.stringify(callId)} got no reply within ${timeoutMs}ms; the host may still have run it`, "timeout");
+    this.callId = callId;
+  }
+}
+
+class QgisSdkBridgeAbortedError2 extends QgisSdkError2 {
+  callId;
+  constructor(callId) {
+    super(`Call ${JSON.stringify(callId)} was aborted locally`, "aborted");
+    this.callId = callId;
+  }
+}
+
+class QgisSdkBridgeClosedError2 extends QgisSdkError2 {
+  constructor() {
+    super("This bridge client is closed", "closed");
+  }
+}
+
+class QgisSdkBridgeSequenceError2 extends QgisSdkError2 {
+  subscriptionId;
+  expected;
+  received;
+  constructor(subscriptionId, expected, received) {
+    super(`Subscription ${JSON.stringify(subscriptionId)} expected frame ${expected} but received ${received}`, "stream_gap");
+    this.subscriptionId = subscriptionId;
+    this.expected = expected;
+    this.received = received;
+  }
+}
+
+class QgisSdkBridgeStreamEndedError2 extends QgisSdkError2 {
+  subscriptionId;
+  terminal;
+  constructor(subscriptionId, terminal) {
+    super(terminal.message ?? `Subscription ${JSON.stringify(subscriptionId)} ended: ${terminal.kind}`, terminal.kind);
+    this.subscriptionId = subscriptionId;
+    this.terminal = terminal;
+  }
+}
+
+class QgisSdkBridgeRemoteError2 extends QgisSdkError2 {
+  failure;
+  callId;
+  constructor(callId, failure) {
+    super(failure.message, failure.code);
+    this.callId = callId;
+    this.failure = failure;
+  }
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function parseInvokeReply2(raw) {
+  if (!isPlainRecord2(raw)) {
+    throw new QgisSdkBridgeProtocolError2("A reply must be an object");
+  }
+  if (raw.protocol !== BRIDGE_PROTOCOL_VERSION2) {
+    throw new QgisSdkBridgeProtocolError2(`Unsupported bridge protocol: ${String(raw.protocol)}; this client speaks ${BRIDGE_PROTOCOL_VERSION2}`);
+  }
+  if (!isNonEmptyString(raw.call_id) || raw.call_id.length > MAX_CALL_ID_LENGTH2) {
+    throw new QgisSdkBridgeProtocolError2(`call_id must be a nonempty string of at most ${MAX_CALL_ID_LENGTH2} characters`);
+  }
+  const callId = raw.call_id;
+  if (typeof raw.ok !== "boolean") {
+    throw new QgisSdkBridgeProtocolError2(`${callId}: ok must be a boolean`);
+  }
+  if (raw.ok) {
+    if (!Object.hasOwn(raw, "value")) {
+      throw new QgisSdkBridgeProtocolError2(`${callId}: a success reply must carry a value`);
+    }
+    return Object.freeze({
+      protocol: BRIDGE_PROTOCOL_VERSION2,
+      call_id: callId,
+      ok: true,
+      value: raw.value
+    });
+  }
+  if (!isPlainRecord2(raw.error)) {
+    throw new QgisSdkBridgeProtocolError2(`${callId}: a failure reply must carry an error object`);
+  }
+  if (!isNonEmptyString(raw.error.code)) {
+    throw new QgisSdkBridgeProtocolError2(`${callId}: error.code must be a string`);
+  }
+  if (typeof raw.error.message !== "string") {
+    throw new QgisSdkBridgeProtocolError2(`${callId}: error.message must be a string`);
+  }
+  return Object.freeze({
+    protocol: BRIDGE_PROTOCOL_VERSION2,
+    call_id: callId,
+    ok: false,
+    error: Object.freeze({
+      code: raw.error.code,
+      message: raw.error.message
+    })
+  });
+}
+function isIndex(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+var EVENT_KINDS = ["data", "progress", "state"];
+var TERMINAL_KINDS = [
+  "cancelled",
+  "complete",
+  "disposed",
+  "error",
+  "gap"
+];
+function parseStreamFrame2(raw) {
+  if (!isPlainRecord2(raw)) {
+    throw new QgisSdkBridgeProtocolError2("A stream frame must be an object");
+  }
+  if (raw.protocol !== BRIDGE_PROTOCOL_VERSION2) {
+    throw new QgisSdkBridgeProtocolError2(`Unsupported bridge protocol: ${String(raw.protocol)}; this client speaks ${BRIDGE_PROTOCOL_VERSION2}`);
+  }
+  if (!isNonEmptyString(raw.subscription_id)) {
+    throw new QgisSdkBridgeProtocolError2("A stream frame must name its subscription");
+  }
+  if (!isIndex(raw.seq)) {
+    throw new QgisSdkBridgeProtocolError2(`${raw.subscription_id}: seq must be a non-negative integer`);
+  }
+  const hasEvent = Object.hasOwn(raw, "event");
+  const hasTerminal = Object.hasOwn(raw, "terminal");
+  if (hasEvent === hasTerminal) {
+    throw new QgisSdkBridgeProtocolError2(`${raw.subscription_id}: a stream frame carries an event or a terminal, not both`);
+  }
+  if (hasEvent) {
+    if (!isPlainRecord2(raw.event)) {
+      throw new QgisSdkBridgeProtocolError2(`${raw.subscription_id}: event must be an object`);
+    }
+    const kind = raw.event.kind;
+    if (!EVENT_KINDS.includes(kind)) {
+      throw new QgisSdkBridgeProtocolError2(`${raw.subscription_id}: ${String(kind)} is not an event kind`);
+    }
+    return Object.freeze({
+      protocol: BRIDGE_PROTOCOL_VERSION2,
+      subscription_id: raw.subscription_id,
+      seq: raw.seq,
+      event: Object.freeze({
+        kind,
+        payload: raw.event.payload
+      })
+    });
+  }
+  if (!isPlainRecord2(raw.terminal)) {
+    throw new QgisSdkBridgeProtocolError2(`${raw.subscription_id}: terminal must be an object`);
+  }
+  const kind = raw.terminal.kind;
+  if (!TERMINAL_KINDS.includes(kind)) {
+    throw new QgisSdkBridgeProtocolError2(`${raw.subscription_id}: ${String(kind)} is not a terminal kind`);
+  }
+  if (raw.terminal.message !== undefined && typeof raw.terminal.message !== "string") {
+    throw new QgisSdkBridgeProtocolError2(`${raw.subscription_id}: terminal.message must be a string`);
+  }
+  if (raw.terminal.dropped !== undefined && !isIndex(raw.terminal.dropped)) {
+    throw new QgisSdkBridgeProtocolError2(`${raw.subscription_id}: terminal.dropped must be a non-negative integer`);
+  }
+  return Object.freeze({
+    protocol: BRIDGE_PROTOCOL_VERSION2,
+    subscription_id: raw.subscription_id,
+    seq: raw.seq,
+    terminal: Object.freeze({
+      kind,
+      ...typeof raw.terminal.message === "string" ? { message: raw.terminal.message } : {},
+      ...isIndex(raw.terminal.dropped) ? { dropped: raw.terminal.dropped } : {}
+    })
+  });
+}
+
+class BridgeClient2 {
+  transport;
+  timeoutMs;
+  pending = new Map;
+  subscriptions = new Map;
+  disposals = new Set;
+  unsubscribe;
+  counter = 0;
+  closed = false;
+  unmatched = 0;
+  breaks = 0;
+  lastProtocolError = null;
+  constructor(transport, options = {}) {
+    this.transport = transport;
+    this.timeoutMs = options.timeoutMs ?? 30000;
+    this.unsubscribe = transport.subscribe((message) => {
+      this.handle(message);
+    });
+  }
+  get isClosed() {
+    return this.closed;
+  }
+  get unmatchedReplies() {
+    return this.unmatched;
+  }
+  get pendingCalls() {
+    return this.pending.size;
+  }
+  invoke(operation, payload = {}, options = {}) {
+    if (!isNonEmptyString(operation)) {
+      return Promise.reject(new QgisSdkBridgeProtocolError2("operation must be a nonempty string"));
+    }
+    return this.send({ kind: "invoke", operation, payload }, options);
+  }
+  subscribe(operation, payload = {}, handlers = {}, options = {}) {
+    if (!isNonEmptyString(operation)) {
+      return Promise.reject(new QgisSdkBridgeProtocolError2("operation must be a nonempty string"));
+    }
+    return this.send({ kind: "subscribe", operation, payload }, options).then((value) => {
+      const id = isPlainRecord2(value) ? value.subscription_id : undefined;
+      if (!isNonEmptyString(id)) {
+        throw new QgisSdkBridgeProtocolError2("A subscription acknowledgement must carry a subscription_id");
+      }
+      const open = {
+        id,
+        handlers,
+        expectedSeq: 0,
+        closed: false
+      };
+      this.subscriptions.set(id, open);
+      const handle = {
+        id,
+        get closed() {
+          return open.closed;
+        },
+        close: () => {
+          this.endSubscription(id, { kind: "disposed" }, true);
+        }
+      };
+      return handle;
+    });
+  }
+  get activeSubscriptions() {
+    return [...this.subscriptions.keys()];
+  }
+  get sequenceBreaks() {
+    return this.breaks;
+  }
+  send(body, options) {
+    if (this.closed) {
+      return Promise.reject(new QgisSdkBridgeClosedError2);
+    }
+    this.counter += 1;
+    const callId = `c${this.counter}`;
+    const promise = new Promise((resolve, reject) => {
+      if (options.signal?.aborted === true) {
+        reject(new QgisSdkBridgeAbortedError2(callId));
+        return;
+      }
+      const onAbort = () => {
+        const pending = this.pending.get(callId);
+        if (pending === undefined) {
+          return;
+        }
+        this.settle(callId);
+        pending.reject(new QgisSdkBridgeAbortedError2(callId));
+      };
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+      const timer = this.timeoutMs > 0 ? setTimeout(() => {
+        const pending = this.pending.get(callId);
+        if (pending === undefined) {
+          return;
+        }
+        this.settle(callId);
+        pending.reject(new QgisSdkBridgeTimeoutError2(callId, this.timeoutMs));
+      }, this.timeoutMs) : null;
+      const detach = options.signal === undefined ? null : () => {
+        options.signal?.removeEventListener("abort", onAbort);
+      };
+      this.pending.set(callId, { resolve, reject, timer, detach });
+      this.transport.send({
+        protocol: BRIDGE_PROTOCOL_VERSION2,
+        call_id: callId,
+        ...body
+      });
+    });
+    return promise;
+  }
+  close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.unsubscribe();
+    for (const id of [...this.subscriptions.keys()]) {
+      this.endSubscription(id, { kind: "disposed" }, false);
+    }
+    for (const callId of [...this.pending.keys()]) {
+      const pending = this.pending.get(callId);
+      if (pending === undefined) {
+        continue;
+      }
+      this.settle(callId);
+      pending.reject(new QgisSdkBridgeClosedError2);
+    }
+  }
+  settle(callId) {
+    const pending = this.pending.get(callId);
+    if (pending === undefined) {
+      return;
+    }
+    this.pending.delete(callId);
+    if (pending.timer !== null) {
+      clearTimeout(pending.timer);
+    }
+    pending.detach?.();
+    return pending;
+  }
+  handle(message) {
+    if (isPlainRecord2(message) && Object.hasOwn(message, "subscription_id")) {
+      this.handleFrame(message);
+      return;
+    }
+    let reply;
+    try {
+      reply = parseInvokeReply2(message);
+    } catch (error) {
+      this.unmatched += 1;
+      if (error instanceof Error) {
+        this.lastProtocolError = error;
+      }
+      return;
+    }
+    if (this.disposals.delete(reply.call_id)) {
+      return;
+    }
+    const pending = this.settle(reply.call_id);
+    if (pending === undefined) {
+      this.unmatched += 1;
+      return;
+    }
+    if (reply.ok) {
+      pending.resolve(reply.value);
+      return;
+    }
+    pending.reject(new QgisSdkBridgeRemoteError2(reply.call_id, reply.error));
+  }
+  handleFrame(raw) {
+    let frame;
+    try {
+      frame = parseStreamFrame2(raw);
+    } catch (error) {
+      this.unmatched += 1;
+      if (error instanceof Error) {
+        this.lastProtocolError = error;
+      }
+      return;
+    }
+    const open = this.subscriptions.get(frame.subscription_id);
+    if (open === undefined) {
+      this.unmatched += 1;
+      return;
+    }
+    if (frame.seq !== open.expectedSeq) {
+      this.breaks += 1;
+      const expected = open.expectedSeq;
+      this.endSubscription(frame.subscription_id, {
+        kind: "gap",
+        message: `Expected frame ${expected} but received ${frame.seq}`,
+        dropped: Math.max(0, frame.seq - expected)
+      }, true);
+      return;
+    }
+    open.expectedSeq += 1;
+    if ("terminal" in frame) {
+      this.endSubscription(frame.subscription_id, frame.terminal, false);
+      return;
+    }
+    open.handlers.onEvent?.(frame.event);
+  }
+  endSubscription(id, terminal, notifyHost) {
+    const open = this.subscriptions.get(id);
+    if (open === undefined || open.closed) {
+      return;
+    }
+    open.closed = true;
+    this.subscriptions.delete(id);
+    if (notifyHost) {
+      this.disposeSubscription(id);
+    }
+    open.handlers.onTerminal?.(terminal);
+  }
+  disposeSubscription(id) {
+    if (this.closed) {
+      return;
+    }
+    this.counter += 1;
+    const callId = `c${this.counter}`;
+    this.disposals.add(callId);
+    this.transport.send({
+      protocol: BRIDGE_PROTOCOL_VERSION2,
+      call_id: callId,
+      kind: "unsubscribe",
+      subscription_id: id
+    });
+  }
+  get protocolError() {
+    return this.lastProtocolError;
+  }
+}
+
+export { BRIDGE_PROTOCOL_VERSION2, MAX_CALL_ID_LENGTH2, QgisSdkBridgeProtocolError2, QgisSdkBridgeTimeoutError2, QgisSdkBridgeAbortedError2, QgisSdkBridgeClosedError2, QgisSdkBridgeSequenceError2, QgisSdkBridgeStreamEndedError2, QgisSdkBridgeRemoteError2, parseInvokeReply2, parseStreamFrame2, BridgeClient2 };
+
+//# debugId=C89F8A8A5D4AF50B64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/bridge.ts"],
  "sourcesContent": [
    "/**\n * The versioned transport contract a web view speaks (TASK-4, first slice).\n *\n * This module is the client half of `qgis_sdk.bridge`: it parses the replies the\n * host produces, correlates them by call id, and refuses anything that does not\n * match the protocol instead of guessing. It is deliberately usable without a\n * QWebChannel - the transport is injected - so failures can be scripted in a\n * test rather than reproduced inside a running QGIS.\n *\n * Two properties matter more than the API surface:\n *\n * - A malformed reply is refused, never coerced. A frontend that accepts\n *   `{ok: \"yes\"}` or an error without a code ends up switching on text.\n * - A local timeout says nothing about the host. The call may have run, so it is\n *   reported as an unknown outcome and is never retried automatically.\n */\n\nimport { isPlainRecord, QgisSdkError } from \"./index\";\n\nexport const BRIDGE_PROTOCOL_VERSION: 1 = 1;\nexport const MAX_CALL_ID_LENGTH: number = 128;\n\n/** A failure reply, as the host serialized it. */\nexport interface BridgeFailure {\n\treadonly code: string;\n\treadonly message: string;\n}\n\n/** A reply to one invocation: exactly one of `value` or `error` is present. */\nexport type InvokeReply =\n\t| {\n\t\t\treadonly protocol: 1;\n\t\t\treadonly call_id: string;\n\t\t\treadonly ok: true;\n\t\t\treadonly value: unknown;\n\t  }\n\t| {\n\t\t\treadonly protocol: 1;\n\t\t\treadonly call_id: string;\n\t\t\treadonly ok: false;\n\t\t\treadonly error: BridgeFailure;\n\t  };\n\n/** The kinds of event a stream may carry; only `progress` may be coalesced. */\nexport type StreamEventKind = \"data\" | \"progress\" | \"state\";\n\n/** Why a subscription stopped. */\nexport type StreamTerminalKind =\n\t| \"complete\"\n\t| \"error\"\n\t| \"cancelled\"\n\t| \"gap\"\n\t| \"disposed\";\n\n/** One event on a subscription. */\nexport interface BridgeStreamEvent {\n\treadonly kind: StreamEventKind;\n\treadonly payload: unknown;\n}\n\n/** The end of a subscription, as the host described it. */\nexport interface BridgeStreamTerminal {\n\treadonly kind: StreamTerminalKind;\n\treadonly message?: string;\n\treadonly dropped?: number;\n}\n\n/** A frame carrying one event. */\nexport interface BridgeEventFrame {\n\treadonly protocol: 1;\n\treadonly subscription_id: string;\n\treadonly seq: number;\n\treadonly event: BridgeStreamEvent;\n}\n\n/** The frame that ends a subscription. */\nexport interface BridgeTerminalFrame {\n\treadonly protocol: 1;\n\treadonly subscription_id: string;\n\treadonly seq: number;\n\treadonly terminal: BridgeStreamTerminal;\n}\n\n/** Anything the host may send for a subscription. */\nexport type BridgeStreamFrame = BridgeEventFrame | BridgeTerminalFrame;\n\n/** The transport a client speaks through; a QWebChannel adapter or a script. */\nexport interface WireTransport {\n\tsend(message: unknown): void;\n\tsubscribe(listener: (message: unknown) => void): () => void;\n}\n\n/** Options for {@link BridgeClient}. */\nexport interface BridgeClientOptions {\n\treadonly timeoutMs?: number;\n}\n\n/** Options for one invocation. */\nexport interface InvokeOptions {\n\treadonly signal?: AbortSignal;\n}\n\n/**\n * An envelope or reply does not match the versioned bridge protocol.\n */\nexport class QgisSdkBridgeProtocolError extends QgisSdkError {\n\tpublic constructor(message: string) {\n\t\tsuper(message, \"invalid_bridge_message\");\n\t}\n}\n\n/**\n * The host did not answer in time. The call may still have run, so this is an\n * unknown outcome: retrying automatically is forbidden, deciding is the caller's.\n */\nexport class QgisSdkBridgeTimeoutError extends QgisSdkError {\n\tpublic readonly callId: string;\n\n\tpublic constructor(callId: string, timeoutMs: number) {\n\t\tsuper(\n\t\t\t`Call ${JSON.stringify(callId)} got no reply within ${timeoutMs}ms; the host may still have run it`,\n\t\t\t\"timeout\",\n\t\t);\n\t\tthis.callId = callId;\n\t}\n}\n\n/**\n * The caller aborted locally. Distinct from the host cancelling the operation,\n * which arrives as a failure reply carrying the `cancelled` code.\n */\nexport class QgisSdkBridgeAbortedError extends QgisSdkError {\n\tpublic readonly callId: string;\n\n\tpublic constructor(callId: string) {\n\t\tsuper(`Call ${JSON.stringify(callId)} was aborted locally`, \"aborted\");\n\t\tthis.callId = callId;\n\t}\n}\n\n/**\n * The client was closed, so pending calls can no longer be answered.\n */\nexport class QgisSdkBridgeClosedError extends QgisSdkError {\n\tpublic constructor() {\n\t\tsuper(\"This bridge client is closed\", \"closed\");\n\t}\n}\n\n/**\n * A subscription's frames were not the sequence the host promised.\n *\n * The client does not try to reassemble: a missed frame is a fact about the\n * subscription, not something to paper over.\n */\nexport class QgisSdkBridgeSequenceError extends QgisSdkError {\n\tpublic readonly subscriptionId: string;\n\tpublic readonly expected: number;\n\tpublic readonly received: number;\n\n\tpublic constructor(\n\t\tsubscriptionId: string,\n\t\texpected: number,\n\t\treceived: number,\n\t) {\n\t\tsuper(\n\t\t\t`Subscription ${JSON.stringify(subscriptionId)} expected frame ${expected} but received ${received}`,\n\t\t\t\"stream_gap\",\n\t\t);\n\t\tthis.subscriptionId = subscriptionId;\n\t\tthis.expected = expected;\n\t\tthis.received = received;\n\t}\n}\n\n/**\n * The subscription ended with a terminal frame the caller may want to inspect.\n */\nexport class QgisSdkBridgeStreamEndedError extends QgisSdkError {\n\tpublic readonly subscriptionId: string;\n\tpublic readonly terminal: BridgeStreamTerminal;\n\n\tpublic constructor(subscriptionId: string, terminal: BridgeStreamTerminal) {\n\t\tsuper(\n\t\t\tterminal.message ??\n\t\t\t\t`Subscription ${JSON.stringify(subscriptionId)} ended: ${terminal.kind}`,\n\t\t\tterminal.kind,\n\t\t);\n\t\tthis.subscriptionId = subscriptionId;\n\t\tthis.terminal = terminal;\n\t}\n}\n\n/**\n * The host refused or failed the operation; `failure.code` is the contract.\n */\nexport class QgisSdkBridgeRemoteError extends QgisSdkError {\n\tpublic readonly failure: BridgeFailure;\n\tpublic readonly callId: string;\n\n\tpublic constructor(callId: string, failure: BridgeFailure) {\n\t\tsuper(failure.message, failure.code);\n\t\tthis.callId = callId;\n\t\tthis.failure = failure;\n\t}\n}\n\nfunction isNonEmptyString(value: unknown): value is string {\n\treturn typeof value === \"string\" && value.trim().length > 0;\n}\n\n/**\n * Parse one reply, refusing anything the host could not legitimately have sent.\n */\nexport function parseInvokeReply(raw: unknown): InvokeReply {\n\tif (!isPlainRecord(raw)) {\n\t\tthrow new QgisSdkBridgeProtocolError(\"A reply must be an object\");\n\t}\n\tif (raw.protocol !== BRIDGE_PROTOCOL_VERSION) {\n\t\tthrow new QgisSdkBridgeProtocolError(\n\t\t\t`Unsupported bridge protocol: ${String(raw.protocol)}; this client speaks ${BRIDGE_PROTOCOL_VERSION}`,\n\t\t);\n\t}\n\tif (\n\t\t!isNonEmptyString(raw.call_id) ||\n\t\traw.call_id.length > MAX_CALL_ID_LENGTH\n\t) {\n\t\tthrow new QgisSdkBridgeProtocolError(\n\t\t\t`call_id must be a nonempty string of at most ${MAX_CALL_ID_LENGTH} characters`,\n\t\t);\n\t}\n\tconst callId = raw.call_id;\n\tif (typeof raw.ok !== \"boolean\") {\n\t\tthrow new QgisSdkBridgeProtocolError(`${callId}: ok must be a boolean`);\n\t}\n\tif (raw.ok) {\n\t\tif (!Object.hasOwn(raw, \"value\")) {\n\t\t\tthrow new QgisSdkBridgeProtocolError(\n\t\t\t\t`${callId}: a success reply must carry a value`,\n\t\t\t);\n\t\t}\n\t\treturn Object.freeze({\n\t\t\tprotocol: BRIDGE_PROTOCOL_VERSION,\n\t\t\tcall_id: callId,\n\t\t\tok: true as const,\n\t\t\tvalue: raw.value,\n\t\t});\n\t}\n\tif (!isPlainRecord(raw.error)) {\n\t\tthrow new QgisSdkBridgeProtocolError(\n\t\t\t`${callId}: a failure reply must carry an error object`,\n\t\t);\n\t}\n\tif (!isNonEmptyString(raw.error.code)) {\n\t\tthrow new QgisSdkBridgeProtocolError(\n\t\t\t`${callId}: error.code must be a string`,\n\t\t);\n\t}\n\tif (typeof raw.error.message !== \"string\") {\n\t\tthrow new QgisSdkBridgeProtocolError(\n\t\t\t`${callId}: error.message must be a string`,\n\t\t);\n\t}\n\treturn Object.freeze({\n\t\tprotocol: BRIDGE_PROTOCOL_VERSION,\n\t\tcall_id: callId,\n\t\tok: false as const,\n\t\terror: Object.freeze({\n\t\t\tcode: raw.error.code,\n\t\t\tmessage: raw.error.message,\n\t\t}),\n\t});\n}\n\nfunction isIndex(value: unknown): value is number {\n\treturn typeof value === \"number\" && Number.isSafeInteger(value) && value >= 0;\n}\n\nconst EVENT_KINDS: readonly StreamEventKind[] = [\"data\", \"progress\", \"state\"];\nconst TERMINAL_KINDS: readonly StreamTerminalKind[] = [\n\t\"cancelled\",\n\t\"complete\",\n\t\"disposed\",\n\t\"error\",\n\t\"gap\",\n];\n\n/**\n * Parse one stream frame, refusing anything the host could not legitimately\n * have sent.\n *\n * Exactly one of `event` and `terminal` has to be present: a frame that carries\n * both leaves the client guessing which one wins, and a client that guesses is\n * a client that will eventually deliver an event after the end of a stream.\n */\nexport function parseStreamFrame(raw: unknown): BridgeStreamFrame {\n\tif (!isPlainRecord(raw)) {\n\t\tthrow new QgisSdkBridgeProtocolError(\"A stream frame must be an object\");\n\t}\n\tif (raw.protocol !== BRIDGE_PROTOCOL_VERSION) {\n\t\tthrow new QgisSdkBridgeProtocolError(\n\t\t\t`Unsupported bridge protocol: ${String(raw.protocol)}; this client speaks ${BRIDGE_PROTOCOL_VERSION}`,\n\t\t);\n\t}\n\tif (!isNonEmptyString(raw.subscription_id)) {\n\t\tthrow new QgisSdkBridgeProtocolError(\n\t\t\t\"A stream frame must name its subscription\",\n\t\t);\n\t}\n\tif (!isIndex(raw.seq)) {\n\t\tthrow new QgisSdkBridgeProtocolError(\n\t\t\t`${raw.subscription_id}: seq must be a non-negative integer`,\n\t\t);\n\t}\n\tconst hasEvent = Object.hasOwn(raw, \"event\");\n\tconst hasTerminal = Object.hasOwn(raw, \"terminal\");\n\tif (hasEvent === hasTerminal) {\n\t\tthrow new QgisSdkBridgeProtocolError(\n\t\t\t`${raw.subscription_id}: a stream frame carries an event or a terminal, not both`,\n\t\t);\n\t}\n\tif (hasEvent) {\n\t\tif (!isPlainRecord(raw.event)) {\n\t\t\tthrow new QgisSdkBridgeProtocolError(\n\t\t\t\t`${raw.subscription_id}: event must be an object`,\n\t\t\t);\n\t\t}\n\t\tconst kind = raw.event.kind;\n\t\tif (!EVENT_KINDS.includes(kind as StreamEventKind)) {\n\t\t\tthrow new QgisSdkBridgeProtocolError(\n\t\t\t\t`${raw.subscription_id}: ${String(kind)} is not an event kind`,\n\t\t\t);\n\t\t}\n\t\treturn Object.freeze({\n\t\t\tprotocol: BRIDGE_PROTOCOL_VERSION,\n\t\t\tsubscription_id: raw.subscription_id,\n\t\t\tseq: raw.seq,\n\t\t\tevent: Object.freeze({\n\t\t\t\tkind: kind as StreamEventKind,\n\t\t\t\tpayload: raw.event.payload,\n\t\t\t}),\n\t\t});\n\t}\n\tif (!isPlainRecord(raw.terminal)) {\n\t\tthrow new QgisSdkBridgeProtocolError(\n\t\t\t`${raw.subscription_id}: terminal must be an object`,\n\t\t);\n\t}\n\tconst kind = raw.terminal.kind;\n\tif (!TERMINAL_KINDS.includes(kind as StreamTerminalKind)) {\n\t\tthrow new QgisSdkBridgeProtocolError(\n\t\t\t`${raw.subscription_id}: ${String(kind)} is not a terminal kind`,\n\t\t);\n\t}\n\tif (\n\t\traw.terminal.message !== undefined &&\n\t\ttypeof raw.terminal.message !== \"string\"\n\t) {\n\t\tthrow new QgisSdkBridgeProtocolError(\n\t\t\t`${raw.subscription_id}: terminal.message must be a string`,\n\t\t);\n\t}\n\tif (raw.terminal.dropped !== undefined && !isIndex(raw.terminal.dropped)) {\n\t\tthrow new QgisSdkBridgeProtocolError(\n\t\t\t`${raw.subscription_id}: terminal.dropped must be a non-negative integer`,\n\t\t);\n\t}\n\treturn Object.freeze({\n\t\tprotocol: BRIDGE_PROTOCOL_VERSION,\n\t\tsubscription_id: raw.subscription_id,\n\t\tseq: raw.seq,\n\t\tterminal: Object.freeze({\n\t\t\tkind: kind as StreamTerminalKind,\n\t\t\t...(typeof raw.terminal.message === \"string\"\n\t\t\t\t? { message: raw.terminal.message }\n\t\t\t\t: {}),\n\t\t\t...(isIndex(raw.terminal.dropped)\n\t\t\t\t? { dropped: raw.terminal.dropped }\n\t\t\t\t: {}),\n\t\t}),\n\t});\n}\n\n/** Callbacks a subscription reports through. */\nexport interface SubscriptionHandlers {\n\treadonly onEvent?: (event: BridgeStreamEvent) => void;\n\treadonly onTerminal?: (terminal: BridgeStreamTerminal) => void;\n}\n\n/** A live subscription, as the caller holds it. */\nexport interface BridgeSubscription {\n\treadonly id: string;\n\treadonly closed: boolean;\n\tclose(): void;\n}\n\ninterface OpenSubscription {\n\treadonly id: string;\n\treadonly handlers: SubscriptionHandlers;\n\texpectedSeq: number;\n\tclosed: boolean;\n}\n\ninterface PendingCall {\n\treadonly resolve: (value: unknown) => void;\n\treadonly reject: (error: Error) => void;\n\treadonly timer: ReturnType<typeof setTimeout> | null;\n\treadonly detach: (() => void) | null;\n}\n\n/**\n * Correlate invocations with replies over an injected transport.\n *\n * The client never retries: a timeout, an abort and a closed client are three\n * different answers, and each is reported as itself.\n */\nexport class BridgeClient {\n\tprivate readonly transport: WireTransport;\n\tprivate readonly timeoutMs: number;\n\tprivate readonly pending: Map<string, PendingCall> = new Map();\n\tprivate readonly subscriptions: Map<string, OpenSubscription> = new Map();\n\tprivate readonly disposals: Set<string> = new Set();\n\tprivate readonly unsubscribe: () => void;\n\tprivate counter: number = 0;\n\tprivate closed: boolean = false;\n\tprivate unmatched: number = 0;\n\tprivate breaks: number = 0;\n\tprivate lastProtocolError: Error | null = null;\n\n\tpublic constructor(\n\t\ttransport: WireTransport,\n\t\toptions: BridgeClientOptions = {},\n\t) {\n\t\tthis.transport = transport;\n\t\tthis.timeoutMs = options.timeoutMs ?? 30_000;\n\t\tthis.unsubscribe = transport.subscribe((message) => {\n\t\t\tthis.handle(message);\n\t\t});\n\t}\n\n\t/** Whether {@link close} has run; a closed client answers nothing. */\n\tpublic get isClosed(): boolean {\n\t\treturn this.closed;\n\t}\n\n\t/** Replies that named no pending call: a late duplicate, or a stray message. */\n\tpublic get unmatchedReplies(): number {\n\t\treturn this.unmatched;\n\t}\n\n\t/** Number of calls still waiting for a reply. */\n\tpublic get pendingCalls(): number {\n\t\treturn this.pending.size;\n\t}\n\n\t/**\n\t * Invoke one operation and settle with its value or with a typed failure.\n\t */\n\tpublic invoke(\n\t\toperation: string,\n\t\tpayload: Readonly<Record<string, unknown>> = {},\n\t\toptions: InvokeOptions = {},\n\t): Promise<unknown> {\n\t\tif (!isNonEmptyString(operation)) {\n\t\t\treturn Promise.reject(\n\t\t\t\tnew QgisSdkBridgeProtocolError(\"operation must be a nonempty string\"),\n\t\t\t);\n\t\t}\n\t\treturn this.send({ kind: \"invoke\", operation, payload }, options);\n\t}\n\n\t/**\n\t * Open a subscription and resolve once the host has acknowledged it.\n\t *\n\t * Frames are matched to the subscription by id and by sequence; a frame that\n\t * does not continue the sequence ends the subscription instead of being\n\t * delivered out of order.\n\t */\n\tpublic subscribe(\n\t\toperation: string,\n\t\tpayload: Readonly<Record<string, unknown>> = {},\n\t\thandlers: SubscriptionHandlers = {},\n\t\toptions: InvokeOptions = {},\n\t): Promise<BridgeSubscription> {\n\t\tif (!isNonEmptyString(operation)) {\n\t\t\treturn Promise.reject(\n\t\t\t\tnew QgisSdkBridgeProtocolError(\"operation must be a nonempty string\"),\n\t\t\t);\n\t\t}\n\t\treturn this.send({ kind: \"subscribe\", operation, payload }, options).then(\n\t\t\t(value) => {\n\t\t\t\tconst id = isPlainRecord(value) ? value.subscription_id : undefined;\n\t\t\t\tif (!isNonEmptyString(id)) {\n\t\t\t\t\tthrow new QgisSdkBridgeProtocolError(\n\t\t\t\t\t\t\"A subscription acknowledgement must carry a subscription_id\",\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t\tconst open: OpenSubscription = {\n\t\t\t\t\tid,\n\t\t\t\t\thandlers,\n\t\t\t\t\texpectedSeq: 0,\n\t\t\t\t\tclosed: false,\n\t\t\t\t};\n\t\t\t\tthis.subscriptions.set(id, open);\n\t\t\t\tconst handle: BridgeSubscription = {\n\t\t\t\t\tid,\n\t\t\t\t\tget closed(): boolean {\n\t\t\t\t\t\treturn open.closed;\n\t\t\t\t\t},\n\t\t\t\t\tclose: (): void => {\n\t\t\t\t\t\tthis.endSubscription(id, { kind: \"disposed\" }, true);\n\t\t\t\t\t},\n\t\t\t\t};\n\t\t\t\treturn handle;\n\t\t\t},\n\t\t);\n\t}\n\n\t/** Subscriptions still open; a leak check for callers and tests. */\n\tpublic get activeSubscriptions(): readonly string[] {\n\t\treturn [...this.subscriptions.keys()];\n\t}\n\n\t/** Frames that did not continue their subscription's sequence. */\n\tpublic get sequenceBreaks(): number {\n\t\treturn this.breaks;\n\t}\n\n\tprivate send(\n\t\tbody: Readonly<Record<string, unknown>>,\n\t\toptions: InvokeOptions,\n\t): Promise<unknown> {\n\t\tif (this.closed) {\n\t\t\treturn Promise.reject(new QgisSdkBridgeClosedError());\n\t\t}\n\t\tthis.counter += 1;\n\t\tconst callId = `c${this.counter}`;\n\n\t\tconst promise = new Promise<unknown>((resolve, reject) => {\n\t\t\tif (options.signal?.aborted === true) {\n\t\t\t\treject(new QgisSdkBridgeAbortedError(callId));\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tconst onAbort = (): void => {\n\t\t\t\tconst pending = this.pending.get(callId);\n\t\t\t\tif (pending === undefined) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tthis.settle(callId);\n\t\t\t\tpending.reject(new QgisSdkBridgeAbortedError(callId));\n\t\t\t};\n\t\t\toptions.signal?.addEventListener(\"abort\", onAbort, { once: true });\n\n\t\t\tconst timer =\n\t\t\t\tthis.timeoutMs > 0\n\t\t\t\t\t? setTimeout(() => {\n\t\t\t\t\t\t\tconst pending = this.pending.get(callId);\n\t\t\t\t\t\t\tif (pending === undefined) {\n\t\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tthis.settle(callId);\n\t\t\t\t\t\t\tpending.reject(\n\t\t\t\t\t\t\t\tnew QgisSdkBridgeTimeoutError(callId, this.timeoutMs),\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t}, this.timeoutMs)\n\t\t\t\t\t: null;\n\n\t\t\tconst detach =\n\t\t\t\toptions.signal === undefined\n\t\t\t\t\t? null\n\t\t\t\t\t: (): void => {\n\t\t\t\t\t\t\toptions.signal?.removeEventListener(\"abort\", onAbort);\n\t\t\t\t\t\t};\n\n\t\t\tthis.pending.set(callId, { resolve, reject, timer, detach });\n\t\t\tthis.transport.send({\n\t\t\t\tprotocol: BRIDGE_PROTOCOL_VERSION,\n\t\t\t\tcall_id: callId,\n\t\t\t\t...body,\n\t\t\t});\n\t\t});\n\n\t\treturn promise;\n\t}\n\n\t/**\n\t * Refuse further calls, reject what is still pending, and stop listening.\n\t */\n\tpublic close(): void {\n\t\tif (this.closed) {\n\t\t\treturn;\n\t\t}\n\t\tthis.closed = true;\n\t\tthis.unsubscribe();\n\t\tfor (const id of [...this.subscriptions.keys()]) {\n\t\t\tthis.endSubscription(id, { kind: \"disposed\" }, false);\n\t\t}\n\t\tfor (const callId of [...this.pending.keys()]) {\n\t\t\tconst pending = this.pending.get(callId);\n\t\t\tif (pending === undefined) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tthis.settle(callId);\n\t\t\tpending.reject(new QgisSdkBridgeClosedError());\n\t\t}\n\t}\n\n\tprivate settle(callId: string): PendingCall | undefined {\n\t\tconst pending = this.pending.get(callId);\n\t\tif (pending === undefined) {\n\t\t\treturn undefined;\n\t\t}\n\t\tthis.pending.delete(callId);\n\t\tif (pending.timer !== null) {\n\t\t\tclearTimeout(pending.timer);\n\t\t}\n\t\tpending.detach?.();\n\t\treturn pending;\n\t}\n\n\tprivate handle(message: unknown): void {\n\t\tif (isPlainRecord(message) && Object.hasOwn(message, \"subscription_id\")) {\n\t\t\tthis.handleFrame(message);\n\t\t\treturn;\n\t\t}\n\t\tlet reply: InvokeReply;\n\t\ttry {\n\t\t\treply = parseInvokeReply(message);\n\t\t} catch (error) {\n\t\t\t// A malformed message cannot be attributed to a call, so it cannot\n\t\t\t// settle one: the call keeps waiting and eventually times out, which\n\t\t\t// is the honest answer about an outcome the client could not read.\n\t\t\tthis.unmatched += 1;\n\t\t\tif (error instanceof Error) {\n\t\t\t\tthis.lastProtocolError = error;\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\t\tif (this.disposals.delete(reply.call_id)) {\n\t\t\treturn;\n\t\t}\n\t\tconst pending = this.settle(reply.call_id);\n\t\tif (pending === undefined) {\n\t\t\tthis.unmatched += 1;\n\t\t\treturn;\n\t\t}\n\t\tif (reply.ok) {\n\t\t\tpending.resolve(reply.value);\n\t\t\treturn;\n\t\t}\n\t\tpending.reject(new QgisSdkBridgeRemoteError(reply.call_id, reply.error));\n\t}\n\n\tprivate handleFrame(raw: unknown): void {\n\t\tlet frame: BridgeStreamFrame;\n\t\ttry {\n\t\t\tframe = parseStreamFrame(raw);\n\t\t} catch (error) {\n\t\t\t// A frame that cannot be parsed cannot be attributed either, so it is\n\t\t\t// counted rather than delivered to whatever subscription looks closest.\n\t\t\tthis.unmatched += 1;\n\t\t\tif (error instanceof Error) {\n\t\t\t\tthis.lastProtocolError = error;\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\t\tconst open = this.subscriptions.get(frame.subscription_id);\n\t\tif (open === undefined) {\n\t\t\tthis.unmatched += 1;\n\t\t\treturn;\n\t\t}\n\t\tif (frame.seq !== open.expectedSeq) {\n\t\t\tthis.breaks += 1;\n\t\t\tconst expected = open.expectedSeq;\n\t\t\tthis.endSubscription(\n\t\t\t\tframe.subscription_id,\n\t\t\t\t{\n\t\t\t\t\tkind: \"gap\",\n\t\t\t\t\tmessage: `Expected frame ${expected} but received ${frame.seq}`,\n\t\t\t\t\tdropped: Math.max(0, frame.seq - expected),\n\t\t\t\t},\n\t\t\t\ttrue,\n\t\t\t);\n\t\t\treturn;\n\t\t}\n\t\topen.expectedSeq += 1;\n\t\tif (\"terminal\" in frame) {\n\t\t\tthis.endSubscription(frame.subscription_id, frame.terminal, false);\n\t\t\treturn;\n\t\t}\n\t\topen.handlers.onEvent?.(frame.event);\n\t}\n\n\tprivate endSubscription(\n\t\tid: string,\n\t\tterminal: BridgeStreamTerminal,\n\t\tnotifyHost: boolean,\n\t): void {\n\t\tconst open = this.subscriptions.get(id);\n\t\tif (open === undefined || open.closed) {\n\t\t\treturn;\n\t\t}\n\t\topen.closed = true;\n\t\tthis.subscriptions.delete(id);\n\t\tif (notifyHost) {\n\t\t\tthis.disposeSubscription(id);\n\t\t}\n\t\topen.handlers.onTerminal?.(terminal);\n\t}\n\n\tprivate disposeSubscription(id: string): void {\n\t\tif (this.closed) {\n\t\t\treturn;\n\t\t}\n\t\tthis.counter += 1;\n\t\tconst callId = `c${this.counter}`;\n\t\tthis.disposals.add(callId);\n\t\tthis.transport.send({\n\t\t\tprotocol: BRIDGE_PROTOCOL_VERSION,\n\t\t\tcall_id: callId,\n\t\t\tkind: \"unsubscribe\",\n\t\t\tsubscription_id: id,\n\t\t});\n\t}\n\n\t/** The last malformed message this client refused, if any. */\n\tpublic get protocolError(): Error | null {\n\t\treturn this.lastProtocolError;\n\t}\n}\n"
  ],
  "mappings": "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",
  "debugId": "C89F8A8A5D4AF50B64756E2164756E21",
  "names": []
}

package/dist/testing.d.ts

@@ -0,0 +1,109 @@
+/**
+* Base class for expected SDK errors across the bridge boundary.
+*/
+declare class QgisSdkError extends Error {
+	readonly code: string;
+	constructor(message: string, code?: string);
+}
+/** The kinds of event a stream may carry; only `progress` may be coalesced. */
+type StreamEventKind2 = "data" | "progress" | "state";
+/** Why a subscription stopped. */
+type StreamTerminalKind = "complete" | "error" | "cancelled" | "gap" | "disposed";
+/** The end of a subscription, as the host described it. */
+interface BridgeStreamTerminal {
+	readonly kind: StreamTerminalKind;
+	readonly message?: string;
+	readonly dropped?: number;
+}
+/** The transport a client speaks through; a QWebChannel adapter or a script. */
+interface WireTransport {
+	send(message: unknown): void;
+	subscribe(listener: (message: unknown) => void): () => void;
+}
+/** A scripted host failure, returned from an expectation's handler. */
+interface ScriptedFault {
+	readonly fault: {
+		readonly code: string;
+		readonly message: string;
+	};
+}
+/** Script a failure reply with this code and message. */
+declare function fault(code: string, message: string): ScriptedFault;
+/** Return this from a handler to never answer, so the client's timeout speaks. */
+declare const SILENCE: unique symbol;
+/** A subscription the script turns down: a fault reply, or no reply at all. */
+type ScriptedRefusal = ScriptedFault | typeof SILENCE;
+/**
+* A subscribe expectation's script: emit on `stream` now or later, or return
+* a refusal instead of acknowledging.
+*/
+type SubscribeScript<Req extends object> = (payload: Req, stream: ScriptedStream) => ScriptedRefusal | void;
+/** What an invoke expectation may answer with. */
+type ScriptedReply<Res> = Res | ScriptedFault | typeof SILENCE | Promise<Res | ScriptedFault | typeof SILENCE>;
+/** A message the client sent, as the harness recorded it. */
+interface RecordedCall {
+	readonly callId: string;
+	readonly kind: "invoke" | "subscribe" | "unsubscribe";
+	readonly operation: string;
+	readonly payload?: Readonly<Record<string, unknown>>;
+	readonly subscriptionId?: string;
+}
+/**
+* One scripted subscription. Frames carry the sequence the kernel checks, so
+* `skip` is the one way to script a gap.
+*/
+interface ScriptedStream {
+	readonly id: string;
+	readonly operation: string;
+	/** `false` once the host ended it or the page closed it. */
+	readonly open: boolean;
+	emit(kind: StreamEventKind2, payload: unknown): void;
+	end(terminal: BridgeStreamTerminal): void;
+	/** Advance the sequence without sending, so the next frame is a gap. */
+	skip(frames: number): void;
+}
+/** Options for a subscribe expectation. */
+interface SubscribeOptions {
+	/** Delay the acknowledgement until this promise settles. */
+	readonly ack?: () => Promise<void>;
+}
+/**
+* A test's script went wrong: an unmet or unexpected call, a leaked
+* subscription, a handler that threw, or an envelope that is not protocol 1.
+*/
+declare class QgisSdkBridgeHarnessError extends QgisSdkError {
+	constructor(message: string);
+}
+/** The harness a test holds; also the transport its client is built on. */
+interface BridgeHarness<Op extends string = string> extends WireTransport {
+	/** Every message the client sent, in order. */
+	readonly calls: readonly RecordedCall[];
+	/** Calls no expectation covered; each was answered `unexpected_call`. */
+	readonly unexpected: readonly RecordedCall[];
+	/** Subscriptions neither ended by a script nor closed by the page. */
+	readonly openSubscriptions: readonly string[];
+	/** Clients currently attached. */
+	readonly listeners: number;
+	/** Answer the next `operation` call with what `handler` returns. */
+	expectInvoke<
+		Req extends object = Readonly<Record<string, unknown>>,
+		Res = unknown
+	>(operation: Op, handler: (payload: Req) => ScriptedReply<Res>): void;
+	/**
+	* Acknowledge the next `operation` subscription and hand `script` the
+	* stream; return a fault or {@link SILENCE} from it to refuse instead.
+	*/
+	expectSubscribe<Req extends object = Readonly<Record<string, unknown>>>(operation: Op, script: SubscribeScript<Req>, options?: SubscribeOptions): void;
+	/** Push any raw message, for what no expectation can script. */
+	deliver(raw: unknown): void;
+	/** Resolve once everything queued so far has been delivered. */
+	settled(): Promise<void>;
+	/** Throw unless every expectation was met and nothing leaked. */
+	assertSatisfied(): void;
+}
+/**
+* Create a harness; `Op` narrows the operations a test may expect, typically
+* the generated module's `OperationId`.
+*/
+declare function createBridgeHarness<Op extends string = string>(): BridgeHarness<Op>;
+export { BridgeHarness, QgisSdkBridgeHarnessError, RecordedCall, SILENCE, ScriptedFault, ScriptedRefusal, ScriptedReply, ScriptedStream, SubscribeOptions, SubscribeScript, createBridgeHarness, fault };