@archont561/qgis-sdk 0.0.0 → 0.3.0

package/dist/testing.js

@@ -0,0 +1,323 @@
+import {
+  QgisSdkError2
+} from "./shared/chunk-0fknax6w.js";
+
+// src/testing.ts
+var PROTOCOL = 1;
+var SUBSCRIPTION_CAPACITY = 64;
+function fault(code, message) {
+  return Object.freeze({ fault: Object.freeze({ code, message }) });
+}
+function isFault(value) {
+  return typeof value === "object" && value !== null && "fault" in value && typeof value.fault === "object";
+}
+var SILENCE = Symbol("qgis-sdk-harness-silence");
+
+class QgisSdkBridgeHarnessError extends QgisSdkError2 {
+  constructor(message) {
+    super(message, "harness_error");
+  }
+}
+
+class Harness {
+  listenerSet = new Set;
+  expectations = [];
+  recorded = [];
+  unexpectedCalls = [];
+  streams = new Map;
+  problems = [];
+  outbox = [];
+  draining = null;
+  streamCounter = 0;
+  get calls() {
+    return [...this.recorded];
+  }
+  get unexpected() {
+    return [...this.unexpectedCalls];
+  }
+  get openSubscriptions() {
+    return [...this.streams.values()].filter((stream) => stream.open).map((stream) => stream.id);
+  }
+  get listeners() {
+    return this.listenerSet.size;
+  }
+  subscribe(listener) {
+    this.listenerSet.add(listener);
+    return () => {
+      this.listenerSet.delete(listener);
+      if (this.listenerSet.size === 0) {
+        for (const stream of this.streams.values()) {
+          stream.open = false;
+        }
+      }
+    };
+  }
+  send(message) {
+    const envelope = this.parseEnvelope(message);
+    if (envelope.kind === "unsubscribe") {
+      this.closeFromPage(envelope);
+      return;
+    }
+    const expectation = this.take(envelope.kind, envelope.operation);
+    if (expectation === undefined) {
+      this.unexpectedCalls.push(envelope);
+      this.deliverFailure(envelope.callId, "unexpected_call", `no expectation covers ${envelope.kind} ${JSON.stringify(envelope.operation)}`);
+      return;
+    }
+    if (expectation.kind === "invoke") {
+      this.answerInvoke(envelope, expectation);
+      return;
+    }
+    this.answerSubscribe(envelope, expectation);
+  }
+  expectInvoke(operation, handler) {
+    this.expectations.push({
+      kind: "invoke",
+      operation,
+      handler
+    });
+  }
+  expectSubscribe(operation, script, options = {}) {
+    this.expectations.push({
+      kind: "subscribe",
+      operation,
+      script,
+      options
+    });
+  }
+  deliver(raw) {
+    this.outbox.push(raw);
+    this.drain();
+  }
+  settled() {
+    return this.draining ?? Promise.resolve();
+  }
+  assertSatisfied() {
+    const problems = [...this.problems];
+    if (this.expectations.length > 0) {
+      const unmet = this.expectations.map((expectation) => `${expectation.kind} ${expectation.operation}`);
+      problems.push(`unmet expectations: ${unmet.join(", ")}`);
+    }
+    if (this.unexpectedCalls.length > 0) {
+      const unexpected = this.unexpectedCalls.map((call) => `${call.kind} ${call.operation}`);
+      problems.push(`unexpected calls: ${unexpected.join(", ")}`);
+    }
+    const open = this.openSubscriptions;
+    if (open.length > 0) {
+      problems.push(`open subscriptions: ${open.join(", ")}`);
+    }
+    if (problems.length > 0) {
+      throw new QgisSdkBridgeHarnessError(problems.join("; "));
+    }
+  }
+  answerInvoke(call, expectation) {
+    this.resolveHandler(call, () => expectation.handler(call.payload ?? {})).then((reply) => {
+      if (reply === SILENCE) {
+        return;
+      }
+      if (isFault(reply)) {
+        this.deliverFailure(call.callId, reply.fault.code, reply.fault.message);
+        return;
+      }
+      this.deliver({
+        protocol: PROTOCOL,
+        call_id: call.callId,
+        ok: true,
+        value: reply
+      });
+    });
+  }
+  answerSubscribe(call, expectation) {
+    this.streamCounter += 1;
+    const open = {
+      id: `s${this.streamCounter}`,
+      operation: call.operation,
+      seq: 0,
+      open: false
+    };
+    const held = [];
+    let sink = (frame) => {
+      held.push(frame);
+    };
+    const stream = this.scripted(open, (frame) => sink(frame));
+    const ack = expectation.options.ack ?? (() => Promise.resolve());
+    ack().then(() => this.resolveHandler(call, () => {
+      open.open = true;
+      return expectation.script(call.payload ?? {}, stream);
+    })).then((outcome) => {
+      if (outcome === SILENCE || isFault(outcome)) {
+        open.open = false;
+        held.length = 0;
+        if (isFault(outcome)) {
+          this.deliverFailure(call.callId, outcome.fault.code, outcome.fault.message);
+        }
+        return;
+      }
+      if (this.listenerSet.size === 0) {
+        open.open = false;
+        held.length = 0;
+        return;
+      }
+      this.streams.set(open.id, open);
+      this.deliver({
+        protocol: PROTOCOL,
+        call_id: call.callId,
+        ok: true,
+        value: {
+          subscription_id: open.id,
+          capacity: SUBSCRIPTION_CAPACITY
+        }
+      });
+      sink = (frame) => this.deliver(frame);
+      for (const frame of held) {
+        sink(frame);
+      }
+      held.length = 0;
+    });
+  }
+  resolveHandler(call, run) {
+    return new Promise((resolve) => {
+      resolve(run());
+    }).catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      this.problems.push(`handler for ${call.kind} ${call.operation} threw: ${message}`);
+      return fault("harness_error", message);
+    });
+  }
+  scripted(open, sink) {
+    const requireOpen = (verb) => {
+      if (!open.open) {
+        throw new QgisSdkBridgeHarnessError(`cannot ${verb} on subscription ${open.id}: it is not open`);
+      }
+    };
+    return {
+      id: open.id,
+      operation: open.operation,
+      get open() {
+        return open.open;
+      },
+      emit: (kind, payload) => {
+        requireOpen("emit");
+        sink({
+          protocol: PROTOCOL,
+          subscription_id: open.id,
+          seq: open.seq,
+          event: { kind, payload }
+        });
+        open.seq += 1;
+      },
+      end: (terminal) => {
+        requireOpen("end");
+        open.open = false;
+        sink({
+          protocol: PROTOCOL,
+          subscription_id: open.id,
+          seq: open.seq,
+          terminal
+        });
+        open.seq += 1;
+      },
+      skip: (frames) => {
+        requireOpen("skip");
+        open.seq += frames;
+      }
+    };
+  }
+  closeFromPage(call) {
+    const open = call.subscriptionId === undefined ? undefined : this.streams.get(call.subscriptionId);
+    const disposed = open?.open === true;
+    if (open !== undefined) {
+      open.open = false;
+    }
+    this.deliver({
+      protocol: PROTOCOL,
+      call_id: call.callId,
+      ok: true,
+      value: { disposed }
+    });
+  }
+  deliverFailure(callId, code, message) {
+    this.deliver({
+      protocol: PROTOCOL,
+      call_id: callId,
+      ok: false,
+      error: { code, message }
+    });
+  }
+  drain() {
+    if (this.draining !== null) {
+      return;
+    }
+    this.draining = (async () => {
+      while (this.outbox.length > 0) {
+        await Promise.resolve();
+        const message = this.outbox.shift();
+        for (const listener of [...this.listenerSet]) {
+          listener(message);
+        }
+      }
+      this.draining = null;
+    })();
+  }
+  take(kind, operation) {
+    const index = this.expectations.findIndex((expectation) => expectation.kind === kind && expectation.operation === operation);
+    if (index === -1) {
+      return;
+    }
+    return this.expectations.splice(index, 1)[0];
+  }
+  parseEnvelope(message) {
+    if (typeof message !== "object" || message === null) {
+      throw new QgisSdkBridgeHarnessError("the client sent a non-object");
+    }
+    const raw = message;
+    if (raw.protocol !== PROTOCOL) {
+      throw new QgisSdkBridgeHarnessError(`the client speaks protocol ${String(raw.protocol)}; the harness fakes ${PROTOCOL}`);
+    }
+    if (typeof raw.call_id !== "string" || raw.call_id.length === 0) {
+      throw new QgisSdkBridgeHarnessError("the client sent no call_id");
+    }
+    const callId = raw.call_id;
+    if (raw.kind === "unsubscribe") {
+      const subscriptionId = raw.subscription_id;
+      if (typeof subscriptionId !== "string") {
+        throw new QgisSdkBridgeHarnessError(`${callId}: unsubscribe names no subscription_id`);
+      }
+      const call = {
+        callId,
+        kind: "unsubscribe",
+        operation: this.streams.get(subscriptionId)?.operation ?? "",
+        subscriptionId
+      };
+      this.recorded.push(call);
+      return call;
+    }
+    if (raw.kind !== "invoke" && raw.kind !== "subscribe") {
+      throw new QgisSdkBridgeHarnessError(`${callId}: ${String(raw.kind)} is not a bridge envelope kind`);
+    }
+    if (typeof raw.operation !== "string") {
+      throw new QgisSdkBridgeHarnessError(`${callId}: operation must be a string`);
+    }
+    const payload = typeof raw.payload === "object" && raw.payload !== null ? raw.payload : {};
+    const call = {
+      callId,
+      kind: raw.kind,
+      operation: raw.operation,
+      payload
+    };
+    this.recorded.push(call);
+    return call;
+  }
+}
+function createBridgeHarness() {
+  return new Harness;
+}
+export {
+  QgisSdkBridgeHarnessError,
+  SILENCE,
+  createBridgeHarness,
+  fault
+};
+
+//# debugId=8E66F11E152CD67C64756E2164756E21
+//# 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 \"./index\";\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\";\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/**\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\nclass Harness<Op extends string> implements BridgeHarness<Op> {\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 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\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\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 !== \"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; `Op` narrows the operations a test may expect, typically\n * the generated module's `OperationId`.\n */\nexport function createBridgeHarness<\n\tOp extends string = string,\n>(): BridgeHarness<Op> {\n\treturn new Harness<Op>();\n}\n"
  ],
  "mappings": "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",
  "debugId": "8E66F11E152CD67C64756E2164756E21",
  "names": []
}

package/package.json

@@ -1,10 +1,64 @@
 {
-  "name": "@archont561/qgis-sdk",
-  "version": "0.0.0",
-  "description": "OIDC trusted publishing setup package for @archont561/qgis-sdk",
-  "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
+	"name": "@archont561/qgis-sdk",
+	"version": "0.3.0",
+	"description": "TypeScript bridge contracts and error primitives for QGIS SDK WebEngine plugin interfaces.",
+	"license": "MIT",
+	"type": "module",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		},
+		"./bridge": {
+			"types": "./dist/bridge.d.ts",
+			"import": "./dist/bridge.js",
+			"default": "./dist/bridge.js"
+		},
+		"./host": {
+			"types": "./dist/host.d.ts",
+			"import": "./dist/host.js",
+			"default": "./dist/host.js"
+		},
+		"./react": {
+			"types": "./dist/react.d.ts",
+			"import": "./dist/react.js",
+			"default": "./dist/react.js"
+		},
+		"./testing": {
+			"types": "./dist/testing.d.ts",
+			"import": "./dist/testing.js",
+			"default": "./dist/testing.js"
+		}
+	},
+	"files": [
+		"dist",
+		"README.md",
+		"LICENSE"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/Archont561/qgis-sdk.git",
+		"directory": "packages/qgis-sdk-typescript"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "bunup",
+		"test": "bun test",
+		"coverage": "bun --cwd=../.. --config=bunfig.toml test --coverage packages/qgis-sdk-typescript/tests",
+		"typecheck": "tsc --noEmit",
+		"generate:contract-types": "json2ts -i 'tests/contracts/generated/schemas/*.json' -o tests/contracts/generated/types/ && json2ts -i 'tests/contracts/pydantic/generated/schemas/*.json' -o tests/contracts/pydantic/generated/types/"
+	},
+	"peerDependencies": {
+		"react": ">=18"
+	},
+	"peerDependenciesMeta": {
+		"react": {
+			"optional": true
+		}
+	}
 }