@archont561/qgis-sdk 0.3.0 → 0.5.0

package/dist/shared/chunk-wtv4vt4q.d.ts

@@ -0,0 +1,280 @@
+import { QgisSdkError2 } from "./chunk-pdj2fxjb.js";
+declare const MAX_SAFE_INTEGER2: number;
+declare const MIN_SAFE_INTEGER2: number;
+declare const PLUGIN_DESCRIPTION_SCHEMA_VERSION2: 1;
+type ValidationDirection2 = "request" | "result";
+interface SerializedValidationIssue2 {
+	readonly path: (string | number)[];
+	readonly code: string;
+}
+interface SerializedContractValidationError2 {
+	readonly code: string;
+	readonly direction: ValidationDirection2;
+	readonly issues: SerializedValidationIssue2[];
+}
+interface ActionDescription2 {
+	readonly id: string;
+	readonly title: string;
+	readonly handler: string;
+	readonly request: Readonly<Record<string, unknown>>;
+	readonly result: Readonly<Record<string, unknown>>;
+}
+/** The event kinds a stream may declare; the frame carries the same three. */
+type StreamEventKind2 = "data" | "progress" | "state";
+/**
+* A declared stream (decision-28): a request in, one payload schema per
+* declared event kind out. There is no `result`: the reply to a subscription is
+* the protocol's acknowledgement, not something an author declares.
+*/
+interface StreamDescription2 {
+	readonly id: string;
+	readonly title: string;
+	readonly handler: string;
+	readonly request: Readonly<Record<string, unknown>>;
+	readonly events: Readonly<Partial<Record<StreamEventKind2, Readonly<Record<string, unknown>>>>>;
+}
+interface PluginDescription2 {
+	readonly schema_version: 1;
+	readonly id: string;
+	readonly title: string;
+	readonly actions: readonly ActionDescription2[];
+	/** Declared streams; a description from a host that predates them is empty. */
+	readonly streams: readonly StreamDescription2[];
+}
+/**
+* Return whether `value` is a finite integer within the JavaScript-safe wire range.
+*/
+declare function isSafeJsonInteger2(value: unknown): value is number;
+/**
+* A declaration cannot be represented or parsed in the versioned contract.
+*/
+declare class QgisSdkDeclarationError2 extends QgisSdkError2 {
+	constructor(message: string);
+}
+/**
+* Safe, structured location and category for a rejected contract value.
+*/
+declare class QgisSdkValidationIssue2 {
+	readonly path: readonly (string | number)[];
+	readonly code: string;
+	constructor(path: readonly (string | number)[], code: string);
+	toJSON(): SerializedValidationIssue2;
+}
+/**
+* A request or result did not satisfy its declared wire contract.
+*/
+declare class QgisSdkContractValidationError2 extends QgisSdkError2 {
+	readonly direction: ValidationDirection2;
+	readonly issues: readonly QgisSdkValidationIssue2[];
+	constructor(direction: ValidationDirection2, issues: readonly QgisSdkValidationIssue2[]);
+	toJSON(): SerializedContractValidationError2;
+}
+/**
+* Parse and validate a version 1 `PluginDescription` emitted by `describe_plugin`.
+*/
+declare function parsePluginDescription2(input: string | Readonly<Record<string, unknown>>): PluginDescription2;
+declare const BRIDGE_PROTOCOL_VERSION2: 1;
+declare const MAX_CALL_ID_LENGTH2: number;
+/** A failure reply, as the host serialized it. */
+interface BridgeFailure2 {
+	readonly code: string;
+	readonly message: string;
+}
+/** A reply to one invocation: exactly one of `value` or `error` is present. */
+type InvokeReply2 = {
+	readonly protocol: 1;
+	readonly call_id: string;
+	readonly ok: true;
+	readonly value: unknown;
+} | {
+	readonly protocol: 1;
+	readonly call_id: string;
+	readonly ok: false;
+	readonly error: BridgeFailure2;
+};
+/** Why a subscription stopped. */
+type StreamTerminalKind2 = "complete" | "error" | "cancelled" | "gap" | "disposed";
+/** One event on a subscription. */
+interface BridgeStreamEvent2 {
+	readonly kind: StreamEventKind2;
+	readonly payload: unknown;
+}
+/** The end of a subscription, as the host described it. */
+interface BridgeStreamTerminal2 {
+	readonly kind: StreamTerminalKind2;
+	readonly message?: string;
+	readonly dropped?: number;
+}
+/** A frame carrying one event. */
+interface BridgeEventFrame2 {
+	readonly protocol: 1;
+	readonly subscription_id: string;
+	readonly seq: number;
+	readonly event: BridgeStreamEvent2;
+}
+/** The frame that ends a subscription. */
+interface BridgeTerminalFrame2 {
+	readonly protocol: 1;
+	readonly subscription_id: string;
+	readonly seq: number;
+	readonly terminal: BridgeStreamTerminal2;
+}
+/** Anything the host may send for a subscription. */
+type BridgeStreamFrame2 = BridgeEventFrame2 | BridgeTerminalFrame2;
+/** The transport a client speaks through; a QWebChannel adapter or a script. */
+interface WireTransport2 {
+	send(message: unknown): void;
+	subscribe(listener: (message: unknown) => void): () => void;
+}
+/** Options for {@link BridgeClient}. */
+interface BridgeClientOptions2 {
+	readonly timeoutMs?: number;
+}
+/** Options for one invocation. */
+interface InvokeOptions2 {
+	readonly signal?: AbortSignal;
+}
+/**
+* An envelope or reply does not match the versioned bridge protocol.
+*/
+declare class QgisSdkBridgeProtocolError2 extends QgisSdkError2 {
+	constructor(message: string);
+}
+/**
+* The host did not answer in time. The call may still have run, so this is an
+* unknown outcome: retrying automatically is forbidden, deciding is the caller's.
+*/
+declare class QgisSdkBridgeTimeoutError2 extends QgisSdkError2 {
+	readonly callId: string;
+	constructor(callId: string, timeoutMs: number);
+}
+/**
+* The caller aborted locally. Distinct from the host cancelling the operation,
+* which arrives as a failure reply carrying the `cancelled` code.
+*/
+declare class QgisSdkBridgeAbortedError2 extends QgisSdkError2 {
+	readonly callId: string;
+	constructor(callId: string);
+}
+/**
+* The client was closed, so pending calls can no longer be answered.
+*/
+declare class QgisSdkBridgeClosedError2 extends QgisSdkError2 {
+	constructor();
+}
+/**
+* A subscription's frames were not the sequence the host promised.
+*
+* The client does not try to reassemble: a missed frame is a fact about the
+* subscription, not something to paper over.
+*/
+declare class QgisSdkBridgeSequenceError2 extends QgisSdkError2 {
+	readonly subscriptionId: string;
+	readonly expected: number;
+	readonly received: number;
+	constructor(subscriptionId: string, expected: number, received: number);
+}
+/**
+* The subscription ended with a terminal frame the caller may want to inspect.
+*/
+declare class QgisSdkBridgeStreamEndedError2 extends QgisSdkError2 {
+	readonly subscriptionId: string;
+	readonly terminal: BridgeStreamTerminal2;
+	constructor(subscriptionId: string, terminal: BridgeStreamTerminal2);
+}
+/**
+* The host refused or failed the operation; `failure.code` is the contract.
+*/
+declare class QgisSdkBridgeRemoteError2 extends QgisSdkError2 {
+	readonly failure: BridgeFailure2;
+	readonly callId: string;
+	constructor(callId: string, failure: BridgeFailure2);
+}
+/**
+* Parse one reply, refusing anything the host could not legitimately have sent.
+*/
+declare function parseInvokeReply2(raw: unknown): InvokeReply2;
+/**
+* Parse one stream frame, refusing anything the host could not legitimately
+* have sent.
+*
+* Exactly one of `event` and `terminal` has to be present: a frame that carries
+* both leaves the client guessing which one wins, and a client that guesses is
+* a client that will eventually deliver an event after the end of a stream.
+*/
+declare function parseStreamFrame2(raw: unknown): BridgeStreamFrame2;
+/** Callbacks a subscription reports through. */
+interface SubscriptionHandlers2 {
+	readonly onEvent?: (event: BridgeStreamEvent2) => void;
+	readonly onTerminal?: (terminal: BridgeStreamTerminal2) => void;
+}
+/** A live subscription, as the caller holds it. */
+interface BridgeSubscription2 {
+	readonly id: string;
+	readonly closed: boolean;
+	close(): void;
+}
+/**
+* Correlate invocations with replies over an injected transport.
+*
+* The client never retries: a timeout, an abort and a closed client are three
+* different answers, and each is reported as itself.
+*/
+declare class BridgeClient2 {
+	private readonly transport;
+	private readonly timeoutMs;
+	private readonly pending;
+	private readonly subscriptions;
+	private readonly disposals;
+	private readonly unsubscribe;
+	private counter;
+	private closed;
+	private unmatched;
+	private breaks;
+	private lastProtocolError;
+	constructor(transport: WireTransport2, options?: BridgeClientOptions2);
+	/** Whether {@link close} has run; a closed client answers nothing. */
+	get isClosed(): boolean;
+	/** Replies that named no pending call: a late duplicate, or a stray message. */
+	get unmatchedReplies(): number;
+	/** Number of calls still waiting for a reply. */
+	get pendingCalls(): number;
+	/**
+	* Invoke one operation and settle with its value or with a typed failure.
+	*/
+	invoke(operation: string, payload?: Readonly<Record<string, unknown>>, options?: InvokeOptions2): Promise<unknown>;
+	/**
+	* Open a subscription and resolve once the host has acknowledged it.
+	*
+	* Frames are matched to the subscription by id and by sequence; a frame that
+	* does not continue the sequence ends the subscription instead of being
+	* delivered out of order.
+	*/
+	subscribe(operation: string, payload?: Readonly<Record<string, unknown>>, handlers?: SubscriptionHandlers2, options?: InvokeOptions2): Promise<BridgeSubscription2>;
+	/**
+	* Ask the host for the handshake: the contract this view may use.
+	*
+	* The host bound the view before its first message, so this is a call, not
+	* a binding. The value is what `Dispatcher.handshake` builds - protocol,
+	* generation, the plugin description, the host schema version and the
+	* operations this view is authorized for.
+	*/
+	handshake(options?: InvokeOptions2): Promise<unknown>;
+	/** Subscriptions still open; a leak check for callers and tests. */
+	get activeSubscriptions(): readonly string[];
+	/** Frames that did not continue their subscription's sequence. */
+	get sequenceBreaks(): number;
+	private send;
+	/**
+	* Refuse further calls, reject what is still pending, and stop listening.
+	*/
+	close(): void;
+	private settle;
+	private handle;
+	private handleFrame;
+	private endSubscription;
+	private disposeSubscription;
+	/** The last malformed message this client refused, if any. */
+	get protocolError(): Error | null;
+}
+export { MAX_SAFE_INTEGER2, MIN_SAFE_INTEGER2, PLUGIN_DESCRIPTION_SCHEMA_VERSION2, ValidationDirection2, SerializedValidationIssue2, SerializedContractValidationError2, ActionDescription2, StreamEventKind2, StreamDescription2, PluginDescription2, isSafeJsonInteger2, QgisSdkDeclarationError2, QgisSdkValidationIssue2, QgisSdkContractValidationError2, parsePluginDescription2, BRIDGE_PROTOCOL_VERSION2, MAX_CALL_ID_LENGTH2, BridgeFailure2, InvokeReply2, StreamTerminalKind2, BridgeStreamEvent2, BridgeStreamTerminal2, BridgeEventFrame2, BridgeTerminalFrame2, BridgeStreamFrame2, WireTransport2, BridgeClientOptions2, InvokeOptions2, QgisSdkBridgeProtocolError2, QgisSdkBridgeTimeoutError2, QgisSdkBridgeAbortedError2, QgisSdkBridgeClosedError2, QgisSdkBridgeSequenceError2, QgisSdkBridgeStreamEndedError2, QgisSdkBridgeRemoteError2, parseInvokeReply2, parseStreamFrame2, SubscriptionHandlers2, BridgeSubscription2, BridgeClient2 };

package/dist/svelte.d.ts

@@ -0,0 +1,75 @@
+import "./shared/chunk-wtv4vt4q.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 { QgisSdkError2 } from "./shared/chunk-pdj2fxjb.js";
+/** A helper was used outside the shape it needs. */
+declare class QgisSdkBridgeSvelteError extends QgisSdkError2 {
+	constructor(message: string);
+}
+/** The context key `setQgisSdk` writes and `getQgisSdk` reads. */
+declare const QGIS_SDK_CONTEXT: unique symbol;
+/**
+* Share a `QgisSdk` with the component subtree; call during component
+* initialisation. The SDK is shared as given and never closed here.
+*/
+declare function setQgisSdk<T extends QgisSdkCore2<unknown, unknown>>(qgis: T): T;
+/**
+* The `QgisSdk` the nearest `setQgisSdk` shared.
+*
+* The type parameters name the generated `Operations` and `Streams`; they are
+* the caller's claim, the same way the ancestor's argument was the page's.
+*/
+declare function getQgisSdk<
+	O = OperationMap2,
+	S = StreamMap2
+>(): QgisSdk2<O, S>;
+/**
+* An operation store whose in-flight call is aborted when the component is
+* destroyed; read it as `$op` or pass it to {@link toRune}.
+*/
+declare function operation<
+	I,
+	R
+>(operation: Operation2<I, R>): OperationStore2<I, R>;
+/**
+* A stream store closed when the component is destroyed. Pass the input now
+* or later with `store.setInput(...)`; `$effect(() => store.setInput(input))`
+* follows a reactive one, by content.
+*/
+declare function stream<
+	I,
+	E
+>(open: Stream2<I, E>, input?: I | null, handlers?: StreamHandlersLike2<E>): StreamStore2<I, E>;
+type RequestOf<
+	O,
+	K extends keyof O
+> = O[K] extends {
+	readonly request: infer Req;
+} ? Req : never;
+type ResultOf<
+	O,
+	K extends keyof O
+> = O[K] extends {
+	readonly result: infer Res;
+} ? Res : never;
+/**
+* The form of one declared action, disposed with the component: render
+* `form.fields`, bind `$form.values`, call `form.submit()`.
+*/
+declare function form<
+	O,
+	K extends keyof O & string
+>(qgis: QgisSdkCore2<O, unknown>, id: K, options?: FormOptions2): FormStore2<RequestOf<O, K> & object, ResultOf<O, K>>;
+/**
+* A host query store refreshed now (unless `auto` is `false`) and aborted
+* when the component is destroyed: `hostQuery(layersQuery(qgis))`.
+*/
+declare function hostQuery<T>(store: HostQueryStore2<T>, options?: {
+	readonly auto?: boolean;
+}): HostQueryStore2<T>;
+/** A runes-friendly view of any store: `const op = toRune(store); op.current`. */
+declare function toRune<T>(store: Store2<T>): {
+	readonly current: T;
+};
+export { Operation2 as Operation, OperationState2 as OperationState, QGIS_SDK_CONTEXT, QgisSdkBridgeSvelteError, Stream2 as Stream, StreamHandleLike2 as StreamHandleLike, StreamHandlersLike2 as StreamHandlersLike, StreamState2 as StreamState, StreamTerminalLike2 as StreamTerminalLike, form, getQgisSdk, hostQuery, operation, setQgisSdk, stream, toRune };

package/dist/svelte.js

@@ -0,0 +1,70 @@
+import"./shared/chunk-8gawbn19.js";
+import {
+  OperationStore2,
+  StreamStore2,
+  FormStore2
+} from "./shared/chunk-t1vpt5yq.js";
+import {
+  QgisSdkError2
+} from "./shared/chunk-2hwva3a3.js";
+
+// src/svelte.ts
+import { getContext, onDestroy, setContext } from "svelte";
+import { fromStore } from "svelte/store";
+class QgisSdkBridgeSvelteError extends QgisSdkError2 {
+  constructor(message) {
+    super(message, "svelte_binding");
+  }
+}
+var QGIS_SDK_CONTEXT = Symbol("qgis-sdk");
+function setQgisSdk(qgis) {
+  setContext(QGIS_SDK_CONTEXT, qgis);
+  return qgis;
+}
+function getQgisSdk() {
+  const qgis = getContext(QGIS_SDK_CONTEXT);
+  if (qgis === undefined) {
+    throw new QgisSdkBridgeSvelteError("getQgisSdk needs setQgisSdk in an ancestor component");
+  }
+  return qgis;
+}
+function operation(operation) {
+  const store = new OperationStore2(operation);
+  onDestroy(store.abort);
+  return store;
+}
+function stream(open, input = null, handlers = {}) {
+  const store = new StreamStore2(open, handlers);
+  store.setInput(input);
+  onDestroy(store.close);
+  return store;
+}
+function form(qgis, id, options) {
+  const store = new FormStore2(qgis, id, options);
+  onDestroy(() => store.dispose());
+  return store;
+}
+function hostQuery(store, options = {}) {
+  if (options.auto !== false) {
+    store.refresh();
+  }
+  onDestroy(store.abort);
+  return store;
+}
+function toRune(store) {
+  return fromStore(store);
+}
+export {
+  QGIS_SDK_CONTEXT,
+  QgisSdkBridgeSvelteError,
+  form,
+  getQgisSdk,
+  hostQuery,
+  operation,
+  setQgisSdk,
+  stream,
+  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": []
}

package/dist/testing.d.ts

@@ -1,25 +1,7 @@
-/**
-* 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;
-}
+import { StreamEventKind2, BridgeStreamTerminal2, WireTransport2 } from "./shared/chunk-wtv4vt4q.js";
+import { HostOperationId2 } from "./shared/chunk-7tgzmz0m.js";
+import { OperationShape2, StreamShape2, BridgeSchema2, QgisSdkHostTheme2 } from "./shared/chunk-a33y575v.js";
+import { QgisSdkError2 } from "./shared/chunk-pdj2fxjb.js";
 /** A scripted host failure, returned from an expectation's handler. */
 interface ScriptedFault {
 	readonly fault: {
@@ -43,7 +25,8 @@ type ScriptedReply<Res> = Res | ScriptedFault | typeof SILENCE | Promise<Res | S
 /** A message the client sent, as the harness recorded it. */
 interface RecordedCall {
 	readonly callId: string;
-	readonly kind: "invoke" | "subscribe" | "unsubscribe";
+	readonly kind: "invoke" | "subscribe" | "unsubscribe" | "handshake";
+	/** Empty for a handshake, which names no operation. */
 	readonly operation: string;
 	readonly payload?: Readonly<Record<string, unknown>>;
 	readonly subscriptionId?: string;
@@ -58,7 +41,7 @@ interface ScriptedStream {
 	/** `false` once the host ended it or the page closed it. */
 	readonly open: boolean;
 	emit(kind: StreamEventKind2, payload: unknown): void;
-	end(terminal: BridgeStreamTerminal): void;
+	end(terminal: BridgeStreamTerminal2): void;
 	/** Advance the sequence without sending, so the next frame is a gap. */
 	skip(frames: number): void;
 }
@@ -67,15 +50,32 @@ interface SubscribeOptions {
 	/** Delay the acknowledgement until this promise settles. */
 	readonly ack?: () => Promise<void>;
 }
+/** Options for {@link createBridgeHarness}. */
+interface HarnessOptions {
+	/**
+	* The host operation ids the scripted handshake advertises; every curated
+	* id by default. A narrowed list is how a test proves a page respects
+	* `qgis.host.granted`. A call outside it is still answered
+	* by whatever the test scripted - typically `fault("not_authorized", ...)` -
+	* because that refusal is the host's, not the harness's.
+	*/
+	readonly granted?: readonly HostOperationId2[];
+	/**
+	* The palette the scripted handshake carries as `theme`; none by default,
+	* which is what a page outside QGIS sees. The same shape the WebEngine
+	* adapter sends, so a test can prove a page takes the host's colours.
+	*/
+	readonly theme?: QgisSdkHostTheme2;
+}
 /**
 * 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 {
+declare class QgisSdkBridgeHarnessError extends QgisSdkError2 {
 	constructor(message: string);
 }
 /** The harness a test holds; also the transport its client is built on. */
-interface BridgeHarness<Op extends string = string> extends WireTransport {
+interface BridgeHarness<Op extends string = string> extends WireTransport2 {
 	/** Every message the client sent, in order. */
 	readonly calls: readonly RecordedCall[];
 	/** Calls no expectation covered; each was answered `unexpected_call`. */
@@ -102,8 +102,36 @@ interface BridgeHarness<Op extends string = string> extends WireTransport {
 	assertSatisfied(): void;
 }
 /**
-* Create a harness; `Op` narrows the operations a test may expect, typically
-* the generated module's `OperationId`.
+* The harness {@link createBridgeHarness} returns for a schema: the same
+* harness, with `expectInvoke` and `expectSubscribe` typed by the schema's
+* `Operations` and `Streams` - a payload is the declared request, a reply the
+* declared result - and by the curated host ids, whose shapes the host module
+* owns.
+*/
+interface SchemaBridgeHarness<
+	O,
+	S
+> extends Omit<BridgeHarness<Extract<keyof O | keyof S, string> | HostOperationId2>, "expectInvoke" | "expectSubscribe"> {
+	expectInvoke<K extends Extract<keyof O, string>>(operation: K, handler: (payload: O[K] extends OperationShape2 ? O[K]["request"] : never) => ScriptedReply<O[K] extends OperationShape2 ? O[K]["result"] : never>): void;
+	expectInvoke<
+		Req extends object = Readonly<Record<string, unknown>>,
+		Res = unknown
+	>(operation: HostOperationId2, handler: (payload: Req) => ScriptedReply<Res>): void;
+	expectSubscribe<K extends Extract<keyof S, string>>(operation: K, script: SubscribeScript<S[K] extends StreamShape2 ? S[K]["request"] : never>, options?: SubscribeOptions): void;
+	expectSubscribe<Req extends object = Readonly<Record<string, unknown>>>(operation: HostOperationId2, script: SubscribeScript<Req>, options?: SubscribeOptions): void;
+}
+/**
+* Create a harness.
+*
+* Given the generated `bridge.schema.ts` default export, the harness is typed
+* by it: `expectInvoke("sites.summary", (payload) => ...)` sees the declared
+* request and must answer with the declared result, and the handshake it
+* answers advertises the schema's operations. Without one, `Op` narrows the
+* operations a test may expect, typically a generated `OperationId`.
 */
-declare function createBridgeHarness<Op extends string = string>(): BridgeHarness<Op>;
-export { BridgeHarness, QgisSdkBridgeHarnessError, RecordedCall, SILENCE, ScriptedFault, ScriptedRefusal, ScriptedReply, ScriptedStream, SubscribeOptions, SubscribeScript, createBridgeHarness, fault };
+declare function createBridgeHarness<Op extends string = string>(options?: HarnessOptions): BridgeHarness<Op>;
+declare function createBridgeHarness<
+	O,
+	S
+>(schema: BridgeSchema2<O, S>, options?: HarnessOptions): SchemaBridgeHarness<O, S>;
+export { BridgeHarness, HarnessOptions, QgisSdkBridgeHarnessError, RecordedCall, SILENCE, SchemaBridgeHarness, ScriptedFault, ScriptedRefusal, ScriptedReply, ScriptedStream, SubscribeOptions, SubscribeScript, createBridgeHarness, fault };