@archont561/qgis-sdk 0.5.0 → 0.6.0

package/dist/shared/chunk-xg5ntw1c.js

@@ -0,0 +1,414 @@
+import {
+  QgisSdkError2
+} from "./chunk-2hwva3a3.js";
+
+// src/internal.ts
+var STREAM_EVENT_KINDS = Object.freeze([
+  "data",
+  "progress",
+  "state"
+]);
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/bridge/errors.ts
+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 QgisSdkBridgeRemoteError2 extends QgisSdkError2 {
+  failure;
+  callId;
+  constructor(callId, failure) {
+    super(failure.message, failure.code);
+    this.callId = callId;
+    this.failure = failure;
+  }
+}
+
+// src/bridge/protocol.ts
+var BRIDGE_PROTOCOL_VERSION2 = 1;
+var MAX_CALL_ID_LENGTH2 = 128;
+
+// src/bridge/frames.ts
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function parseInvokeReply2(raw) {
+  if (!isPlainRecord(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 (!isPlainRecord(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 TERMINAL_KINDS = [
+  "cancelled",
+  "complete",
+  "disposed",
+  "error",
+  "gap"
+];
+function parseStreamFrame2(raw) {
+  if (!isPlainRecord(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 (!isPlainRecord(raw.event)) {
+      throw new QgisSdkBridgeProtocolError2(`${raw.subscription_id}: event must be an object`);
+    }
+    const kind = raw.event.kind;
+    if (!STREAM_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 (!isPlainRecord(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 } : {}
+    })
+  });
+}
+
+// src/bridge/client.ts
+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 = isPlainRecord(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;
+    });
+  }
+  handshake(options = {}) {
+    return this.send({ kind: "handshake" }, options);
+  }
+  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 (isPlainRecord(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 { STREAM_EVENT_KINDS, isPlainRecord, QgisSdkBridgeProtocolError2, QgisSdkBridgeTimeoutError2, QgisSdkBridgeAbortedError2, QgisSdkBridgeClosedError2, QgisSdkBridgeRemoteError2, BRIDGE_PROTOCOL_VERSION2, MAX_CALL_ID_LENGTH2, parseInvokeReply2, parseStreamFrame2, BridgeClient2 };
+
+//# debugId=21C326780896BE7D64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/internal.ts", "src/bridge/errors.ts", "src/bridge/protocol.ts", "src/bridge/frames.ts", "src/bridge/client.ts"],
  "sourcesContent": [
    "/**\n * Helpers the entry points share but the package does not export.\n *\n * Nothing here is part of the public surface: a page that needs a record guard\n * writes its own one-liner rather than depending on an SDK implementation\n * detail that may move.\n */\n\nimport type { StreamEventKind } from \"./declarations\";\n\n/** The declared stream event kinds; the declaration parser and the frame parser check the same list. */\nexport const STREAM_EVENT_KINDS: readonly StreamEventKind[] = Object.freeze([\n\t\"data\",\n\t\"progress\",\n\t\"state\",\n]);\n\n/**\n * Return whether `value` is a non-null, non-array object: the shape every wire\n * envelope, description and event payload must have before its fields are read.\n */\nexport function isPlainRecord(\n\tvalue: unknown,\n): value is Record<string, unknown> {\n\treturn typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n",
    "/** The bridge's errors: protocol, timeout, abort, closed and remote. */\n\nimport { QgisSdkError } from \"../errors\";\nimport type { BridgeFailure } from \"./protocol\";\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 * 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",
    "/** The wire shapes of the bridge protocol: replies, frames, transport and options. */\n\nimport type { StreamEventKind } from \"../declarations\";\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/** 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",
    "/** Parsing one invoke reply and one stream frame, refusing what the host could not send. */\n\nimport type { StreamEventKind } from \"../declarations\";\nimport { isPlainRecord, STREAM_EVENT_KINDS } from \"../internal\";\nimport { QgisSdkBridgeProtocolError } from \"./errors\";\nimport {\n\tBRIDGE_PROTOCOL_VERSION,\n\ttype BridgeStreamFrame,\n\ttype InvokeReply,\n\tMAX_CALL_ID_LENGTH,\n\ttype StreamTerminalKind,\n} from \"./protocol\";\n\nexport function 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 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 (!STREAM_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",
    "/** {@link BridgeClient}: invocations correlated with replies over an injected transport. */\n\nimport { isPlainRecord } from \"../internal\";\nimport {\n\tQgisSdkBridgeAbortedError,\n\tQgisSdkBridgeClosedError,\n\tQgisSdkBridgeProtocolError,\n\tQgisSdkBridgeRemoteError,\n\tQgisSdkBridgeTimeoutError,\n} from \"./errors\";\nimport { isNonEmptyString, parseInvokeReply, parseStreamFrame } from \"./frames\";\nimport {\n\tBRIDGE_PROTOCOL_VERSION,\n\ttype BridgeClientOptions,\n\ttype BridgeStreamEvent,\n\ttype BridgeStreamFrame,\n\ttype BridgeStreamTerminal,\n\ttype InvokeOptions,\n\ttype InvokeReply,\n\ttype WireTransport,\n} from \"./protocol\";\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/**\n\t * Ask the host for the handshake: the contract this view may use.\n\t *\n\t * The host bound the view before its first message, so this is a call, not\n\t * a binding. The value is what `Dispatcher.handshake` builds - protocol,\n\t * generation, the plugin description, the host schema version and the\n\t * operations this view is authorized for.\n\t */\n\tpublic handshake(options: InvokeOptions = {}): Promise<unknown> {\n\t\treturn this.send({ kind: \"handshake\" }, options);\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": ";;;;;AAWO,IAAM,qBAAiD,OAAO,OAAO;AAAA,EAC3E;AAAA,EACA;AAAA,EACA;AACD,CAAC;AAMM,SAAS,aAAa,CAC5B,OACmC;AAAA,EACnC,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAAA;;;AChBpE,MAAM,oCAAmC,cAAa;AAAA,EACrD,WAAW,CAAC,SAAiB;AAAA,IACnC,MAAM,SAAS,wBAAwB;AAAA;AAEzC;AAAA;AAMO,MAAM,mCAAkC,cAAa;AAAA,EAC3C;AAAA,EAET,WAAW,CAAC,QAAgB,WAAmB;AAAA,IACrD,MACC,QAAQ,KAAK,UAAU,MAAM,yBAAyB,+CACtD,SACD;AAAA,IACA,KAAK,SAAS;AAAA;AAEhB;AAAA;AAMO,MAAM,mCAAkC,cAAa;AAAA,EAC3C;AAAA,EAET,WAAW,CAAC,QAAgB;AAAA,IAClC,MAAM,QAAQ,KAAK,UAAU,MAAM,yBAAyB,SAAS;AAAA,IACrE,KAAK,SAAS;AAAA;AAEhB;AAAA;AAKO,MAAM,kCAAiC,cAAa;AAAA,EACnD,WAAW,GAAG;AAAA,IACpB,MAAM,gCAAgC,QAAQ;AAAA;AAEhD;AAAA;AAKO,MAAM,kCAAiC,cAAa;AAAA,EAC1C;AAAA,EACA;AAAA,EAET,WAAW,CAAC,QAAgB,SAAwB;AAAA,IAC1D,MAAM,QAAQ,SAAS,QAAQ,IAAI;AAAA,IACnC,KAAK,SAAS;AAAA,IACd,KAAK,UAAU;AAAA;AAEjB;;;AC5DO,IAAM,2BAA6B;AACnC,IAAM,sBAA6B;;;ACQnC,SAAS,gBAAgB,CAAC,OAAiC;AAAA,EACjE,OAAO,OAAO,UAAU,YAAY,MAAM,KAAK,EAAE,SAAS;AAAA;AAMpD,SAAS,iBAAgB,CAAC,KAA2B;AAAA,EAC3D,IAAI,CAAC,cAAc,GAAG,GAAG;AAAA,IACxB,MAAM,IAAI,4BAA2B,2BAA2B;AAAA,EACjE;AAAA,EACA,IAAI,IAAI,aAAa,0BAAyB;AAAA,IAC7C,MAAM,IAAI,4BACT,gCAAgC,OAAO,IAAI,QAAQ,yBAAyB,0BAC7E;AAAA,EACD;AAAA,EACA,IACC,CAAC,iBAAiB,IAAI,OAAO,KAC7B,IAAI,QAAQ,SAAS,qBACpB;AAAA,IACD,MAAM,IAAI,4BACT,gDAAgD,gCACjD;AAAA,EACD;AAAA,EACA,MAAM,SAAS,IAAI;AAAA,EACnB,IAAI,OAAO,IAAI,OAAO,WAAW;AAAA,IAChC,MAAM,IAAI,4BAA2B,GAAG,8BAA8B;AAAA,EACvE;AAAA,EACA,IAAI,IAAI,IAAI;AAAA,IACX,IAAI,CAAC,OAAO,OAAO,KAAK,OAAO,GAAG;AAAA,MACjC,MAAM,IAAI,4BACT,GAAG,4CACJ;AAAA,IACD;AAAA,IACA,OAAO,OAAO,OAAO;AAAA,MACpB,UAAU;AAAA,MACV,SAAS;AAAA,MACT,IAAI;AAAA,MACJ,OAAO,IAAI;AAAA,IACZ,CAAC;AAAA,EACF;AAAA,EACA,IAAI,CAAC,cAAc,IAAI,KAAK,GAAG;AAAA,IAC9B,MAAM,IAAI,4BACT,GAAG,oDACJ;AAAA,EACD;AAAA,EACA,IAAI,CAAC,iBAAiB,IAAI,MAAM,IAAI,GAAG;AAAA,IACtC,MAAM,IAAI,4BACT,GAAG,qCACJ;AAAA,EACD;AAAA,EACA,IAAI,OAAO,IAAI,MAAM,YAAY,UAAU;AAAA,IAC1C,MAAM,IAAI,4BACT,GAAG,wCACJ;AAAA,EACD;AAAA,EACA,OAAO,OAAO,OAAO;AAAA,IACpB,UAAU;AAAA,IACV,SAAS;AAAA,IACT,IAAI;AAAA,IACJ,OAAO,OAAO,OAAO;AAAA,MACpB,MAAM,IAAI,MAAM;AAAA,MAChB,SAAS,IAAI,MAAM;AAAA,IACpB,CAAC;AAAA,EACF,CAAC;AAAA;AAGF,SAAS,OAAO,CAAC,OAAiC;AAAA,EACjD,OAAO,OAAO,UAAU,YAAY,OAAO,cAAc,KAAK,KAAK,SAAS;AAAA;AAG7E,IAAM,iBAAgD;AAAA,EACrD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACD;AAUO,SAAS,iBAAgB,CAAC,KAAiC;AAAA,EACjE,IAAI,CAAC,cAAc,GAAG,GAAG;AAAA,IACxB,MAAM,IAAI,4BAA2B,kCAAkC;AAAA,EACxE;AAAA,EACA,IAAI,IAAI,aAAa,0BAAyB;AAAA,IAC7C,MAAM,IAAI,4BACT,gCAAgC,OAAO,IAAI,QAAQ,yBAAyB,0BAC7E;AAAA,EACD;AAAA,EACA,IAAI,CAAC,iBAAiB,IAAI,eAAe,GAAG;AAAA,IAC3C,MAAM,IAAI,4BACT,2CACD;AAAA,EACD;AAAA,EACA,IAAI,CAAC,QAAQ,IAAI,GAAG,GAAG;AAAA,IACtB,MAAM,IAAI,4BACT,GAAG,IAAI,qDACR;AAAA,EACD;AAAA,EACA,MAAM,WAAW,OAAO,OAAO,KAAK,OAAO;AAAA,EAC3C,MAAM,cAAc,OAAO,OAAO,KAAK,UAAU;AAAA,EACjD,IAAI,aAAa,aAAa;AAAA,IAC7B,MAAM,IAAI,4BACT,GAAG,IAAI,0EACR;AAAA,EACD;AAAA,EACA,IAAI,UAAU;AAAA,IACb,IAAI,CAAC,cAAc,IAAI,KAAK,GAAG;AAAA,MAC9B,MAAM,IAAI,4BACT,GAAG,IAAI,0CACR;AAAA,IACD;AAAA,IACA,MAAM,OAAO,IAAI,MAAM;AAAA,IACvB,IAAI,CAAC,mBAAmB,SAAS,IAAuB,GAAG;AAAA,MAC1D,MAAM,IAAI,4BACT,GAAG,IAAI,oBAAoB,OAAO,IAAI,wBACvC;AAAA,IACD;AAAA,IACA,OAAO,OAAO,OAAO;AAAA,MACpB,UAAU;AAAA,MACV,iBAAiB,IAAI;AAAA,MACrB,KAAK,IAAI;AAAA,MACT,OAAO,OAAO,OAAO;AAAA,QACpB;AAAA,QACA,SAAS,IAAI,MAAM;AAAA,MACpB,CAAC;AAAA,IACF,CAAC;AAAA,EACF;AAAA,EACA,IAAI,CAAC,cAAc,IAAI,QAAQ,GAAG;AAAA,IACjC,MAAM,IAAI,4BACT,GAAG,IAAI,6CACR;AAAA,EACD;AAAA,EACA,MAAM,OAAO,IAAI,SAAS;AAAA,EAC1B,IAAI,CAAC,eAAe,SAAS,IAA0B,GAAG;AAAA,IACzD,MAAM,IAAI,4BACT,GAAG,IAAI,oBAAoB,OAAO,IAAI,0BACvC;AAAA,EACD;AAAA,EACA,IACC,IAAI,SAAS,YAAY,aACzB,OAAO,IAAI,SAAS,YAAY,UAC/B;AAAA,IACD,MAAM,IAAI,4BACT,GAAG,IAAI,oDACR;AAAA,EACD;AAAA,EACA,IAAI,IAAI,SAAS,YAAY,aAAa,CAAC,QAAQ,IAAI,SAAS,OAAO,GAAG;AAAA,IACzE,MAAM,IAAI,4BACT,GAAG,IAAI,kEACR;AAAA,EACD;AAAA,EACA,OAAO,OAAO,OAAO;AAAA,IACpB,UAAU;AAAA,IACV,iBAAiB,IAAI;AAAA,IACrB,KAAK,IAAI;AAAA,IACT,UAAU,OAAO,OAAO;AAAA,MACvB;AAAA,SACI,OAAO,IAAI,SAAS,YAAY,WACjC,EAAE,SAAS,IAAI,SAAS,QAAQ,IAChC,CAAC;AAAA,SACA,QAAQ,IAAI,SAAS,OAAO,IAC7B,EAAE,SAAS,IAAI,SAAS,QAAQ,IAChC,CAAC;AAAA,IACL,CAAC;AAAA,EACF,CAAC;AAAA;;;AClIK,MAAM,cAAa;AAAA,EACR;AAAA,EACA;AAAA,EACA,UAAoC,IAAI;AAAA,EACxC,gBAA+C,IAAI;AAAA,EACnD,YAAyB,IAAI;AAAA,EAC7B;AAAA,EACT,UAAkB;AAAA,EAClB,SAAkB;AAAA,EAClB,YAAoB;AAAA,EACpB,SAAiB;AAAA,EACjB,oBAAkC;AAAA,EAEnC,WAAW,CACjB,WACA,UAA+B,CAAC,GAC/B;AAAA,IACD,KAAK,YAAY;AAAA,IACjB,KAAK,YAAY,QAAQ,aAAa;AAAA,IACtC,KAAK,cAAc,UAAU,UAAU,CAAC,YAAY;AAAA,MACnD,KAAK,OAAO,OAAO;AAAA,KACnB;AAAA;AAAA,MAIS,QAAQ,GAAY;AAAA,IAC9B,OAAO,KAAK;AAAA;AAAA,MAIF,gBAAgB,GAAW;AAAA,IACrC,OAAO,KAAK;AAAA;AAAA,MAIF,YAAY,GAAW;AAAA,IACjC,OAAO,KAAK,QAAQ;AAAA;AAAA,EAMd,MAAM,CACZ,WACA,UAA6C,CAAC,GAC9C,UAAyB,CAAC,GACP;AAAA,IACnB,IAAI,CAAC,iBAAiB,SAAS,GAAG;AAAA,MACjC,OAAO,QAAQ,OACd,IAAI,4BAA2B,qCAAqC,CACrE;AAAA,IACD;AAAA,IACA,OAAO,KAAK,KAAK,EAAE,MAAM,UAAU,WAAW,QAAQ,GAAG,OAAO;AAAA;AAAA,EAU1D,SAAS,CACf,WACA,UAA6C,CAAC,GAC9C,WAAiC,CAAC,GAClC,UAAyB,CAAC,GACI;AAAA,IAC9B,IAAI,CAAC,iBAAiB,SAAS,GAAG;AAAA,MACjC,OAAO,QAAQ,OACd,IAAI,4BAA2B,qCAAqC,CACrE;AAAA,IACD;AAAA,IACA,OAAO,KAAK,KAAK,EAAE,MAAM,aAAa,WAAW,QAAQ,GAAG,OAAO,EAAE,KACpE,CAAC,UAAU;AAAA,MACV,MAAM,KAAK,cAAc,KAAK,IAAI,MAAM,kBAAkB;AAAA,MAC1D,IAAI,CAAC,iBAAiB,EAAE,GAAG;AAAA,QAC1B,MAAM,IAAI,4BACT,6DACD;AAAA,MACD;AAAA,MACA,MAAM,OAAyB;AAAA,QAC9B;AAAA,QACA;AAAA,QACA,aAAa;AAAA,QACb,QAAQ;AAAA,MACT;AAAA,MACA,KAAK,cAAc,IAAI,IAAI,IAAI;AAAA,MAC/B,MAAM,SAA6B;AAAA,QAClC;AAAA,YACI,MAAM,GAAY;AAAA,UACrB,OAAO,KAAK;AAAA;AAAA,QAEb,OAAO,MAAY;AAAA,UAClB,KAAK,gBAAgB,IAAI,EAAE,MAAM,WAAW,GAAG,IAAI;AAAA;AAAA,MAErD;AAAA,MACA,OAAO;AAAA,KAET;AAAA;AAAA,EAWM,SAAS,CAAC,UAAyB,CAAC,GAAqB;AAAA,IAC/D,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,GAAG,OAAO;AAAA;AAAA,MAIrC,mBAAmB,GAAsB;AAAA,IACnD,OAAO,CAAC,GAAG,KAAK,cAAc,KAAK,CAAC;AAAA;AAAA,MAI1B,cAAc,GAAW;AAAA,IACnC,OAAO,KAAK;AAAA;AAAA,EAGL,IAAI,CACX,MACA,SACmB;AAAA,IACnB,IAAI,KAAK,QAAQ;AAAA,MAChB,OAAO,QAAQ,OAAO,IAAI,yBAA0B;AAAA,IACrD;AAAA,IACA,KAAK,WAAW;AAAA,IAChB,MAAM,SAAS,IAAI,KAAK;AAAA,IAExB,MAAM,UAAU,IAAI,QAAiB,CAAC,SAAS,WAAW;AAAA,MACzD,IAAI,QAAQ,QAAQ,YAAY,MAAM;AAAA,QACrC,OAAO,IAAI,2BAA0B,MAAM,CAAC;AAAA,QAC5C;AAAA,MACD;AAAA,MACA,MAAM,UAAU,MAAY;AAAA,QAC3B,MAAM,UAAU,KAAK,QAAQ,IAAI,MAAM;AAAA,QACvC,IAAI,YAAY,WAAW;AAAA,UAC1B;AAAA,QACD;AAAA,QACA,KAAK,OAAO,MAAM;AAAA,QAClB,QAAQ,OAAO,IAAI,2BAA0B,MAAM,CAAC;AAAA;AAAA,MAErD,QAAQ,QAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;AAAA,MAEjE,MAAM,QACL,KAAK,YAAY,IACd,WAAW,MAAM;AAAA,QACjB,MAAM,UAAU,KAAK,QAAQ,IAAI,MAAM;AAAA,QACvC,IAAI,YAAY,WAAW;AAAA,UAC1B;AAAA,QACD;AAAA,QACA,KAAK,OAAO,MAAM;AAAA,QAClB,QAAQ,OACP,IAAI,2BAA0B,QAAQ,KAAK,SAAS,CACrD;AAAA,SACE,KAAK,SAAS,IAChB;AAAA,MAEJ,MAAM,SACL,QAAQ,WAAW,YAChB,OACA,MAAY;AAAA,QACZ,QAAQ,QAAQ,oBAAoB,SAAS,OAAO;AAAA;AAAA,MAGxD,KAAK,QAAQ,IAAI,QAAQ,EAAE,SAAS,QAAQ,OAAO,OAAO,CAAC;AAAA,MAC3D,KAAK,UAAU,KAAK;AAAA,QACnB,UAAU;AAAA,QACV,SAAS;AAAA,WACN;AAAA,MACJ,CAAC;AAAA,KACD;AAAA,IAED,OAAO;AAAA;AAAA,EAMD,KAAK,GAAS;AAAA,IACpB,IAAI,KAAK,QAAQ;AAAA,MAChB;AAAA,IACD;AAAA,IACA,KAAK,SAAS;AAAA,IACd,KAAK,YAAY;AAAA,IACjB,WAAW,MAAM,CAAC,GAAG,KAAK,cAAc,KAAK,CAAC,GAAG;AAAA,MAChD,KAAK,gBAAgB,IAAI,EAAE,MAAM,WAAW,GAAG,KAAK;AAAA,IACrD;AAAA,IACA,WAAW,UAAU,CAAC,GAAG,KAAK,QAAQ,KAAK,CAAC,GAAG;AAAA,MAC9C,MAAM,UAAU,KAAK,QAAQ,IAAI,MAAM;AAAA,MACvC,IAAI,YAAY,WAAW;AAAA,QAC1B;AAAA,MACD;AAAA,MACA,KAAK,OAAO,MAAM;AAAA,MAClB,QAAQ,OAAO,IAAI,yBAA0B;AAAA,IAC9C;AAAA;AAAA,EAGO,MAAM,CAAC,QAAyC;AAAA,IACvD,MAAM,UAAU,KAAK,QAAQ,IAAI,MAAM;AAAA,IACvC,IAAI,YAAY,WAAW;AAAA,MAC1B;AAAA,IACD;AAAA,IACA,KAAK,QAAQ,OAAO,MAAM;AAAA,IAC1B,IAAI,QAAQ,UAAU,MAAM;AAAA,MAC3B,aAAa,QAAQ,KAAK;AAAA,IAC3B;AAAA,IACA,QAAQ,SAAS;AAAA,IACjB,OAAO;AAAA;AAAA,EAGA,MAAM,CAAC,SAAwB;AAAA,IACtC,IAAI,cAAc,OAAO,KAAK,OAAO,OAAO,SAAS,iBAAiB,GAAG;AAAA,MACxE,KAAK,YAAY,OAAO;AAAA,MACxB;AAAA,IACD;AAAA,IACA,IAAI;AAAA,IACJ,IAAI;AAAA,MACH,QAAQ,kBAAiB,OAAO;AAAA,MAC/B,OAAO,OAAO;AAAA,MAIf,KAAK,aAAa;AAAA,MAClB,IAAI,iBAAiB,OAAO;AAAA,QAC3B,KAAK,oBAAoB;AAAA,MAC1B;AAAA,MACA;AAAA;AAAA,IAED,IAAI,KAAK,UAAU,OAAO,MAAM,OAAO,GAAG;AAAA,MACzC;AAAA,IACD;AAAA,IACA,MAAM,UAAU,KAAK,OAAO,MAAM,OAAO;AAAA,IACzC,IAAI,YAAY,WAAW;AAAA,MAC1B,KAAK,aAAa;AAAA,MAClB;AAAA,IACD;AAAA,IACA,IAAI,MAAM,IAAI;AAAA,MACb,QAAQ,QAAQ,MAAM,KAAK;AAAA,MAC3B;AAAA,IACD;AAAA,IACA,QAAQ,OAAO,IAAI,0BAAyB,MAAM,SAAS,MAAM,KAAK,CAAC;AAAA;AAAA,EAGhE,WAAW,CAAC,KAAoB;AAAA,IACvC,IAAI;AAAA,IACJ,IAAI;AAAA,MACH,QAAQ,kBAAiB,GAAG;AAAA,MAC3B,OAAO,OAAO;AAAA,MAGf,KAAK,aAAa;AAAA,MAClB,IAAI,iBAAiB,OAAO;AAAA,QAC3B,KAAK,oBAAoB;AAAA,MAC1B;AAAA,MACA;AAAA;AAAA,IAED,MAAM,OAAO,KAAK,cAAc,IAAI,MAAM,eAAe;AAAA,IACzD,IAAI,SAAS,WAAW;AAAA,MACvB,KAAK,aAAa;AAAA,MAClB;AAAA,IACD;AAAA,IACA,IAAI,MAAM,QAAQ,KAAK,aAAa;AAAA,MACnC,KAAK,UAAU;AAAA,MACf,MAAM,WAAW,KAAK;AAAA,MACtB,KAAK,gBACJ,MAAM,iBACN;AAAA,QACC,MAAM;AAAA,QACN,SAAS,kBAAkB,yBAAyB,MAAM;AAAA,QAC1D,SAAS,KAAK,IAAI,GAAG,MAAM,MAAM,QAAQ;AAAA,MAC1C,GACA,IACD;AAAA,MACA;AAAA,IACD;AAAA,IACA,KAAK,eAAe;AAAA,IACpB,IAAI,cAAc,OAAO;AAAA,MACxB,KAAK,gBAAgB,MAAM,iBAAiB,MAAM,UAAU,KAAK;AAAA,MACjE;AAAA,IACD;AAAA,IACA,KAAK,SAAS,UAAU,MAAM,KAAK;AAAA;AAAA,EAG5B,eAAe,CACtB,IACA,UACA,YACO;AAAA,IACP,MAAM,OAAO,KAAK,cAAc,IAAI,EAAE;AAAA,IACtC,IAAI,SAAS,aAAa,KAAK,QAAQ;AAAA,MACtC;AAAA,IACD;AAAA,IACA,KAAK,SAAS;AAAA,IACd,KAAK,cAAc,OAAO,EAAE;AAAA,IAC5B,IAAI,YAAY;AAAA,MACf,KAAK,oBAAoB,EAAE;AAAA,IAC5B;AAAA,IACA,KAAK,SAAS,aAAa,QAAQ;AAAA;AAAA,EAG5B,mBAAmB,CAAC,IAAkB;AAAA,IAC7C,IAAI,KAAK,QAAQ;AAAA,MAChB;AAAA,IACD;AAAA,IACA,KAAK,WAAW;AAAA,IAChB,MAAM,SAAS,IAAI,KAAK;AAAA,IACxB,KAAK,UAAU,IAAI,MAAM;AAAA,IACzB,KAAK,UAAU,KAAK;AAAA,MACnB,UAAU;AAAA,MACV,SAAS;AAAA,MACT,MAAM;AAAA,MACN,iBAAiB;AAAA,IAClB,CAAC;AAAA;AAAA,MAIS,aAAa,GAAiB;AAAA,IACxC,OAAO,KAAK;AAAA;AAEd;",
  "debugId": "21C326780896BE7D64756E2164756E21",
  "names": []
}

package/dist/svelte.d.ts

@@ -1,7 +1,7 @@
-import "./shared/chunk-wtv4vt4q.js";
+import "./shared/chunk-8c12nwme.js";
 import "./shared/chunk-7tgzmz0m.js";
-import { OperationMap2, StreamMap2, QgisSdkCore2, QgisSdk2 } from "./shared/chunk-a33y575v.js";
-import { Store2, OperationState2, Operation2, OperationStore2, StreamTerminalLike2, StreamHandleLike2, StreamHandlersLike2, Stream2, StreamState2, StreamStore2, FormOptions2, FormStore2, HostQueryStore2 } from "./shared/chunk-3zscfm3y.js";
+import { OperationMap2, StreamMap2, QgisSdkCore2, QgisSdk2 } from "./shared/chunk-nwz8n14x.js";
+import { Store2, OperationState2, Operation2, OperationStore2, FormOptions2, FormStore2, HostQueryStore2, StreamTerminalLike2, StreamHandleLike2, StreamHandlersLike2, Stream2, StreamState2, StreamStore2 } from "./shared/chunk-b11znjn6.js";
 import { QgisSdkError2 } from "./shared/chunk-pdj2fxjb.js";
 /** A helper was used outside the shape it needs. */
 declare class QgisSdkBridgeSvelteError extends QgisSdkError2 {

package/dist/svelte.js

@@ -1,9 +1,9 @@
-import"./shared/chunk-8gawbn19.js";
+import"./shared/chunk-xg5ntw1c.js";
 import {
   OperationStore2,
-  StreamStore2,
-  FormStore2
-} from "./shared/chunk-t1vpt5yq.js";
+  FormStore2,
+  StreamStore2
+} from "./shared/chunk-72sjmz60.js";
 import {
   QgisSdkError2
 } from "./shared/chunk-2hwva3a3.js";
@@ -66,5 +66,5 @@ export {
   toRune
 };
 
-//# debugId=A88CE88B3B7681A364756E2164756E21
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/svelte.ts"],
  "sourcesContent": [
    "/**\n * Thin Svelte 5 bindings over the store core (decision-47).\n *\n * This entry point is optional and is the only one that imports Svelte. The\n * stores in `./stores` already satisfy Svelte's store contract - `subscribe`\n * calls at once and on every change and returns the unsubscriber - so a\n * component writes `$state` over any of them with no wrapper. What this\n * module adds is the little Svelte asks for around that:\n *\n * - `setQgisSdk`/`getQgisSdk`, one `QgisSdk` through component context;\n * - factories that tie a store's lifetime to the component that made it\n *   (`onDestroy` aborts a call, closes a stream, disposes a form), which a\n *   bare `new OperationStore(...)` in a `<script>` would not;\n * - `toRune`, a `$state`-friendly `{ current }` over any store, through\n *   `fromStore` of `svelte/store`, for a component that prefers runes.\n */\n\nimport { getContext, onDestroy, setContext } from \"svelte\";\nimport { fromStore } from \"svelte/store\";\nimport { QgisSdkError } from \"./errors\";\nimport type { QgisSdk, QgisSdkCore } from \"./qgis-sdk\";\nimport type { OperationMap, StreamMap } from \"./schema\";\nimport {\n\ttype FormOptions,\n\tFormStore,\n\ttype HostQueryStore,\n\ttype Operation,\n\tOperationStore,\n\ttype Store,\n\ttype Stream,\n\ttype StreamHandlersLike,\n\tStreamStore,\n} from \"./stores\";\n\nexport type {\n\tOperation,\n\tOperationState,\n\tStream,\n\tStreamHandleLike,\n\tStreamHandlersLike,\n\tStreamState,\n\tStreamTerminalLike,\n} from \"./stores\";\n\n/** A helper was used outside the shape it needs. */\nexport class QgisSdkBridgeSvelteError extends QgisSdkError {\n\tpublic constructor(message: string) {\n\t\tsuper(message, \"svelte_binding\");\n\t}\n}\n\n/** The context key `setQgisSdk` writes and `getQgisSdk` reads. */\nexport const QGIS_SDK_CONTEXT: unique symbol = Symbol(\"qgis-sdk\");\n\n/**\n * Share a `QgisSdk` with the component subtree; call during component\n * initialisation. The SDK is shared as given and never closed here.\n */\nexport function setQgisSdk<T extends QgisSdkCore<unknown, unknown>>(\n\tqgis: T,\n): T {\n\tsetContext(QGIS_SDK_CONTEXT, qgis);\n\treturn qgis;\n}\n\n/**\n * The `QgisSdk` the nearest `setQgisSdk` shared.\n *\n * The type parameters name the generated `Operations` and `Streams`; they are\n * the caller's claim, the same way the ancestor's argument was the page's.\n */\nexport function getQgisSdk<O = OperationMap, S = StreamMap>(): QgisSdk<O, S> {\n\tconst qgis = getContext<QgisSdkCore<unknown, unknown> | undefined>(\n\t\tQGIS_SDK_CONTEXT,\n\t);\n\tif (qgis === undefined) {\n\t\tthrow new QgisSdkBridgeSvelteError(\n\t\t\t\"getQgisSdk needs setQgisSdk in an ancestor component\",\n\t\t);\n\t}\n\treturn qgis as unknown as QgisSdk<O, S>;\n}\n\n/**\n * An operation store whose in-flight call is aborted when the component is\n * destroyed; read it as `$op` or pass it to {@link toRune}.\n */\nexport function operation<I, R>(\n\toperation: Operation<I, R>,\n): OperationStore<I, R> {\n\tconst store = new OperationStore(operation);\n\tonDestroy(store.abort);\n\treturn store;\n}\n\n/**\n * A stream store closed when the component is destroyed. Pass the input now\n * or later with `store.setInput(...)`; `$effect(() => store.setInput(input))`\n * follows a reactive one, by content.\n */\nexport function stream<I, E>(\n\topen: Stream<I, E>,\n\tinput: I | null = null,\n\thandlers: StreamHandlersLike<E> = {},\n): StreamStore<I, E> {\n\tconst store = new StreamStore(open, handlers);\n\tstore.setInput(input);\n\tonDestroy(store.close);\n\treturn store;\n}\n\ntype RequestOf<O, K extends keyof O> = O[K] extends {\n\treadonly request: infer Req;\n}\n\t? Req\n\t: never;\ntype ResultOf<O, K extends keyof O> = O[K] extends {\n\treadonly result: infer Res;\n}\n\t? Res\n\t: never;\n\n/**\n * The form of one declared action, disposed with the component: render\n * `form.fields`, bind `$form.values`, call `form.submit()`.\n */\nexport function form<O, K extends keyof O & string>(\n\tqgis: QgisSdkCore<O, unknown>,\n\tid: K,\n\toptions?: FormOptions,\n): FormStore<RequestOf<O, K> & object, ResultOf<O, K>> {\n\tconst store = new FormStore<RequestOf<O, K> & object, ResultOf<O, K>>(\n\t\tqgis as QgisSdkCore<unknown, unknown>,\n\t\tid,\n\t\toptions,\n\t);\n\tonDestroy(() => store.dispose());\n\treturn store;\n}\n\n/**\n * A host query store refreshed now (unless `auto` is `false`) and aborted\n * when the component is destroyed: `hostQuery(layersQuery(qgis))`.\n */\nexport function hostQuery<T>(\n\tstore: HostQueryStore<T>,\n\toptions: { readonly auto?: boolean } = {},\n): HostQueryStore<T> {\n\tif (options.auto !== false) {\n\t\tvoid store.refresh();\n\t}\n\tonDestroy(store.abort);\n\treturn store;\n}\n\n/** A runes-friendly view of any store: `const op = toRune(store); op.current`. */\nexport function toRune<T>(store: Store<T>): { readonly current: T } {\n\treturn fromStore(store);\n}\n"
  ],
  "mappings": ";;;;;;;;;;;AAiBA;AACA;AA2BO,MAAM,iCAAiC,cAAa;AAAA,EACnD,WAAW,CAAC,SAAiB;AAAA,IACnC,MAAM,SAAS,gBAAgB;AAAA;AAEjC;AAGO,IAAM,mBAAkC,OAAO,UAAU;AAMzD,SAAS,UAAmD,CAClE,MACI;AAAA,EACJ,WAAW,kBAAkB,IAAI;AAAA,EACjC,OAAO;AAAA;AASD,SAAS,UAA2C,GAAkB;AAAA,EAC5E,MAAM,OAAO,WACZ,gBACD;AAAA,EACA,IAAI,SAAS,WAAW;AAAA,IACvB,MAAM,IAAI,yBACT,sDACD;AAAA,EACD;AAAA,EACA,OAAO;AAAA;AAOD,SAAS,SAAe,CAC9B,WACuB;AAAA,EACvB,MAAM,QAAQ,IAAI,gBAAe,SAAS;AAAA,EAC1C,UAAU,MAAM,KAAK;AAAA,EACrB,OAAO;AAAA;AAQD,SAAS,MAAY,CAC3B,MACA,QAAkB,MAClB,WAAkC,CAAC,GACf;AAAA,EACpB,MAAM,QAAQ,IAAI,aAAY,MAAM,QAAQ;AAAA,EAC5C,MAAM,SAAS,KAAK;AAAA,EACpB,UAAU,MAAM,KAAK;AAAA,EACrB,OAAO;AAAA;AAkBD,SAAS,IAAmC,CAClD,MACA,IACA,SACsD;AAAA,EACtD,MAAM,QAAQ,IAAI,WACjB,MACA,IACA,OACD;AAAA,EACA,UAAU,MAAM,MAAM,QAAQ,CAAC;AAAA,EAC/B,OAAO;AAAA;AAOD,SAAS,SAAY,CAC3B,OACA,UAAuC,CAAC,GACpB;AAAA,EACpB,IAAI,QAAQ,SAAS,OAAO;AAAA,IACtB,MAAM,QAAQ;AAAA,EACpB;AAAA,EACA,UAAU,MAAM,KAAK;AAAA,EACrB,OAAO;AAAA;AAID,SAAS,MAAS,CAAC,OAA0C;AAAA,EACnE,OAAO,UAAU,KAAK;AAAA;",
  "debugId": "A88CE88B3B7681A364756E2164756E21",
  "names": []
}
+//# debugId=40BDC6B527490EFB64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/svelte.ts"],
  "sourcesContent": [
    "/**\n * Thin Svelte 5 bindings over the store core (decision-47).\n *\n * This entry point is optional and is the only one that imports Svelte. The\n * stores in `./stores` already satisfy Svelte's store contract - `subscribe`\n * calls at once and on every change and returns the unsubscriber - so a\n * component writes `$state` over any of them with no wrapper. What this\n * module adds is the little Svelte asks for around that:\n *\n * - `setQgisSdk`/`getQgisSdk`, one `QgisSdk` through component context;\n * - factories that tie a store's lifetime to the component that made it\n *   (`onDestroy` aborts a call, closes a stream, disposes a form), which a\n *   bare `new OperationStore(...)` in a `<script>` would not;\n * - `toRune`, a `$state`-friendly `{ current }` over any store, through\n *   `fromStore` of `svelte/store`, for a component that prefers runes.\n */\n\nimport { getContext, onDestroy, setContext } from \"svelte\";\nimport { fromStore } from \"svelte/store\";\nimport { QgisSdkError } from \"./errors\";\nimport type { QgisSdk, QgisSdkCore } from \"./qgis-sdk\";\nimport type { OperationMap, StreamMap } from \"./schema\";\nimport {\n\ttype FormOptions,\n\tFormStore,\n\ttype HostQueryStore,\n\ttype Operation,\n\tOperationStore,\n\ttype Store,\n\ttype Stream,\n\ttype StreamHandlersLike,\n\tStreamStore,\n} from \"./stores\";\n\nexport type {\n\tOperation,\n\tOperationState,\n\tStream,\n\tStreamHandleLike,\n\tStreamHandlersLike,\n\tStreamState,\n\tStreamTerminalLike,\n} from \"./stores\";\n\n/** A helper was used outside the shape it needs. */\nexport class QgisSdkBridgeSvelteError extends QgisSdkError {\n\tpublic constructor(message: string) {\n\t\tsuper(message, \"svelte_binding\");\n\t}\n}\n\n/** The context key `setQgisSdk` writes and `getQgisSdk` reads. */\nexport const QGIS_SDK_CONTEXT: unique symbol = Symbol(\"qgis-sdk\");\n\n/**\n * Share a `QgisSdk` with the component subtree; call during component\n * initialisation. The SDK is shared as given and never closed here.\n */\nexport function setQgisSdk<T extends QgisSdkCore<unknown, unknown>>(\n\tqgis: T,\n): T {\n\tsetContext(QGIS_SDK_CONTEXT, qgis);\n\treturn qgis;\n}\n\n/**\n * The `QgisSdk` the nearest `setQgisSdk` shared.\n *\n * The type parameters name the generated `Operations` and `Streams`; they are\n * the caller's claim, the same way the ancestor's argument was the page's.\n */\nexport function getQgisSdk<O = OperationMap, S = StreamMap>(): QgisSdk<O, S> {\n\tconst qgis = getContext<QgisSdkCore<unknown, unknown> | undefined>(\n\t\tQGIS_SDK_CONTEXT,\n\t);\n\tif (qgis === undefined) {\n\t\tthrow new QgisSdkBridgeSvelteError(\n\t\t\t\"getQgisSdk needs setQgisSdk in an ancestor component\",\n\t\t);\n\t}\n\treturn qgis as unknown as QgisSdk<O, S>;\n}\n\n/**\n * An operation store whose in-flight call is aborted when the component is\n * destroyed; read it as `$op` or pass it to {@link toRune}.\n */\nexport function operation<I, R>(\n\toperation: Operation<I, R>,\n): OperationStore<I, R> {\n\tconst store = new OperationStore(operation);\n\tonDestroy(store.abort);\n\treturn store;\n}\n\n/**\n * A stream store closed when the component is destroyed. Pass the input now\n * or later with `store.setInput(...)`; `$effect(() => store.setInput(input))`\n * follows a reactive one, by content.\n */\nexport function stream<I, E>(\n\topen: Stream<I, E>,\n\tinput: I | null = null,\n\thandlers: StreamHandlersLike<E> = {},\n): StreamStore<I, E> {\n\tconst store = new StreamStore(open, handlers);\n\tstore.setInput(input);\n\tonDestroy(store.close);\n\treturn store;\n}\n\ntype RequestOf<O, K extends keyof O> = O[K] extends {\n\treadonly request: infer Req;\n}\n\t? Req\n\t: never;\ntype ResultOf<O, K extends keyof O> = O[K] extends {\n\treadonly result: infer Res;\n}\n\t? Res\n\t: never;\n\n/**\n * The form of one declared action, disposed with the component: render\n * `form.fields`, bind `$form.values`, call `form.submit()`.\n */\nexport function form<O, K extends keyof O & string>(\n\tqgis: QgisSdkCore<O, unknown>,\n\tid: K,\n\toptions?: FormOptions,\n): FormStore<RequestOf<O, K> & object, ResultOf<O, K>> {\n\tconst store = new FormStore<RequestOf<O, K> & object, ResultOf<O, K>>(\n\t\tqgis as QgisSdkCore<unknown, unknown>,\n\t\tid,\n\t\toptions,\n\t);\n\tonDestroy(() => store.dispose());\n\treturn store;\n}\n\n/**\n * A host query store refreshed now (unless `auto` is `false`) and aborted\n * when the component is destroyed: `hostQuery(layersQuery(qgis))`.\n */\nexport function hostQuery<T>(\n\tstore: HostQueryStore<T>,\n\toptions: { readonly auto?: boolean } = {},\n): HostQueryStore<T> {\n\tif (options.auto !== false) {\n\t\tvoid store.refresh();\n\t}\n\tonDestroy(store.abort);\n\treturn store;\n}\n\n/** A runes-friendly view of any store: `const op = toRune(store); op.current`. */\nexport function toRune<T>(store: Store<T>): { readonly current: T } {\n\treturn fromStore(store);\n}\n"
  ],
  "mappings": ";;;;;;;;;;;AAiBA;AACA;AA2BO,MAAM,iCAAiC,cAAa;AAAA,EACnD,WAAW,CAAC,SAAiB;AAAA,IACnC,MAAM,SAAS,gBAAgB;AAAA;AAEjC;AAGO,IAAM,mBAAkC,OAAO,UAAU;AAMzD,SAAS,UAAmD,CAClE,MACI;AAAA,EACJ,WAAW,kBAAkB,IAAI;AAAA,EACjC,OAAO;AAAA;AASD,SAAS,UAA2C,GAAkB;AAAA,EAC5E,MAAM,OAAO,WACZ,gBACD;AAAA,EACA,IAAI,SAAS,WAAW;AAAA,IACvB,MAAM,IAAI,yBACT,sDACD;AAAA,EACD;AAAA,EACA,OAAO;AAAA;AAOD,SAAS,SAAe,CAC9B,WACuB;AAAA,EACvB,MAAM,QAAQ,IAAI,gBAAe,SAAS;AAAA,EAC1C,UAAU,MAAM,KAAK;AAAA,EACrB,OAAO;AAAA;AAQD,SAAS,MAAY,CAC3B,MACA,QAAkB,MAClB,WAAkC,CAAC,GACf;AAAA,EACpB,MAAM,QAAQ,IAAI,aAAY,MAAM,QAAQ;AAAA,EAC5C,MAAM,SAAS,KAAK;AAAA,EACpB,UAAU,MAAM,KAAK;AAAA,EACrB,OAAO;AAAA;AAkBD,SAAS,IAAmC,CAClD,MACA,IACA,SACsD;AAAA,EACtD,MAAM,QAAQ,IAAI,WACjB,MACA,IACA,OACD;AAAA,EACA,UAAU,MAAM,MAAM,QAAQ,CAAC;AAAA,EAC/B,OAAO;AAAA;AAOD,SAAS,SAAY,CAC3B,OACA,UAAuC,CAAC,GACpB;AAAA,EACpB,IAAI,QAAQ,SAAS,OAAO;AAAA,IACtB,MAAM,QAAQ;AAAA,EACpB;AAAA,EACA,UAAU,MAAM,KAAK;AAAA,EACrB,OAAO;AAAA;AAID,SAAS,MAAS,CAAC,OAA0C;AAAA,EACnE,OAAO,UAAU,KAAK;AAAA;",
  "debugId": "40BDC6B527490EFB64756E2164756E21",
  "names": []
}

package/dist/testing.d.ts

@@ -1,6 +1,6 @@
-import { StreamEventKind2, BridgeStreamTerminal2, WireTransport2 } from "./shared/chunk-wtv4vt4q.js";
+import { StreamEventKind2, BridgeStreamTerminal2, WireTransport2 } from "./shared/chunk-8c12nwme.js";
 import { HostOperationId2 } from "./shared/chunk-7tgzmz0m.js";
-import { OperationShape2, StreamShape2, BridgeSchema2, QgisSdkHostTheme2 } from "./shared/chunk-a33y575v.js";
+import { OperationShape2, StreamShape2, BridgeSchema2, QgisSdkHostTheme2 } from "./shared/chunk-nwz8n14x.js";
 import { QgisSdkError2 } from "./shared/chunk-pdj2fxjb.js";
 /** A scripted host failure, returned from an expectation's handler. */
 interface ScriptedFault {

package/dist/vue.d.ts

@@ -1,7 +1,7 @@
-import "./shared/chunk-wtv4vt4q.js";
+import "./shared/chunk-8c12nwme.js";
 import "./shared/chunk-7tgzmz0m.js";
-import { OperationMap2, StreamMap2, QgisSdkCore2, QgisSdk2 } from "./shared/chunk-a33y575v.js";
-import { Store2, OperationState2, Operation2, OperationStore2, StreamTerminalLike2, StreamHandleLike2, StreamHandlersLike2, Stream2, StreamState2, StreamStore2, FormState2, FormOptions2, FormStore2, HostQueryState2, HostQueryStore2 } from "./shared/chunk-3zscfm3y.js";
+import { OperationMap2, StreamMap2, QgisSdkCore2, QgisSdk2 } from "./shared/chunk-nwz8n14x.js";
+import { Store2, OperationState2, Operation2, OperationStore2, FormState2, FormOptions2, FormStore2, HostQueryState2, HostQueryStore2, StreamTerminalLike2, StreamHandleLike2, StreamHandlersLike2, Stream2, StreamState2, StreamStore2 } from "./shared/chunk-b11znjn6.js";
 import { QgisSdkError2 } from "./shared/chunk-pdj2fxjb.js";
 import { InjectionKey, MaybeRefOrGetter, ShallowRef } from "vue";
 /** A composable was used outside the shape it needs. */