@archont561/qgis-sdk 0.4.0 → 0.5.0

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,6 +1,6 @@
 import { StreamEventKind2, BridgeStreamTerminal2, WireTransport2 } from "./shared/chunk-wtv4vt4q.js";
-import { HostOperationId2 } from "./shared/chunk-khemhx86.js";
-import { OperationShape2, StreamShape2, BridgeSchema2 } from "./shared/chunk-jjx14tgd.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 {
@@ -55,11 +55,17 @@ 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` (TASK-66 AC #5). A call outside it is still answered
+	* `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

package/dist/testing.js

@@ -1,7 +1,7 @@
 import {
   HOST_SCHEMA_VERSION2,
   HOST_OPERATIONS2
-} from "./shared/chunk-vqyymknv.js";
+} from "./shared/chunk-stre69mw.js";
 import {
   QgisSdkError2
 } from "./shared/chunk-2hwva3a3.js";
@@ -25,6 +25,7 @@ class QgisSdkBridgeHarnessError extends QgisSdkError2 {
 
 class Harness {
   granted;
+  theme;
   plugin;
   listenerSet = new Set;
   expectations = [];
@@ -37,6 +38,7 @@ class Harness {
   streamCounter = 0;
   constructor(options, plugin) {
     this.granted = Object.freeze([...options.granted ?? HOST_OPERATIONS2]);
+    this.theme = options.theme;
     this.plugin = plugin;
   }
   get calls() {
@@ -141,7 +143,8 @@ class Harness {
         operations: [...declared, ...this.granted].map((id) => ({
           id,
           title: id
-        }))
+        })),
+        ...this.theme === undefined ? {} : { theme: this.theme }
       }
     });
   }
@@ -362,5 +365,5 @@ export {
   fault
 };
 
-//# debugId=A423121C49C80BCD64756E2164756E21
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/testing.ts"],
  "sourcesContent": [
    "/**\n * An injected per-client harness for the bridge (TASK-18, decision-23).\n *\n * The harness is a {@link WireTransport}: a page's own `BridgeClient` speaks to\n * it exactly as it would to a QWebChannel, and a test scripts what the host\n * answers - typed replies, faults, silence, stream events, terminals, gaps -\n * without touching a browser global or a running QGIS. Two harnesses are two\n * hosts, so isolation between clients is a fact a test can prove.\n *\n * What it proves is bounded. A green test here says the page handles the\n * frames a host *could* send; it says nothing about what a QWebEngineView or\n * a real host does. That evidence lives in the Python suite and in the\n * qualification harnesses recorded in doc-14. Keep the two apart in reports.\n *\n * Everything the harness sends is delivered asynchronously, one message per\n * microtask, so a reply never re-enters the client inside its own `send`.\n */\n\nimport type {\n\tBridgeStreamTerminal,\n\tStreamEventKind,\n\tWireTransport,\n} from \"./bridge\";\nimport { QgisSdkError } from \"./errors\";\nimport {\n\tHOST_OPERATIONS,\n\tHOST_SCHEMA_VERSION,\n\ttype HostOperationId,\n} from \"./generated/host\";\nimport type { BridgeSchema, OperationShape, StreamShape } from \"./schema\";\n\nconst PROTOCOL = 1;\nconst SUBSCRIPTION_CAPACITY = 64;\n\n/** A scripted host failure, returned from an expectation's handler. */\nexport interface ScriptedFault {\n\treadonly fault: { readonly code: string; readonly message: string };\n}\n\n/** Script a failure reply with this code and message. */\nexport function fault(code: string, message: string): ScriptedFault {\n\treturn Object.freeze({ fault: Object.freeze({ code, message }) });\n}\n\nfunction isFault(value: unknown): value is ScriptedFault {\n\treturn (\n\t\ttypeof value === \"object\" &&\n\t\tvalue !== null &&\n\t\t\"fault\" in value &&\n\t\ttypeof (value as ScriptedFault).fault === \"object\"\n\t);\n}\n\n/** Return this from a handler to never answer, so the client's timeout speaks. */\nexport const SILENCE: unique symbol = Symbol(\"qgis-sdk-harness-silence\");\n\n/** A subscription the script turns down: a fault reply, or no reply at all. */\nexport type ScriptedRefusal = ScriptedFault | typeof SILENCE;\n\n/**\n * A subscribe expectation's script: emit on `stream` now or later, or return\n * a refusal instead of acknowledging.\n */\nexport type SubscribeScript<Req extends object> = (\n\tpayload: Req,\n\tstream: ScriptedStream,\n\t// biome-ignore lint/suspicious/noConfusingVoidType: a script that only emits returns nothing\n) => ScriptedRefusal | void;\n\n/** What an invoke expectation may answer with. */\nexport type ScriptedReply<Res> =\n\t| Res\n\t| ScriptedFault\n\t| typeof SILENCE\n\t| Promise<Res | ScriptedFault | typeof SILENCE>;\n\n/** A message the client sent, as the harness recorded it. */\nexport interface RecordedCall {\n\treadonly callId: string;\n\treadonly kind: \"invoke\" | \"subscribe\" | \"unsubscribe\" | \"handshake\";\n\t/** Empty for a handshake, which names no operation. */\n\treadonly operation: string;\n\treadonly payload?: Readonly<Record<string, unknown>>;\n\treadonly subscriptionId?: string;\n}\n\n/**\n * One scripted subscription. Frames carry the sequence the kernel checks, so\n * `skip` is the one way to script a gap.\n */\nexport interface ScriptedStream {\n\treadonly id: string;\n\treadonly operation: string;\n\t/** `false` once the host ended it or the page closed it. */\n\treadonly open: boolean;\n\temit(kind: StreamEventKind, payload: unknown): void;\n\tend(terminal: BridgeStreamTerminal): void;\n\t/** Advance the sequence without sending, so the next frame is a gap. */\n\tskip(frames: number): void;\n}\n\n/** Options for a subscribe expectation. */\nexport interface SubscribeOptions {\n\t/** Delay the acknowledgement until this promise settles. */\n\treadonly ack?: () => Promise<void>;\n}\n\n/** Options for {@link createBridgeHarness}. */\nexport interface HarnessOptions {\n\t/**\n\t * The host operation ids the scripted handshake advertises; every curated\n\t * id by default. A narrowed list is how a test proves a page respects\n\t * `qgis.host.granted` (TASK-66 AC #5). A call outside it is still answered\n\t * by whatever the test scripted - typically `fault(\"not_authorized\", ...)` -\n\t * because that refusal is the host's, not the harness's.\n\t */\n\treadonly granted?: readonly HostOperationId[];\n}\n\n/**\n * A test's script went wrong: an unmet or unexpected call, a leaked\n * subscription, a handler that threw, or an envelope that is not protocol 1.\n */\nexport class QgisSdkBridgeHarnessError extends QgisSdkError {\n\tpublic constructor(message: string) {\n\t\tsuper(message, \"harness_error\");\n\t}\n}\n\ninterface InvokeExpectation {\n\treadonly kind: \"invoke\";\n\treadonly operation: string;\n\treadonly handler: (payload: Readonly<Record<string, unknown>>) => unknown;\n}\n\ninterface SubscribeExpectation {\n\treadonly kind: \"subscribe\";\n\treadonly operation: string;\n\treadonly script: SubscribeScript<Readonly<Record<string, unknown>>>;\n\treadonly options: SubscribeOptions;\n}\n\ntype Expectation = InvokeExpectation | SubscribeExpectation;\n\ninterface OpenStream {\n\treadonly id: string;\n\treadonly operation: string;\n\tseq: number;\n\topen: boolean;\n}\n\n/** The harness a test holds; also the transport its client is built on. */\nexport interface BridgeHarness<Op extends string = string>\n\textends WireTransport {\n\t/** Every message the client sent, in order. */\n\treadonly calls: readonly RecordedCall[];\n\t/** Calls no expectation covered; each was answered `unexpected_call`. */\n\treadonly unexpected: readonly RecordedCall[];\n\t/** Subscriptions neither ended by a script nor closed by the page. */\n\treadonly openSubscriptions: readonly string[];\n\t/** Clients currently attached. */\n\treadonly listeners: number;\n\t/** Answer the next `operation` call with what `handler` returns. */\n\texpectInvoke<\n\t\tReq extends object = Readonly<Record<string, unknown>>,\n\t\tRes = unknown,\n\t>(operation: Op, handler: (payload: Req) => ScriptedReply<Res>): void;\n\t/**\n\t * Acknowledge the next `operation` subscription and hand `script` the\n\t * stream; return a fault or {@link SILENCE} from it to refuse instead.\n\t */\n\texpectSubscribe<Req extends object = Readonly<Record<string, unknown>>>(\n\t\toperation: Op,\n\t\tscript: SubscribeScript<Req>,\n\t\toptions?: SubscribeOptions,\n\t): void;\n\t/** Push any raw message, for what no expectation can script. */\n\tdeliver(raw: unknown): void;\n\t/** Resolve once everything queued so far has been delivered. */\n\tsettled(): Promise<void>;\n\t/** Throw unless every expectation was met and nothing leaked. */\n\tassertSatisfied(): void;\n}\n\n/**\n * The harness {@link createBridgeHarness} returns for a schema: the same\n * harness, with `expectInvoke` and `expectSubscribe` typed by the schema's\n * `Operations` and `Streams` - a payload is the declared request, a reply the\n * declared result - and by the curated host ids, whose shapes the host module\n * owns.\n */\nexport interface SchemaBridgeHarness<O, S>\n\textends Omit<\n\t\tBridgeHarness<Extract<keyof O | keyof S, string> | HostOperationId>,\n\t\t\"expectInvoke\" | \"expectSubscribe\"\n\t> {\n\texpectInvoke<K extends Extract<keyof O, string>>(\n\t\toperation: K,\n\t\thandler: (\n\t\t\tpayload: O[K] extends OperationShape ? O[K][\"request\"] : never,\n\t\t) => ScriptedReply<O[K] extends OperationShape ? O[K][\"result\"] : never>,\n\t): void;\n\texpectInvoke<\n\t\tReq extends object = Readonly<Record<string, unknown>>,\n\t\tRes = unknown,\n\t>(\n\t\toperation: HostOperationId,\n\t\thandler: (payload: Req) => ScriptedReply<Res>,\n\t): void;\n\texpectSubscribe<K extends Extract<keyof S, string>>(\n\t\toperation: K,\n\t\tscript: SubscribeScript<S[K] extends StreamShape ? S[K][\"request\"] : never>,\n\t\toptions?: SubscribeOptions,\n\t): void;\n\texpectSubscribe<Req extends object = Readonly<Record<string, unknown>>>(\n\t\toperation: HostOperationId,\n\t\tscript: SubscribeScript<Req>,\n\t\toptions?: SubscribeOptions,\n\t): void;\n}\n\nclass Harness<Op extends string> implements BridgeHarness<Op> {\n\tprivate readonly granted: readonly HostOperationId[];\n\tprivate readonly plugin: BridgeSchema | null;\n\tprivate readonly listenerSet = new Set<(message: unknown) => void>();\n\tprivate readonly expectations: Expectation[] = [];\n\tprivate readonly recorded: RecordedCall[] = [];\n\tprivate readonly unexpectedCalls: RecordedCall[] = [];\n\tprivate readonly streams = new Map<string, OpenStream>();\n\tprivate readonly problems: string[] = [];\n\tprivate readonly outbox: unknown[] = [];\n\tprivate draining: Promise<void> | null = null;\n\tprivate streamCounter = 0;\n\n\tpublic constructor(options: HarnessOptions, plugin: BridgeSchema | null) {\n\t\tthis.granted = Object.freeze([...(options.granted ?? HOST_OPERATIONS)]);\n\t\tthis.plugin = plugin;\n\t}\n\n\tpublic get calls(): readonly RecordedCall[] {\n\t\treturn [...this.recorded];\n\t}\n\n\tpublic get unexpected(): readonly RecordedCall[] {\n\t\treturn [...this.unexpectedCalls];\n\t}\n\n\tpublic get openSubscriptions(): readonly string[] {\n\t\treturn [...this.streams.values()]\n\t\t\t.filter((stream) => stream.open)\n\t\t\t.map((stream) => stream.id);\n\t}\n\n\tpublic get listeners(): number {\n\t\treturn this.listenerSet.size;\n\t}\n\n\tpublic subscribe(listener: (message: unknown) => void): () => void {\n\t\tthis.listenerSet.add(listener);\n\t\treturn () => {\n\t\t\tthis.listenerSet.delete(listener);\n\t\t\tif (this.listenerSet.size === 0) {\n\t\t\t\t// The last client detached: the view is gone, and a host disposes\n\t\t\t\t// the subscriptions of a view it lost (decision-23), so they are\n\t\t\t\t// no longer leaks.\n\t\t\t\tfor (const stream of this.streams.values()) {\n\t\t\t\t\tstream.open = false;\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t}\n\n\tpublic send(message: unknown): void {\n\t\tconst envelope = this.parseEnvelope(message);\n\t\tif (envelope.kind === \"unsubscribe\") {\n\t\t\tthis.closeFromPage(envelope);\n\t\t\treturn;\n\t\t}\n\t\tif (envelope.kind === \"handshake\") {\n\t\t\tthis.answerHandshake(envelope);\n\t\t\treturn;\n\t\t}\n\t\tconst expectation = this.take(envelope.kind, envelope.operation);\n\t\tif (expectation === undefined) {\n\t\t\tthis.unexpectedCalls.push(envelope);\n\t\t\tthis.deliverFailure(\n\t\t\t\tenvelope.callId,\n\t\t\t\t\"unexpected_call\",\n\t\t\t\t`no expectation covers ${envelope.kind} ${JSON.stringify(envelope.operation)}`,\n\t\t\t);\n\t\t\treturn;\n\t\t}\n\t\tif (expectation.kind === \"invoke\") {\n\t\t\tthis.answerInvoke(envelope, expectation);\n\t\t\treturn;\n\t\t}\n\t\tthis.answerSubscribe(envelope, expectation);\n\t}\n\n\tpublic expectInvoke<Req extends object, Res>(\n\t\toperation: Op,\n\t\thandler: (payload: Req) => ScriptedReply<Res>,\n\t): void {\n\t\tthis.expectations.push({\n\t\t\tkind: \"invoke\",\n\t\t\toperation,\n\t\t\thandler: handler as InvokeExpectation[\"handler\"],\n\t\t});\n\t}\n\n\tpublic expectSubscribe<Req extends object>(\n\t\toperation: Op,\n\t\tscript: SubscribeScript<Req>,\n\t\toptions: SubscribeOptions = {},\n\t): void {\n\t\tthis.expectations.push({\n\t\t\tkind: \"subscribe\",\n\t\t\toperation,\n\t\t\tscript: script as SubscribeExpectation[\"script\"],\n\t\t\toptions,\n\t\t});\n\t}\n\n\tpublic deliver(raw: unknown): void {\n\t\tthis.outbox.push(raw);\n\t\tthis.drain();\n\t}\n\n\tpublic settled(): Promise<void> {\n\t\treturn this.draining ?? Promise.resolve();\n\t}\n\n\tpublic assertSatisfied(): void {\n\t\tconst problems = [...this.problems];\n\t\tif (this.expectations.length > 0) {\n\t\t\tconst unmet = this.expectations.map(\n\t\t\t\t(expectation) => `${expectation.kind} ${expectation.operation}`,\n\t\t\t);\n\t\t\tproblems.push(`unmet expectations: ${unmet.join(\", \")}`);\n\t\t}\n\t\tif (this.unexpectedCalls.length > 0) {\n\t\t\tconst unexpected = this.unexpectedCalls.map(\n\t\t\t\t(call) => `${call.kind} ${call.operation}`,\n\t\t\t);\n\t\t\tproblems.push(`unexpected calls: ${unexpected.join(\", \")}`);\n\t\t}\n\t\tconst open = this.openSubscriptions;\n\t\tif (open.length > 0) {\n\t\t\tproblems.push(`open subscriptions: ${open.join(\", \")}`);\n\t\t}\n\t\tif (problems.length > 0) {\n\t\t\tthrow new QgisSdkBridgeHarnessError(problems.join(\"; \"));\n\t\t}\n\t}\n\n\t// -- answering ---------------------------------------------------------------\n\n\t/**\n\t * Answer the handshake the way `Dispatcher` does: the plugin description\n\t * the harness was built from (or none) and the advertised operation ids -\n\t * the plugin's, then the granted host ids. No expectation is consumed: a\n\t * handshake is the SDK's first message, not something a test scripts.\n\t */\n\tprivate answerHandshake(call: RecordedCall): void {\n\t\tconst declared = [\n\t\t\t...(this.plugin?.actions ?? []).map((action) => action.id),\n\t\t\t...(this.plugin?.streams ?? []).map((stream) => stream.id),\n\t\t];\n\t\tthis.deliver({\n\t\t\tprotocol: PROTOCOL,\n\t\t\tcall_id: call.callId,\n\t\t\tok: true,\n\t\t\tvalue: {\n\t\t\t\tprotocol: PROTOCOL,\n\t\t\t\tgeneration: 0,\n\t\t\t\tplugin: this.plugin,\n\t\t\t\thost_schema_version: HOST_SCHEMA_VERSION,\n\t\t\t\toperations: [...declared, ...this.granted].map((id) => ({\n\t\t\t\t\tid,\n\t\t\t\t\ttitle: id,\n\t\t\t\t})),\n\t\t\t},\n\t\t});\n\t}\n\n\tprivate answerInvoke(\n\t\tcall: RecordedCall,\n\t\texpectation: InvokeExpectation,\n\t): void {\n\t\tthis.resolveHandler(call, () =>\n\t\t\texpectation.handler(call.payload ?? {}),\n\t\t).then((reply) => {\n\t\t\tif (reply === SILENCE) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (isFault(reply)) {\n\t\t\t\tthis.deliverFailure(call.callId, reply.fault.code, reply.fault.message);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tthis.deliver({\n\t\t\t\tprotocol: PROTOCOL,\n\t\t\t\tcall_id: call.callId,\n\t\t\t\tok: true,\n\t\t\t\tvalue: reply,\n\t\t\t});\n\t\t});\n\t}\n\n\tprivate answerSubscribe(\n\t\tcall: RecordedCall,\n\t\texpectation: SubscribeExpectation,\n\t): void {\n\t\tthis.streamCounter += 1;\n\t\tconst open: OpenStream = {\n\t\t\tid: `s${this.streamCounter}`,\n\t\t\toperation: call.operation,\n\t\t\tseq: 0,\n\t\t\topen: false,\n\t\t};\n\t\t// Frames the script emits before the acknowledgement is decided are held\n\t\t// back: a refused subscription sends none, an accepted one sends them\n\t\t// after the acknowledgement, so the kernel has registered the\n\t\t// subscription by the time the first frame reaches it.\n\t\tconst held: unknown[] = [];\n\t\tlet sink = (frame: unknown): void => {\n\t\t\theld.push(frame);\n\t\t};\n\t\tconst stream = this.scripted(open, (frame) => sink(frame));\n\t\tconst ack = expectation.options.ack ?? (() => Promise.resolve());\n\t\tack()\n\t\t\t.then(() =>\n\t\t\t\tthis.resolveHandler(call, () => {\n\t\t\t\t\topen.open = true;\n\t\t\t\t\treturn expectation.script(call.payload ?? {}, stream);\n\t\t\t\t}),\n\t\t\t)\n\t\t\t.then((outcome) => {\n\t\t\t\tif (outcome === SILENCE || isFault(outcome)) {\n\t\t\t\t\topen.open = false;\n\t\t\t\t\theld.length = 0;\n\t\t\t\t\tif (isFault(outcome)) {\n\t\t\t\t\t\tthis.deliverFailure(\n\t\t\t\t\t\t\tcall.callId,\n\t\t\t\t\t\t\toutcome.fault.code,\n\t\t\t\t\t\t\toutcome.fault.message,\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tif (this.listenerSet.size === 0) {\n\t\t\t\t\t// The view detached while the host was deciding: nothing to\n\t\t\t\t\t// acknowledge to, nothing to keep open.\n\t\t\t\t\topen.open = false;\n\t\t\t\t\theld.length = 0;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tthis.streams.set(open.id, open);\n\t\t\t\tthis.deliver({\n\t\t\t\t\tprotocol: PROTOCOL,\n\t\t\t\t\tcall_id: call.callId,\n\t\t\t\t\tok: true,\n\t\t\t\t\tvalue: {\n\t\t\t\t\t\tsubscription_id: open.id,\n\t\t\t\t\t\tcapacity: SUBSCRIPTION_CAPACITY,\n\t\t\t\t\t},\n\t\t\t\t});\n\t\t\t\tsink = (frame) => this.deliver(frame);\n\t\t\t\tfor (const frame of held) {\n\t\t\t\t\tsink(frame);\n\t\t\t\t}\n\t\t\t\theld.length = 0;\n\t\t\t});\n\t}\n\n\tprivate resolveHandler(\n\t\tcall: RecordedCall,\n\t\trun: () => unknown,\n\t): Promise<unknown> {\n\t\treturn new Promise<unknown>((resolve) => {\n\t\t\tresolve(run());\n\t\t}).catch((error: unknown) => {\n\t\t\tconst message = error instanceof Error ? error.message : String(error);\n\t\t\tthis.problems.push(\n\t\t\t\t`handler for ${call.kind} ${call.operation} threw: ${message}`,\n\t\t\t);\n\t\t\treturn fault(\"harness_error\", message);\n\t\t});\n\t}\n\n\tprivate scripted(\n\t\topen: OpenStream,\n\t\tsink: (frame: unknown) => void,\n\t): ScriptedStream {\n\t\tconst requireOpen = (verb: string): void => {\n\t\t\tif (!open.open) {\n\t\t\t\tthrow new QgisSdkBridgeHarnessError(\n\t\t\t\t\t`cannot ${verb} on subscription ${open.id}: it is not open`,\n\t\t\t\t);\n\t\t\t}\n\t\t};\n\t\treturn {\n\t\t\tid: open.id,\n\t\t\toperation: open.operation,\n\t\t\tget open(): boolean {\n\t\t\t\treturn open.open;\n\t\t\t},\n\t\t\temit: (kind, payload) => {\n\t\t\t\trequireOpen(\"emit\");\n\t\t\t\tsink({\n\t\t\t\t\tprotocol: PROTOCOL,\n\t\t\t\t\tsubscription_id: open.id,\n\t\t\t\t\tseq: open.seq,\n\t\t\t\t\tevent: { kind, payload },\n\t\t\t\t});\n\t\t\t\topen.seq += 1;\n\t\t\t},\n\t\t\tend: (terminal) => {\n\t\t\t\trequireOpen(\"end\");\n\t\t\t\topen.open = false;\n\t\t\t\tsink({\n\t\t\t\t\tprotocol: PROTOCOL,\n\t\t\t\t\tsubscription_id: open.id,\n\t\t\t\t\tseq: open.seq,\n\t\t\t\t\tterminal,\n\t\t\t\t});\n\t\t\t\topen.seq += 1;\n\t\t\t},\n\t\t\tskip: (frames) => {\n\t\t\t\trequireOpen(\"skip\");\n\t\t\t\topen.seq += frames;\n\t\t\t},\n\t\t};\n\t}\n\n\tprivate closeFromPage(call: RecordedCall): void {\n\t\tconst open =\n\t\t\tcall.subscriptionId === undefined\n\t\t\t\t? undefined\n\t\t\t\t: this.streams.get(call.subscriptionId);\n\t\tconst disposed = open?.open === true;\n\t\tif (open !== undefined) {\n\t\t\topen.open = false;\n\t\t}\n\t\tthis.deliver({\n\t\t\tprotocol: PROTOCOL,\n\t\t\tcall_id: call.callId,\n\t\t\tok: true,\n\t\t\tvalue: { disposed },\n\t\t});\n\t}\n\n\tprivate deliverFailure(callId: string, code: string, message: string): void {\n\t\tthis.deliver({\n\t\t\tprotocol: PROTOCOL,\n\t\t\tcall_id: callId,\n\t\t\tok: false,\n\t\t\terror: { code, message },\n\t\t});\n\t}\n\n\tprivate drain(): void {\n\t\tif (this.draining !== null) {\n\t\t\treturn;\n\t\t}\n\t\tthis.draining = (async () => {\n\t\t\twhile (this.outbox.length > 0) {\n\t\t\t\tawait Promise.resolve();\n\t\t\t\tconst message = this.outbox.shift();\n\t\t\t\tfor (const listener of [...this.listenerSet]) {\n\t\t\t\t\tlistener(message);\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.draining = null;\n\t\t})();\n\t}\n\n\t// -- parsing -------------------------------------------------------------------\n\n\tprivate take(\n\t\tkind: \"invoke\" | \"subscribe\",\n\t\toperation: string,\n\t): Expectation | undefined {\n\t\tconst index = this.expectations.findIndex(\n\t\t\t(expectation) =>\n\t\t\t\texpectation.kind === kind && expectation.operation === operation,\n\t\t);\n\t\tif (index === -1) {\n\t\t\treturn undefined;\n\t\t}\n\t\treturn this.expectations.splice(index, 1)[0];\n\t}\n\n\tprivate parseEnvelope(message: unknown): RecordedCall {\n\t\tif (typeof message !== \"object\" || message === null) {\n\t\t\tthrow new QgisSdkBridgeHarnessError(\"the client sent a non-object\");\n\t\t}\n\t\tconst raw = message as Record<string, unknown>;\n\t\tif (raw.protocol !== PROTOCOL) {\n\t\t\tthrow new QgisSdkBridgeHarnessError(\n\t\t\t\t`the client speaks protocol ${String(raw.protocol)}; the harness fakes ${PROTOCOL}`,\n\t\t\t);\n\t\t}\n\t\tif (typeof raw.call_id !== \"string\" || raw.call_id.length === 0) {\n\t\t\tthrow new QgisSdkBridgeHarnessError(\"the client sent no call_id\");\n\t\t}\n\t\tconst callId = raw.call_id;\n\t\tif (raw.kind === \"unsubscribe\") {\n\t\t\tconst subscriptionId = raw.subscription_id;\n\t\t\tif (typeof subscriptionId !== \"string\") {\n\t\t\t\tthrow new QgisSdkBridgeHarnessError(\n\t\t\t\t\t`${callId}: unsubscribe names no subscription_id`,\n\t\t\t\t);\n\t\t\t}\n\t\t\tconst call: RecordedCall = {\n\t\t\t\tcallId,\n\t\t\t\tkind: \"unsubscribe\",\n\t\t\t\toperation: this.streams.get(subscriptionId)?.operation ?? \"\",\n\t\t\t\tsubscriptionId,\n\t\t\t};\n\t\t\tthis.recorded.push(call);\n\t\t\treturn call;\n\t\t}\n\t\tif (raw.kind === \"handshake\") {\n\t\t\tconst call: RecordedCall = { callId, kind: \"handshake\", operation: \"\" };\n\t\t\tthis.recorded.push(call);\n\t\t\treturn call;\n\t\t}\n\t\tif (raw.kind !== \"invoke\" && raw.kind !== \"subscribe\") {\n\t\t\tthrow new QgisSdkBridgeHarnessError(\n\t\t\t\t`${callId}: ${String(raw.kind)} is not a bridge envelope kind`,\n\t\t\t);\n\t\t}\n\t\tif (typeof raw.operation !== \"string\") {\n\t\t\tthrow new QgisSdkBridgeHarnessError(\n\t\t\t\t`${callId}: operation must be a string`,\n\t\t\t);\n\t\t}\n\t\tconst payload =\n\t\t\ttypeof raw.payload === \"object\" && raw.payload !== null\n\t\t\t\t? (raw.payload as Readonly<Record<string, unknown>>)\n\t\t\t\t: {};\n\t\tconst call: RecordedCall = {\n\t\t\tcallId,\n\t\t\tkind: raw.kind,\n\t\t\toperation: raw.operation,\n\t\t\tpayload,\n\t\t};\n\t\tthis.recorded.push(call);\n\t\treturn call;\n\t}\n}\n\n/**\n * Create a harness.\n *\n * Given the generated `bridge.schema.ts` default export, the harness is typed\n * by it: `expectInvoke(\"sites.summary\", (payload) => ...)` sees the declared\n * request and must answer with the declared result, and the handshake it\n * answers advertises the schema's operations. Without one, `Op` narrows the\n * operations a test may expect, typically a generated `OperationId`.\n */\nexport function createBridgeHarness<Op extends string = string>(\n\toptions?: HarnessOptions,\n): BridgeHarness<Op>;\nexport function createBridgeHarness<O, S>(\n\tschema: BridgeSchema<O, S>,\n\toptions?: HarnessOptions,\n): SchemaBridgeHarness<O, S>;\nexport function createBridgeHarness(\n\tfirst: HarnessOptions | BridgeSchema = {},\n\tsecond: HarnessOptions = {},\n): BridgeHarness | SchemaBridgeHarness<unknown, unknown> {\n\tif (\"schema_version\" in first) {\n\t\treturn new Harness<string>(second, first) as SchemaBridgeHarness<\n\t\t\tunknown,\n\t\t\tunknown\n\t\t>;\n\t}\n\treturn new Harness<string>(first, null);\n}\n"
  ],
  "mappings": "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",
  "debugId": "A423121C49C80BCD64756E2164756E21",
  "names": []
}
+//# debugId=8C3CD16BB44B1EC464756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/testing.ts"],
  "sourcesContent": [
    "/**\n * An injected per-client harness for the bridge (decision-23).\n *\n * The harness is a {@link WireTransport}: a page's own `BridgeClient` speaks to\n * it exactly as it would to a QWebChannel, and a test scripts what the host\n * answers - typed replies, faults, silence, stream events, terminals, gaps -\n * without touching a browser global or a running QGIS. Two harnesses are two\n * hosts, so isolation between clients is a fact a test can prove.\n *\n * What it proves is bounded. A green test here says the page handles the\n * frames a host *could* send; it says nothing about what a QWebEngineView or\n * a real host does. That evidence lives in the Python suite and in the\n * qualification harnesses recorded in the workspace guide. Keep the two apart in reports.\n *\n * Everything the harness sends is delivered asynchronously, one message per\n * microtask, so a reply never re-enters the client inside its own `send`.\n */\n\nimport type {\n\tBridgeStreamTerminal,\n\tStreamEventKind,\n\tWireTransport,\n} from \"./bridge\";\nimport { QgisSdkError } from \"./errors\";\nimport {\n\tHOST_OPERATIONS,\n\tHOST_SCHEMA_VERSION,\n\ttype HostOperationId,\n} from \"./generated/host\";\nimport type { QgisSdkHostTheme } from \"./qgis-sdk\";\nimport type { BridgeSchema, OperationShape, StreamShape } from \"./schema\";\n\nconst PROTOCOL = 1;\nconst SUBSCRIPTION_CAPACITY = 64;\n\n/** A scripted host failure, returned from an expectation's handler. */\nexport interface ScriptedFault {\n\treadonly fault: { readonly code: string; readonly message: string };\n}\n\n/** Script a failure reply with this code and message. */\nexport function fault(code: string, message: string): ScriptedFault {\n\treturn Object.freeze({ fault: Object.freeze({ code, message }) });\n}\n\nfunction isFault(value: unknown): value is ScriptedFault {\n\treturn (\n\t\ttypeof value === \"object\" &&\n\t\tvalue !== null &&\n\t\t\"fault\" in value &&\n\t\ttypeof (value as ScriptedFault).fault === \"object\"\n\t);\n}\n\n/** Return this from a handler to never answer, so the client's timeout speaks. */\nexport const SILENCE: unique symbol = Symbol(\"qgis-sdk-harness-silence\");\n\n/** A subscription the script turns down: a fault reply, or no reply at all. */\nexport type ScriptedRefusal = ScriptedFault | typeof SILENCE;\n\n/**\n * A subscribe expectation's script: emit on `stream` now or later, or return\n * a refusal instead of acknowledging.\n */\nexport type SubscribeScript<Req extends object> = (\n\tpayload: Req,\n\tstream: ScriptedStream,\n\t// biome-ignore lint/suspicious/noConfusingVoidType: a script that only emits returns nothing\n) => ScriptedRefusal | void;\n\n/** What an invoke expectation may answer with. */\nexport type ScriptedReply<Res> =\n\t| Res\n\t| ScriptedFault\n\t| typeof SILENCE\n\t| Promise<Res | ScriptedFault | typeof SILENCE>;\n\n/** A message the client sent, as the harness recorded it. */\nexport interface RecordedCall {\n\treadonly callId: string;\n\treadonly kind: \"invoke\" | \"subscribe\" | \"unsubscribe\" | \"handshake\";\n\t/** Empty for a handshake, which names no operation. */\n\treadonly operation: string;\n\treadonly payload?: Readonly<Record<string, unknown>>;\n\treadonly subscriptionId?: string;\n}\n\n/**\n * One scripted subscription. Frames carry the sequence the kernel checks, so\n * `skip` is the one way to script a gap.\n */\nexport interface ScriptedStream {\n\treadonly id: string;\n\treadonly operation: string;\n\t/** `false` once the host ended it or the page closed it. */\n\treadonly open: boolean;\n\temit(kind: StreamEventKind, payload: unknown): void;\n\tend(terminal: BridgeStreamTerminal): void;\n\t/** Advance the sequence without sending, so the next frame is a gap. */\n\tskip(frames: number): void;\n}\n\n/** Options for a subscribe expectation. */\nexport interface SubscribeOptions {\n\t/** Delay the acknowledgement until this promise settles. */\n\treadonly ack?: () => Promise<void>;\n}\n\n/** Options for {@link createBridgeHarness}. */\nexport interface HarnessOptions {\n\t/**\n\t * The host operation ids the scripted handshake advertises; every curated\n\t * id by default. A narrowed list is how a test proves a page respects\n\t * `qgis.host.granted`. A call outside it is still answered\n\t * by whatever the test scripted - typically `fault(\"not_authorized\", ...)` -\n\t * because that refusal is the host's, not the harness's.\n\t */\n\treadonly granted?: readonly HostOperationId[];\n\t/**\n\t * The palette the scripted handshake carries as `theme`; none by default,\n\t * which is what a page outside QGIS sees. The same shape the WebEngine\n\t * adapter sends, so a test can prove a page takes the host's colours.\n\t */\n\treadonly theme?: QgisSdkHostTheme;\n}\n\n/**\n * A test's script went wrong: an unmet or unexpected call, a leaked\n * subscription, a handler that threw, or an envelope that is not protocol 1.\n */\nexport class QgisSdkBridgeHarnessError extends QgisSdkError {\n\tpublic constructor(message: string) {\n\t\tsuper(message, \"harness_error\");\n\t}\n}\n\ninterface InvokeExpectation {\n\treadonly kind: \"invoke\";\n\treadonly operation: string;\n\treadonly handler: (payload: Readonly<Record<string, unknown>>) => unknown;\n}\n\ninterface SubscribeExpectation {\n\treadonly kind: \"subscribe\";\n\treadonly operation: string;\n\treadonly script: SubscribeScript<Readonly<Record<string, unknown>>>;\n\treadonly options: SubscribeOptions;\n}\n\ntype Expectation = InvokeExpectation | SubscribeExpectation;\n\ninterface OpenStream {\n\treadonly id: string;\n\treadonly operation: string;\n\tseq: number;\n\topen: boolean;\n}\n\n/** The harness a test holds; also the transport its client is built on. */\nexport interface BridgeHarness<Op extends string = string>\n\textends WireTransport {\n\t/** Every message the client sent, in order. */\n\treadonly calls: readonly RecordedCall[];\n\t/** Calls no expectation covered; each was answered `unexpected_call`. */\n\treadonly unexpected: readonly RecordedCall[];\n\t/** Subscriptions neither ended by a script nor closed by the page. */\n\treadonly openSubscriptions: readonly string[];\n\t/** Clients currently attached. */\n\treadonly listeners: number;\n\t/** Answer the next `operation` call with what `handler` returns. */\n\texpectInvoke<\n\t\tReq extends object = Readonly<Record<string, unknown>>,\n\t\tRes = unknown,\n\t>(operation: Op, handler: (payload: Req) => ScriptedReply<Res>): void;\n\t/**\n\t * Acknowledge the next `operation` subscription and hand `script` the\n\t * stream; return a fault or {@link SILENCE} from it to refuse instead.\n\t */\n\texpectSubscribe<Req extends object = Readonly<Record<string, unknown>>>(\n\t\toperation: Op,\n\t\tscript: SubscribeScript<Req>,\n\t\toptions?: SubscribeOptions,\n\t): void;\n\t/** Push any raw message, for what no expectation can script. */\n\tdeliver(raw: unknown): void;\n\t/** Resolve once everything queued so far has been delivered. */\n\tsettled(): Promise<void>;\n\t/** Throw unless every expectation was met and nothing leaked. */\n\tassertSatisfied(): void;\n}\n\n/**\n * The harness {@link createBridgeHarness} returns for a schema: the same\n * harness, with `expectInvoke` and `expectSubscribe` typed by the schema's\n * `Operations` and `Streams` - a payload is the declared request, a reply the\n * declared result - and by the curated host ids, whose shapes the host module\n * owns.\n */\nexport interface SchemaBridgeHarness<O, S>\n\textends Omit<\n\t\tBridgeHarness<Extract<keyof O | keyof S, string> | HostOperationId>,\n\t\t\"expectInvoke\" | \"expectSubscribe\"\n\t> {\n\texpectInvoke<K extends Extract<keyof O, string>>(\n\t\toperation: K,\n\t\thandler: (\n\t\t\tpayload: O[K] extends OperationShape ? O[K][\"request\"] : never,\n\t\t) => ScriptedReply<O[K] extends OperationShape ? O[K][\"result\"] : never>,\n\t): void;\n\texpectInvoke<\n\t\tReq extends object = Readonly<Record<string, unknown>>,\n\t\tRes = unknown,\n\t>(\n\t\toperation: HostOperationId,\n\t\thandler: (payload: Req) => ScriptedReply<Res>,\n\t): void;\n\texpectSubscribe<K extends Extract<keyof S, string>>(\n\t\toperation: K,\n\t\tscript: SubscribeScript<S[K] extends StreamShape ? S[K][\"request\"] : never>,\n\t\toptions?: SubscribeOptions,\n\t): void;\n\texpectSubscribe<Req extends object = Readonly<Record<string, unknown>>>(\n\t\toperation: HostOperationId,\n\t\tscript: SubscribeScript<Req>,\n\t\toptions?: SubscribeOptions,\n\t): void;\n}\n\nclass Harness<Op extends string> implements BridgeHarness<Op> {\n\tprivate readonly granted: readonly HostOperationId[];\n\tprivate readonly theme: QgisSdkHostTheme | undefined;\n\tprivate readonly plugin: BridgeSchema | null;\n\tprivate readonly listenerSet = new Set<(message: unknown) => void>();\n\tprivate readonly expectations: Expectation[] = [];\n\tprivate readonly recorded: RecordedCall[] = [];\n\tprivate readonly unexpectedCalls: RecordedCall[] = [];\n\tprivate readonly streams = new Map<string, OpenStream>();\n\tprivate readonly problems: string[] = [];\n\tprivate readonly outbox: unknown[] = [];\n\tprivate draining: Promise<void> | null = null;\n\tprivate streamCounter = 0;\n\n\tpublic constructor(options: HarnessOptions, plugin: BridgeSchema | null) {\n\t\tthis.granted = Object.freeze([...(options.granted ?? HOST_OPERATIONS)]);\n\t\tthis.theme = options.theme;\n\t\tthis.plugin = plugin;\n\t}\n\n\tpublic get calls(): readonly RecordedCall[] {\n\t\treturn [...this.recorded];\n\t}\n\n\tpublic get unexpected(): readonly RecordedCall[] {\n\t\treturn [...this.unexpectedCalls];\n\t}\n\n\tpublic get openSubscriptions(): readonly string[] {\n\t\treturn [...this.streams.values()]\n\t\t\t.filter((stream) => stream.open)\n\t\t\t.map((stream) => stream.id);\n\t}\n\n\tpublic get listeners(): number {\n\t\treturn this.listenerSet.size;\n\t}\n\n\tpublic subscribe(listener: (message: unknown) => void): () => void {\n\t\tthis.listenerSet.add(listener);\n\t\treturn () => {\n\t\t\tthis.listenerSet.delete(listener);\n\t\t\tif (this.listenerSet.size === 0) {\n\t\t\t\t// The last client detached: the view is gone, and a host disposes\n\t\t\t\t// the subscriptions of a view it lost (decision-23), so they are\n\t\t\t\t// no longer leaks.\n\t\t\t\tfor (const stream of this.streams.values()) {\n\t\t\t\t\tstream.open = false;\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t}\n\n\tpublic send(message: unknown): void {\n\t\tconst envelope = this.parseEnvelope(message);\n\t\tif (envelope.kind === \"unsubscribe\") {\n\t\t\tthis.closeFromPage(envelope);\n\t\t\treturn;\n\t\t}\n\t\tif (envelope.kind === \"handshake\") {\n\t\t\tthis.answerHandshake(envelope);\n\t\t\treturn;\n\t\t}\n\t\tconst expectation = this.take(envelope.kind, envelope.operation);\n\t\tif (expectation === undefined) {\n\t\t\tthis.unexpectedCalls.push(envelope);\n\t\t\tthis.deliverFailure(\n\t\t\t\tenvelope.callId,\n\t\t\t\t\"unexpected_call\",\n\t\t\t\t`no expectation covers ${envelope.kind} ${JSON.stringify(envelope.operation)}`,\n\t\t\t);\n\t\t\treturn;\n\t\t}\n\t\tif (expectation.kind === \"invoke\") {\n\t\t\tthis.answerInvoke(envelope, expectation);\n\t\t\treturn;\n\t\t}\n\t\tthis.answerSubscribe(envelope, expectation);\n\t}\n\n\tpublic expectInvoke<Req extends object, Res>(\n\t\toperation: Op,\n\t\thandler: (payload: Req) => ScriptedReply<Res>,\n\t): void {\n\t\tthis.expectations.push({\n\t\t\tkind: \"invoke\",\n\t\t\toperation,\n\t\t\thandler: handler as InvokeExpectation[\"handler\"],\n\t\t});\n\t}\n\n\tpublic expectSubscribe<Req extends object>(\n\t\toperation: Op,\n\t\tscript: SubscribeScript<Req>,\n\t\toptions: SubscribeOptions = {},\n\t): void {\n\t\tthis.expectations.push({\n\t\t\tkind: \"subscribe\",\n\t\t\toperation,\n\t\t\tscript: script as SubscribeExpectation[\"script\"],\n\t\t\toptions,\n\t\t});\n\t}\n\n\tpublic deliver(raw: unknown): void {\n\t\tthis.outbox.push(raw);\n\t\tthis.drain();\n\t}\n\n\tpublic settled(): Promise<void> {\n\t\treturn this.draining ?? Promise.resolve();\n\t}\n\n\tpublic assertSatisfied(): void {\n\t\tconst problems = [...this.problems];\n\t\tif (this.expectations.length > 0) {\n\t\t\tconst unmet = this.expectations.map(\n\t\t\t\t(expectation) => `${expectation.kind} ${expectation.operation}`,\n\t\t\t);\n\t\t\tproblems.push(`unmet expectations: ${unmet.join(\", \")}`);\n\t\t}\n\t\tif (this.unexpectedCalls.length > 0) {\n\t\t\tconst unexpected = this.unexpectedCalls.map(\n\t\t\t\t(call) => `${call.kind} ${call.operation}`,\n\t\t\t);\n\t\t\tproblems.push(`unexpected calls: ${unexpected.join(\", \")}`);\n\t\t}\n\t\tconst open = this.openSubscriptions;\n\t\tif (open.length > 0) {\n\t\t\tproblems.push(`open subscriptions: ${open.join(\", \")}`);\n\t\t}\n\t\tif (problems.length > 0) {\n\t\t\tthrow new QgisSdkBridgeHarnessError(problems.join(\"; \"));\n\t\t}\n\t}\n\n\t// -- answering ---------------------------------------------------------------\n\n\t/**\n\t * Answer the handshake the way `Dispatcher` does: the plugin description\n\t * the harness was built from (or none) and the advertised operation ids -\n\t * the plugin's, then the granted host ids. No expectation is consumed: a\n\t * handshake is the SDK's first message, not something a test scripts.\n\t */\n\tprivate answerHandshake(call: RecordedCall): void {\n\t\tconst declared = [\n\t\t\t...(this.plugin?.actions ?? []).map((action) => action.id),\n\t\t\t...(this.plugin?.streams ?? []).map((stream) => stream.id),\n\t\t];\n\t\tthis.deliver({\n\t\t\tprotocol: PROTOCOL,\n\t\t\tcall_id: call.callId,\n\t\t\tok: true,\n\t\t\tvalue: {\n\t\t\t\tprotocol: PROTOCOL,\n\t\t\t\tgeneration: 0,\n\t\t\t\tplugin: this.plugin,\n\t\t\t\thost_schema_version: HOST_SCHEMA_VERSION,\n\t\t\t\toperations: [...declared, ...this.granted].map((id) => ({\n\t\t\t\t\tid,\n\t\t\t\t\ttitle: id,\n\t\t\t\t})),\n\t\t\t\t...(this.theme === undefined ? {} : { theme: this.theme }),\n\t\t\t},\n\t\t});\n\t}\n\n\tprivate answerInvoke(\n\t\tcall: RecordedCall,\n\t\texpectation: InvokeExpectation,\n\t): void {\n\t\tthis.resolveHandler(call, () =>\n\t\t\texpectation.handler(call.payload ?? {}),\n\t\t).then((reply) => {\n\t\t\tif (reply === SILENCE) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (isFault(reply)) {\n\t\t\t\tthis.deliverFailure(call.callId, reply.fault.code, reply.fault.message);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tthis.deliver({\n\t\t\t\tprotocol: PROTOCOL,\n\t\t\t\tcall_id: call.callId,\n\t\t\t\tok: true,\n\t\t\t\tvalue: reply,\n\t\t\t});\n\t\t});\n\t}\n\n\tprivate answerSubscribe(\n\t\tcall: RecordedCall,\n\t\texpectation: SubscribeExpectation,\n\t): void {\n\t\tthis.streamCounter += 1;\n\t\tconst open: OpenStream = {\n\t\t\tid: `s${this.streamCounter}`,\n\t\t\toperation: call.operation,\n\t\t\tseq: 0,\n\t\t\topen: false,\n\t\t};\n\t\t// Frames the script emits before the acknowledgement is decided are held\n\t\t// back: a refused subscription sends none, an accepted one sends them\n\t\t// after the acknowledgement, so the kernel has registered the\n\t\t// subscription by the time the first frame reaches it.\n\t\tconst held: unknown[] = [];\n\t\tlet sink = (frame: unknown): void => {\n\t\t\theld.push(frame);\n\t\t};\n\t\tconst stream = this.scripted(open, (frame) => sink(frame));\n\t\tconst ack = expectation.options.ack ?? (() => Promise.resolve());\n\t\tack()\n\t\t\t.then(() =>\n\t\t\t\tthis.resolveHandler(call, () => {\n\t\t\t\t\topen.open = true;\n\t\t\t\t\treturn expectation.script(call.payload ?? {}, stream);\n\t\t\t\t}),\n\t\t\t)\n\t\t\t.then((outcome) => {\n\t\t\t\tif (outcome === SILENCE || isFault(outcome)) {\n\t\t\t\t\topen.open = false;\n\t\t\t\t\theld.length = 0;\n\t\t\t\t\tif (isFault(outcome)) {\n\t\t\t\t\t\tthis.deliverFailure(\n\t\t\t\t\t\t\tcall.callId,\n\t\t\t\t\t\t\toutcome.fault.code,\n\t\t\t\t\t\t\toutcome.fault.message,\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tif (this.listenerSet.size === 0) {\n\t\t\t\t\t// The view detached while the host was deciding: nothing to\n\t\t\t\t\t// acknowledge to, nothing to keep open.\n\t\t\t\t\topen.open = false;\n\t\t\t\t\theld.length = 0;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tthis.streams.set(open.id, open);\n\t\t\t\tthis.deliver({\n\t\t\t\t\tprotocol: PROTOCOL,\n\t\t\t\t\tcall_id: call.callId,\n\t\t\t\t\tok: true,\n\t\t\t\t\tvalue: {\n\t\t\t\t\t\tsubscription_id: open.id,\n\t\t\t\t\t\tcapacity: SUBSCRIPTION_CAPACITY,\n\t\t\t\t\t},\n\t\t\t\t});\n\t\t\t\tsink = (frame) => this.deliver(frame);\n\t\t\t\tfor (const frame of held) {\n\t\t\t\t\tsink(frame);\n\t\t\t\t}\n\t\t\t\theld.length = 0;\n\t\t\t});\n\t}\n\n\tprivate resolveHandler(\n\t\tcall: RecordedCall,\n\t\trun: () => unknown,\n\t): Promise<unknown> {\n\t\treturn new Promise<unknown>((resolve) => {\n\t\t\tresolve(run());\n\t\t}).catch((error: unknown) => {\n\t\t\tconst message = error instanceof Error ? error.message : String(error);\n\t\t\tthis.problems.push(\n\t\t\t\t`handler for ${call.kind} ${call.operation} threw: ${message}`,\n\t\t\t);\n\t\t\treturn fault(\"harness_error\", message);\n\t\t});\n\t}\n\n\tprivate scripted(\n\t\topen: OpenStream,\n\t\tsink: (frame: unknown) => void,\n\t): ScriptedStream {\n\t\tconst requireOpen = (verb: string): void => {\n\t\t\tif (!open.open) {\n\t\t\t\tthrow new QgisSdkBridgeHarnessError(\n\t\t\t\t\t`cannot ${verb} on subscription ${open.id}: it is not open`,\n\t\t\t\t);\n\t\t\t}\n\t\t};\n\t\treturn {\n\t\t\tid: open.id,\n\t\t\toperation: open.operation,\n\t\t\tget open(): boolean {\n\t\t\t\treturn open.open;\n\t\t\t},\n\t\t\temit: (kind, payload) => {\n\t\t\t\trequireOpen(\"emit\");\n\t\t\t\tsink({\n\t\t\t\t\tprotocol: PROTOCOL,\n\t\t\t\t\tsubscription_id: open.id,\n\t\t\t\t\tseq: open.seq,\n\t\t\t\t\tevent: { kind, payload },\n\t\t\t\t});\n\t\t\t\topen.seq += 1;\n\t\t\t},\n\t\t\tend: (terminal) => {\n\t\t\t\trequireOpen(\"end\");\n\t\t\t\topen.open = false;\n\t\t\t\tsink({\n\t\t\t\t\tprotocol: PROTOCOL,\n\t\t\t\t\tsubscription_id: open.id,\n\t\t\t\t\tseq: open.seq,\n\t\t\t\t\tterminal,\n\t\t\t\t});\n\t\t\t\topen.seq += 1;\n\t\t\t},\n\t\t\tskip: (frames) => {\n\t\t\t\trequireOpen(\"skip\");\n\t\t\t\topen.seq += frames;\n\t\t\t},\n\t\t};\n\t}\n\n\tprivate closeFromPage(call: RecordedCall): void {\n\t\tconst open =\n\t\t\tcall.subscriptionId === undefined\n\t\t\t\t? undefined\n\t\t\t\t: this.streams.get(call.subscriptionId);\n\t\tconst disposed = open?.open === true;\n\t\tif (open !== undefined) {\n\t\t\topen.open = false;\n\t\t}\n\t\tthis.deliver({\n\t\t\tprotocol: PROTOCOL,\n\t\t\tcall_id: call.callId,\n\t\t\tok: true,\n\t\t\tvalue: { disposed },\n\t\t});\n\t}\n\n\tprivate deliverFailure(callId: string, code: string, message: string): void {\n\t\tthis.deliver({\n\t\t\tprotocol: PROTOCOL,\n\t\t\tcall_id: callId,\n\t\t\tok: false,\n\t\t\terror: { code, message },\n\t\t});\n\t}\n\n\tprivate drain(): void {\n\t\tif (this.draining !== null) {\n\t\t\treturn;\n\t\t}\n\t\tthis.draining = (async () => {\n\t\t\twhile (this.outbox.length > 0) {\n\t\t\t\tawait Promise.resolve();\n\t\t\t\tconst message = this.outbox.shift();\n\t\t\t\tfor (const listener of [...this.listenerSet]) {\n\t\t\t\t\tlistener(message);\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.draining = null;\n\t\t})();\n\t}\n\n\t// -- parsing -------------------------------------------------------------------\n\n\tprivate take(\n\t\tkind: \"invoke\" | \"subscribe\",\n\t\toperation: string,\n\t): Expectation | undefined {\n\t\tconst index = this.expectations.findIndex(\n\t\t\t(expectation) =>\n\t\t\t\texpectation.kind === kind && expectation.operation === operation,\n\t\t);\n\t\tif (index === -1) {\n\t\t\treturn undefined;\n\t\t}\n\t\treturn this.expectations.splice(index, 1)[0];\n\t}\n\n\tprivate parseEnvelope(message: unknown): RecordedCall {\n\t\tif (typeof message !== \"object\" || message === null) {\n\t\t\tthrow new QgisSdkBridgeHarnessError(\"the client sent a non-object\");\n\t\t}\n\t\tconst raw = message as Record<string, unknown>;\n\t\tif (raw.protocol !== PROTOCOL) {\n\t\t\tthrow new QgisSdkBridgeHarnessError(\n\t\t\t\t`the client speaks protocol ${String(raw.protocol)}; the harness fakes ${PROTOCOL}`,\n\t\t\t);\n\t\t}\n\t\tif (typeof raw.call_id !== \"string\" || raw.call_id.length === 0) {\n\t\t\tthrow new QgisSdkBridgeHarnessError(\"the client sent no call_id\");\n\t\t}\n\t\tconst callId = raw.call_id;\n\t\tif (raw.kind === \"unsubscribe\") {\n\t\t\tconst subscriptionId = raw.subscription_id;\n\t\t\tif (typeof subscriptionId !== \"string\") {\n\t\t\t\tthrow new QgisSdkBridgeHarnessError(\n\t\t\t\t\t`${callId}: unsubscribe names no subscription_id`,\n\t\t\t\t);\n\t\t\t}\n\t\t\tconst call: RecordedCall = {\n\t\t\t\tcallId,\n\t\t\t\tkind: \"unsubscribe\",\n\t\t\t\toperation: this.streams.get(subscriptionId)?.operation ?? \"\",\n\t\t\t\tsubscriptionId,\n\t\t\t};\n\t\t\tthis.recorded.push(call);\n\t\t\treturn call;\n\t\t}\n\t\tif (raw.kind === \"handshake\") {\n\t\t\tconst call: RecordedCall = { callId, kind: \"handshake\", operation: \"\" };\n\t\t\tthis.recorded.push(call);\n\t\t\treturn call;\n\t\t}\n\t\tif (raw.kind !== \"invoke\" && raw.kind !== \"subscribe\") {\n\t\t\tthrow new QgisSdkBridgeHarnessError(\n\t\t\t\t`${callId}: ${String(raw.kind)} is not a bridge envelope kind`,\n\t\t\t);\n\t\t}\n\t\tif (typeof raw.operation !== \"string\") {\n\t\t\tthrow new QgisSdkBridgeHarnessError(\n\t\t\t\t`${callId}: operation must be a string`,\n\t\t\t);\n\t\t}\n\t\tconst payload =\n\t\t\ttypeof raw.payload === \"object\" && raw.payload !== null\n\t\t\t\t? (raw.payload as Readonly<Record<string, unknown>>)\n\t\t\t\t: {};\n\t\tconst call: RecordedCall = {\n\t\t\tcallId,\n\t\t\tkind: raw.kind,\n\t\t\toperation: raw.operation,\n\t\t\tpayload,\n\t\t};\n\t\tthis.recorded.push(call);\n\t\treturn call;\n\t}\n}\n\n/**\n * Create a harness.\n *\n * Given the generated `bridge.schema.ts` default export, the harness is typed\n * by it: `expectInvoke(\"sites.summary\", (payload) => ...)` sees the declared\n * request and must answer with the declared result, and the handshake it\n * answers advertises the schema's operations. Without one, `Op` narrows the\n * operations a test may expect, typically a generated `OperationId`.\n */\nexport function createBridgeHarness<Op extends string = string>(\n\toptions?: HarnessOptions,\n): BridgeHarness<Op>;\nexport function createBridgeHarness<O, S>(\n\tschema: BridgeSchema<O, S>,\n\toptions?: HarnessOptions,\n): SchemaBridgeHarness<O, S>;\nexport function createBridgeHarness(\n\tfirst: HarnessOptions | BridgeSchema = {},\n\tsecond: HarnessOptions = {},\n): BridgeHarness | SchemaBridgeHarness<unknown, unknown> {\n\tif (\"schema_version\" in first) {\n\t\treturn new Harness<string>(second, first) as SchemaBridgeHarness<\n\t\t\tunknown,\n\t\t\tunknown\n\t\t>;\n\t}\n\treturn new Harness<string>(first, null);\n}\n"
  ],
  "mappings": "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",
  "debugId": "8C3CD16BB44B1EC464756E2164756E21",
  "names": []
}

package/dist/vue.d.ts

@@ -0,0 +1,106 @@
+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, FormState2, FormOptions2, FormStore2, HostQueryState2, HostQueryStore2 } from "./shared/chunk-3zscfm3y.js";
+import { QgisSdkError2 } from "./shared/chunk-pdj2fxjb.js";
+import { InjectionKey, MaybeRefOrGetter, ShallowRef } from "vue";
+/** A composable was used outside the shape it needs. */
+declare class QgisSdkBridgeVueError extends QgisSdkError2 {
+	constructor(message: string);
+}
+/** The injection key `provideQgisSdk` writes and `useQgisSdk` reads. */
+declare const QGIS_SDK_KEY: InjectionKey<QgisSdkCore2<unknown, unknown>>;
+/**
+* Share a `QgisSdk` with the component subtree; call in `setup()`.
+*
+* The SDK is shared as given, whatever its schema, and never closed here:
+* the page that built it closes it.
+*/
+declare function provideQgisSdk(qgis: QgisSdkCore2<unknown, unknown>): void;
+/**
+* The `QgisSdk` the nearest `provideQgisSdk` shared.
+*
+* The type parameters name the generated `Operations` and `Streams`; they are
+* the caller's claim, the same way the provider's argument was the page's.
+*/
+declare function useQgisSdk<
+	O = OperationMap2,
+	S = StreamMap2
+>(): QgisSdk2<O, S>;
+/**
+* Follow any store as a shallow ref; the subscription ends with the scope.
+*/
+declare function useStore<T>(store: Store2<T>): Readonly<ShallowRef<T>>;
+/** What {@link useOperation} returns. */
+interface UseOperation<
+	I,
+	R
+> {
+	readonly state: Readonly<ShallowRef<OperationState2<R>>>;
+	/** Resolves with the value, or `undefined` when the state carries why not. */
+	run(input: I): Promise<R | undefined>;
+	/** Abort the in-flight call locally; the host may still run it. */
+	abort(): void;
+	/** Back to `idle`, aborting anything in flight. */
+	reset(): void;
+	readonly store: OperationStore2<I, R>;
+}
+/**
+* Run a generated operation from a component; disposing the scope aborts
+* whatever is in flight.
+*/
+declare function useOperation<
+	I,
+	R
+>(operation: Operation2<I, R>): UseOperation<I, R>;
+/** A value, a ref or a getter: what `useStream` accepts as its input. */
+type StreamInput<I> = MaybeRefOrGetter<I | null>;
+/**
+* Hold a generated stream open while the scope lives.
+*
+* `input` may be a value, a ref or a getter; the subscription follows its
+* *content* - a new object with the same fields reopens nothing, a different
+* one closes and reopens, `null` closes. Disposing the scope closes the
+* stream, even before the host acknowledged it.
+*/
+declare function useStream<
+	I,
+	E
+>(open: Stream2<I, E>, input: StreamInput<I>, handlers?: StreamHandlersLike2<E>): Readonly<ShallowRef<StreamState2<E>>> & {
+	readonly store: 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: `qgis.<id>` with its fields, values,
+* issues and submission; disposing the scope aborts a submission in flight.
+*/
+declare function useForm<
+	O,
+	K extends keyof O & string
+>(qgis: QgisSdkCore2<O, unknown>, id: K, options?: FormOptions2): {
+	readonly state: Readonly<ShallowRef<FormState2<ResultOf<O, K>>>>;
+	readonly form: FormStore2<RequestOf<O, K> & object, ResultOf<O, K>>;
+};
+/**
+* Follow a host query store: `useHostQuery(layersQuery(qgis))` for a layer
+* picker. `refresh` runs at once unless `auto` is `false`; disposing the
+* scope aborts a load in flight.
+*/
+declare function useHostQuery<T>(store: HostQueryStore2<T>, options?: {
+	readonly auto?: boolean;
+}): {
+	readonly state: Readonly<ShallowRef<HostQueryState2<T>>>;
+	readonly query: HostQueryStore2<T>;
+};
+export { Operation2 as Operation, OperationState2 as OperationState, QGIS_SDK_KEY, QgisSdkBridgeVueError, Stream2 as Stream, StreamHandleLike2 as StreamHandleLike, StreamHandlersLike2 as StreamHandlersLike, StreamInput, StreamState2 as StreamState, StreamTerminalLike2 as StreamTerminalLike, UseOperation, provideQgisSdk, useForm, useHostQuery, useOperation, useQgisSdk, useStore, useStream };

package/dist/vue.js

@@ -0,0 +1,91 @@
+import"./shared/chunk-8gawbn19.js";
+import {
+  OperationStore2,
+  StreamStore2,
+  FormStore2
+} from "./shared/chunk-t1vpt5yq.js";
+import {
+  QgisSdkError2
+} from "./shared/chunk-2hwva3a3.js";
+
+// src/vue.ts
+import {
+  inject,
+  onScopeDispose,
+  provide,
+  shallowRef,
+  toValue,
+  watch
+} from "vue";
+class QgisSdkBridgeVueError extends QgisSdkError2 {
+  constructor(message) {
+    super(message, "vue_binding");
+  }
+}
+var QGIS_SDK_KEY = Symbol("qgis-sdk");
+function provideQgisSdk(qgis) {
+  provide(QGIS_SDK_KEY, qgis);
+}
+function useQgisSdk() {
+  const qgis = inject(QGIS_SDK_KEY, null) ?? null;
+  if (qgis === null) {
+    throw new QgisSdkBridgeVueError("useQgisSdk needs provideQgisSdk in an ancestor's setup()");
+  }
+  return qgis;
+}
+function useStore(store) {
+  const state = shallowRef(store.getSnapshot());
+  const stop = store.subscribe((snapshot) => {
+    state.value = snapshot;
+  });
+  onScopeDispose(stop);
+  return state;
+}
+function useOperation(operation) {
+  const store = new OperationStore2(operation);
+  onScopeDispose(store.abort);
+  return {
+    state: useStore(store),
+    run: store.run,
+    abort: store.abort,
+    reset: store.reset,
+    store
+  };
+}
+function useStream(open, input, handlers = {}) {
+  const store = new StreamStore2(open, handlers);
+  const state = useStore(store);
+  watch(() => toValue(input), (value) => store.setInput(value), {
+    immediate: true,
+    deep: true
+  });
+  onScopeDispose(store.close);
+  return Object.assign(state, { store });
+}
+function useForm(qgis, id, options) {
+  const form = new FormStore2(qgis, id, options);
+  onScopeDispose(() => form.dispose());
+  return { state: useStore(form), form };
+}
+function useHostQuery(store, options = {}) {
+  const state = useStore(store);
+  if (options.auto !== false) {
+    store.refresh();
+  }
+  onScopeDispose(store.abort);
+  return { state, query: store };
+}
+export {
+  QGIS_SDK_KEY,
+  QgisSdkBridgeVueError,
+  provideQgisSdk,
+  useForm,
+  useHostQuery,
+  useOperation,
+  useQgisSdk,
+  useStore,
+  useStream
+};
+
+//# debugId=A81518D4B333BE6C64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/vue.ts"],
  "sourcesContent": [
    "/**\n * Thin Vue 3 bindings over the store core (decision-47).\n *\n * This entry point is optional and is the only one that imports Vue. It adds\n * no behaviour: every composable wraps one store from `./stores` in a\n * `shallowRef` that follows the store's snapshots and stops following when\n * the effect scope that created it is disposed. The composables take the\n * methods a `QgisSdk` already has - `qgis.sites.summary`, `qgis.sites.watch`\n * - so the typed contract is the generated one, not a Vue copy of it.\n *\n * `provideQgisSdk(qgis)` in `setup()` of an ancestor shares one `QgisSdk`\n * with a subtree; `useQgisSdk()` hands it back under the page's types. The\n * provider never closes what it was given.\n */\n\nimport {\n\ttype InjectionKey,\n\tinject,\n\ttype MaybeRefOrGetter,\n\tonScopeDispose,\n\tprovide,\n\ttype ShallowRef,\n\tshallowRef,\n\ttoValue,\n\twatch,\n} from \"vue\";\nimport { QgisSdkError } from \"./errors\";\nimport type { QgisSdk, QgisSdkCore } from \"./qgis-sdk\";\nimport type { OperationMap, StreamMap } from \"./schema\";\nimport {\n\ttype FormOptions,\n\ttype FormState,\n\tFormStore,\n\ttype HostQueryState,\n\ttype HostQueryStore,\n\ttype Operation,\n\ttype OperationState,\n\tOperationStore,\n\ttype Store,\n\ttype Stream,\n\ttype StreamHandlersLike,\n\ttype StreamState,\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 composable was used outside the shape it needs. */\nexport class QgisSdkBridgeVueError extends QgisSdkError {\n\tpublic constructor(message: string) {\n\t\tsuper(message, \"vue_binding\");\n\t}\n}\n\n/** The injection key `provideQgisSdk` writes and `useQgisSdk` reads. */\nexport const QGIS_SDK_KEY: InjectionKey<QgisSdkCore<unknown, unknown>> =\n\tSymbol(\"qgis-sdk\");\n\n/**\n * Share a `QgisSdk` with the component subtree; call in `setup()`.\n *\n * The SDK is shared as given, whatever its schema, and never closed here:\n * the page that built it closes it.\n */\nexport function provideQgisSdk(qgis: QgisSdkCore<unknown, unknown>): void {\n\tprovide(QGIS_SDK_KEY, qgis);\n}\n\n/**\n * The `QgisSdk` the nearest `provideQgisSdk` shared.\n *\n * The type parameters name the generated `Operations` and `Streams`; they are\n * the caller's claim, the same way the provider's argument was the page's.\n */\nexport function useQgisSdk<O = OperationMap, S = StreamMap>(): QgisSdk<O, S> {\n\t// Outside `setup()` Vue warns and returns undefined; inside, the default.\n\tconst qgis = inject(QGIS_SDK_KEY, null) ?? null;\n\tif (qgis === null) {\n\t\tthrow new QgisSdkBridgeVueError(\n\t\t\t\"useQgisSdk needs provideQgisSdk in an ancestor's setup()\",\n\t\t);\n\t}\n\treturn qgis as unknown as QgisSdk<O, S>;\n}\n\n/**\n * Follow any store as a shallow ref; the subscription ends with the scope.\n */\nexport function useStore<T>(store: Store<T>): Readonly<ShallowRef<T>> {\n\tconst state = shallowRef(store.getSnapshot());\n\tconst stop = store.subscribe((snapshot) => {\n\t\tstate.value = snapshot;\n\t});\n\tonScopeDispose(stop);\n\treturn state;\n}\n\n/** What {@link useOperation} returns. */\nexport interface UseOperation<I, R> {\n\treadonly state: Readonly<ShallowRef<OperationState<R>>>;\n\t/** Resolves with the value, or `undefined` when the state carries why not. */\n\trun(input: I): Promise<R | undefined>;\n\t/** Abort the in-flight call locally; the host may still run it. */\n\tabort(): void;\n\t/** Back to `idle`, aborting anything in flight. */\n\treset(): void;\n\treadonly store: OperationStore<I, R>;\n}\n\n/**\n * Run a generated operation from a component; disposing the scope aborts\n * whatever is in flight.\n */\nexport function useOperation<I, R>(\n\toperation: Operation<I, R>,\n): UseOperation<I, R> {\n\tconst store = new OperationStore(operation);\n\tonScopeDispose(store.abort);\n\treturn {\n\t\tstate: useStore(store),\n\t\trun: store.run,\n\t\tabort: store.abort,\n\t\treset: store.reset,\n\t\tstore,\n\t};\n}\n\n/** A value, a ref or a getter: what `useStream` accepts as its input. */\nexport type StreamInput<I> = MaybeRefOrGetter<I | null>;\n\n/**\n * Hold a generated stream open while the scope lives.\n *\n * `input` may be a value, a ref or a getter; the subscription follows its\n * *content* - a new object with the same fields reopens nothing, a different\n * one closes and reopens, `null` closes. Disposing the scope closes the\n * stream, even before the host acknowledged it.\n */\nexport function useStream<I, E>(\n\topen: Stream<I, E>,\n\tinput: StreamInput<I>,\n\thandlers: StreamHandlersLike<E> = {},\n): Readonly<ShallowRef<StreamState<E>>> & {\n\treadonly store: StreamStore<I, E>;\n} {\n\tconst store = new StreamStore(open, handlers);\n\tconst state = useStore(store);\n\twatch(\n\t\t() => toValue(input),\n\t\t(value) => store.setInput(value),\n\t\t{\n\t\t\timmediate: true,\n\t\t\tdeep: true,\n\t\t},\n\t);\n\tonScopeDispose(store.close);\n\treturn Object.assign(state, { 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: `qgis.<id>` with its fields, values,\n * issues and submission; disposing the scope aborts a submission in flight.\n */\nexport function useForm<O, K extends keyof O & string>(\n\tqgis: QgisSdkCore<O, unknown>,\n\tid: K,\n\toptions?: FormOptions,\n): {\n\treadonly state: Readonly<ShallowRef<FormState<ResultOf<O, K>>>>;\n\treadonly form: FormStore<RequestOf<O, K> & object, ResultOf<O, K>>;\n} {\n\tconst form = 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\tonScopeDispose(() => form.dispose());\n\treturn { state: useStore(form), form };\n}\n\n/**\n * Follow a host query store: `useHostQuery(layersQuery(qgis))` for a layer\n * picker. `refresh` runs at once unless `auto` is `false`; disposing the\n * scope aborts a load in flight.\n */\nexport function useHostQuery<T>(\n\tstore: HostQueryStore<T>,\n\toptions: { readonly auto?: boolean } = {},\n): {\n\treadonly state: Readonly<ShallowRef<HostQueryState<T>>>;\n\treadonly query: HostQueryStore<T>;\n} {\n\tconst state = useStore(store);\n\tif (options.auto !== false) {\n\t\tvoid store.refresh();\n\t}\n\tonScopeDispose(store.abort);\n\treturn { state, query: store };\n}\n"
  ],
  "mappings": ";;;;;;;;;;;AAeA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAyCO,MAAM,8BAA8B,cAAa;AAAA,EAChD,WAAW,CAAC,SAAiB;AAAA,IACnC,MAAM,SAAS,aAAa;AAAA;AAE9B;AAGO,IAAM,eACZ,OAAO,UAAU;AAQX,SAAS,cAAc,CAAC,MAA2C;AAAA,EACzE,QAAQ,cAAc,IAAI;AAAA;AASpB,SAAS,UAA2C,GAAkB;AAAA,EAE5E,MAAM,OAAO,OAAO,cAAc,IAAI,KAAK;AAAA,EAC3C,IAAI,SAAS,MAAM;AAAA,IAClB,MAAM,IAAI,sBACT,0DACD;AAAA,EACD;AAAA,EACA,OAAO;AAAA;AAMD,SAAS,QAAW,CAAC,OAA0C;AAAA,EACrE,MAAM,QAAQ,WAAW,MAAM,YAAY,CAAC;AAAA,EAC5C,MAAM,OAAO,MAAM,UAAU,CAAC,aAAa;AAAA,IAC1C,MAAM,QAAQ;AAAA,GACd;AAAA,EACD,eAAe,IAAI;AAAA,EACnB,OAAO;AAAA;AAmBD,SAAS,YAAkB,CACjC,WACqB;AAAA,EACrB,MAAM,QAAQ,IAAI,gBAAe,SAAS;AAAA,EAC1C,eAAe,MAAM,KAAK;AAAA,EAC1B,OAAO;AAAA,IACN,OAAO,SAAS,KAAK;AAAA,IACrB,KAAK,MAAM;AAAA,IACX,OAAO,MAAM;AAAA,IACb,OAAO,MAAM;AAAA,IACb;AAAA,EACD;AAAA;AAcM,SAAS,SAAe,CAC9B,MACA,OACA,WAAkC,CAAC,GAGlC;AAAA,EACD,MAAM,QAAQ,IAAI,aAAY,MAAM,QAAQ;AAAA,EAC5C,MAAM,QAAQ,SAAS,KAAK;AAAA,EAC5B,MACC,MAAM,QAAQ,KAAK,GACnB,CAAC,UAAU,MAAM,SAAS,KAAK,GAC/B;AAAA,IACC,WAAW;AAAA,IACX,MAAM;AAAA,EACP,CACD;AAAA,EACA,eAAe,MAAM,KAAK;AAAA,EAC1B,OAAO,OAAO,OAAO,OAAO,EAAE,MAAM,CAAC;AAAA;AAkB/B,SAAS,OAAsC,CACrD,MACA,IACA,SAIC;AAAA,EACD,MAAM,OAAO,IAAI,WAChB,MACA,IACA,OACD;AAAA,EACA,eAAe,MAAM,KAAK,QAAQ,CAAC;AAAA,EACnC,OAAO,EAAE,OAAO,SAAS,IAAI,GAAG,KAAK;AAAA;AAQ/B,SAAS,YAAe,CAC9B,OACA,UAAuC,CAAC,GAIvC;AAAA,EACD,MAAM,QAAQ,SAAS,KAAK;AAAA,EAC5B,IAAI,QAAQ,SAAS,OAAO;AAAA,IACtB,MAAM,QAAQ;AAAA,EACpB;AAAA,EACA,eAAe,MAAM,KAAK;AAAA,EAC1B,OAAO,EAAE,OAAO,OAAO,MAAM;AAAA;",
  "debugId": "A81518D4B333BE6C64756E2164756E21",
  "names": []
}