@archont561/qgis-sdk 0.0.0 → 0.4.0

package/dist/index.js

@@ -0,0 +1,732 @@
+import {
+  STREAM_EVENT_KINDS,
+  isPlainRecord,
+  BRIDGE_PROTOCOL_VERSION2,
+  MAX_CALL_ID_LENGTH2,
+  QgisSdkBridgeProtocolError2,
+  QgisSdkBridgeTimeoutError2,
+  QgisSdkBridgeAbortedError2,
+  QgisSdkBridgeClosedError2,
+  QgisSdkBridgeSequenceError2,
+  QgisSdkBridgeStreamEndedError2,
+  QgisSdkBridgeRemoteError2,
+  parseInvokeReply2,
+  parseStreamFrame2,
+  BridgeClient2
+} from "./shared/chunk-8gawbn19.js";
+import {
+  HOST_OPERATIONS2,
+  createHost2
+} from "./shared/chunk-vqyymknv.js";
+import {
+  QgisSdkError2
+} from "./shared/chunk-2hwva3a3.js";
+// src/declarations.ts
+var MAX_SAFE_INTEGER = 9007199254740991;
+var MIN_SAFE_INTEGER = -9007199254740991;
+var PLUGIN_DESCRIPTION_SCHEMA_VERSION = 1;
+function isSafeJsonInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value);
+}
+
+class QgisSdkDeclarationError extends QgisSdkError2 {
+  constructor(message) {
+    super(message, "invalid_declaration");
+  }
+}
+
+class QgisSdkValidationIssue {
+  path;
+  code;
+  constructor(path, code) {
+    this.path = Object.freeze([...path]);
+    this.code = code;
+  }
+  toJSON() {
+    return {
+      path: [...this.path],
+      code: this.code
+    };
+  }
+}
+
+class QgisSdkContractValidationError extends QgisSdkError2 {
+  direction;
+  issues;
+  constructor(direction, issues) {
+    const prefix = direction === "request" ? "Request" : "Result";
+    super(`${prefix} contract validation failed`, "contract_validation_failed");
+    this.direction = direction;
+    this.issues = Object.freeze([...issues]);
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      direction: this.direction,
+      issues: this.issues.map((issue) => issue.toJSON())
+    };
+  }
+}
+var DECLARATION_ID_PATTERN = /^[a-zA-Z][a-zA-Z0-9_.-]*$/;
+var PYTHON_IDENTIFIER_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function validateDeclarationId(value, label) {
+  if (typeof value !== "string" || !DECLARATION_ID_PATTERN.test(value)) {
+    throw new QgisSdkDeclarationError(`Invalid ${label} id: expected [a-zA-Z][a-zA-Z0-9_.-]*`);
+  }
+  return value;
+}
+function validateNonBlankTitle(value, id) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new QgisSdkDeclarationError(`${id}: title must be a nonempty string`);
+  }
+  return value;
+}
+function parseOperationHead(raw, label) {
+  if (!isPlainRecord(raw)) {
+    throw new QgisSdkDeclarationError(`${label[0]?.toUpperCase()}${label.slice(1)} description must be an object`);
+  }
+  const id = validateDeclarationId(raw.id, label);
+  const title = validateNonBlankTitle(raw.title, id);
+  if (typeof raw.handler !== "string" || !PYTHON_IDENTIFIER_PATTERN.test(raw.handler)) {
+    throw new QgisSdkDeclarationError(`${id}: handler must be a valid Python identifier`);
+  }
+  if (!isPlainRecord(raw.request)) {
+    throw new QgisSdkDeclarationError(`${id}: request schema must be an object`);
+  }
+  return {
+    raw,
+    id,
+    title,
+    handler: raw.handler,
+    request: Object.freeze({ ...raw.request })
+  };
+}
+function parseActionDescription(raw) {
+  const head = parseOperationHead(raw, "action");
+  if (!isPlainRecord(head.raw.result)) {
+    throw new QgisSdkDeclarationError(`${head.id}: result schema must be an object`);
+  }
+  return Object.freeze({
+    id: head.id,
+    title: head.title,
+    handler: head.handler,
+    request: head.request,
+    result: Object.freeze({ ...head.raw.result })
+  });
+}
+function parseStreamDescription(raw) {
+  const head = parseOperationHead(raw, "stream");
+  const declared = head.raw.events;
+  if (!isPlainRecord(declared) || Object.keys(declared).length === 0) {
+    throw new QgisSdkDeclarationError(`${head.id}: events must map at least one event kind to a schema`);
+  }
+  const events = {};
+  for (const [kind, schema] of Object.entries(declared)) {
+    if (!STREAM_EVENT_KINDS.includes(kind)) {
+      throw new QgisSdkDeclarationError(`${head.id}: ${kind} is not a stream event kind`);
+    }
+    if (!isPlainRecord(schema)) {
+      throw new QgisSdkDeclarationError(`${head.id}: events.${kind} schema must be an object`);
+    }
+    events[kind] = Object.freeze({ ...schema });
+  }
+  return Object.freeze({
+    id: head.id,
+    title: head.title,
+    handler: head.handler,
+    request: head.request,
+    events: Object.freeze(events)
+  });
+}
+function parsePluginDescription(input) {
+  let parsed = input;
+  if (typeof input === "string") {
+    try {
+      parsed = JSON.parse(input);
+    } catch {
+      throw new QgisSdkDeclarationError("Plugin description is not valid JSON");
+    }
+  }
+  if (!isPlainRecord(parsed)) {
+    throw new QgisSdkDeclarationError("Plugin description must be an object");
+  }
+  if (parsed.schema_version !== PLUGIN_DESCRIPTION_SCHEMA_VERSION) {
+    throw new QgisSdkDeclarationError(`Unsupported plugin description schema_version: ${String(parsed.schema_version)}`);
+  }
+  const id = validateDeclarationId(parsed.id, "plugin");
+  const title = validateNonBlankTitle(parsed.title, id);
+  if (!Array.isArray(parsed.actions)) {
+    throw new QgisSdkDeclarationError(`${id}: actions must be an array`);
+  }
+  const declaredStreams = parsed.streams ?? [];
+  if (!Array.isArray(declaredStreams)) {
+    throw new QgisSdkDeclarationError(`${id}: streams must be an array`);
+  }
+  const seenIds = new Set;
+  const claim = (operationId, label) => {
+    if (seenIds.has(operationId)) {
+      throw new QgisSdkDeclarationError(`${id}: duplicate ${label} id ${operationId}`);
+    }
+    seenIds.add(operationId);
+  };
+  const actions = [];
+  for (const item of parsed.actions) {
+    const action = parseActionDescription(item);
+    claim(action.id, "action");
+    actions.push(action);
+  }
+  const streams = [];
+  for (const item of declaredStreams) {
+    const stream = parseStreamDescription(item);
+    claim(stream.id, "stream");
+    streams.push(stream);
+  }
+  const byId = (left, right) => left.id < right.id ? -1 : 1;
+  actions.sort(byId);
+  streams.sort(byId);
+  return Object.freeze({
+    schema_version: PLUGIN_DESCRIPTION_SCHEMA_VERSION,
+    id,
+    title,
+    actions: Object.freeze(actions),
+    streams: Object.freeze(streams)
+  });
+}
+// src/validate.ts
+class QgisSdkContractError extends QgisSdkError2 {
+  operation;
+  direction;
+  issues;
+  constructor(operation, direction, issues) {
+    const detail = issues[0] === undefined ? "" : `: ${describe(issues[0])}`;
+    super(`${operation}: the ${direction} does not match the declared contract${detail}`, "contract_validation_failed");
+    this.operation = operation;
+    this.direction = direction;
+    this.issues = Object.freeze([...issues]);
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      operation: this.operation,
+      direction: this.direction,
+      issues: this.issues.map((issue) => issue.toJSON())
+    };
+  }
+}
+function describe(issue) {
+  const where = issue.path.length === 0 ? "value" : issue.path.join(".");
+  return `${where} ${issue.code}`;
+}
+var PRIMITIVES = new Set([
+  "string",
+  "boolean",
+  "integer",
+  "number",
+  "null",
+  "array",
+  "object"
+]);
+var KNOWN_KEYWORDS = new Set([
+  "type",
+  "properties",
+  "required",
+  "additionalProperties",
+  "items",
+  "anyOf",
+  "enum",
+  "minimum",
+  "maximum",
+  "pattern",
+  "title",
+  "description"
+]);
+function validateAgainstSchema(value, schema, options = {}) {
+  const issues = [];
+  check(value, schema, options.path ?? [], options.allowUnknown === true, issues);
+  return issues;
+}
+function check(value, schema, path, allowUnknown, issues) {
+  if (!isPlainRecord(schema)) {
+    throw new QgisSdkDeclarationError(`${where(path)}: a schema must be an object`);
+  }
+  const unknown = Object.keys(schema).filter((key) => !KNOWN_KEYWORDS.has(key));
+  if (unknown.length > 0) {
+    throw new QgisSdkDeclarationError(`${where(path)}: unsupported schema keyword(s) ${unknown.sort().join(", ")}`);
+  }
+  if ("anyOf" in schema) {
+    const branches = schema.anyOf;
+    if (!Array.isArray(branches) || branches.length === 0) {
+      throw new QgisSdkDeclarationError(`${where(path)}: anyOf must be a nonempty list`);
+    }
+    for (const branch of branches) {
+      const attempt = [];
+      check(value, branch, path, allowUnknown, attempt);
+      if (attempt.length === 0) {
+        return;
+      }
+    }
+    issues.push(new QgisSdkValidationIssue([...path], "any_of"));
+    return;
+  }
+  if ("enum" in schema) {
+    const choices = schema.enum;
+    if (!Array.isArray(choices)) {
+      throw new QgisSdkDeclarationError(`${where(path)}: enum must be a list`);
+    }
+    if (!choices.some((choice) => sameJson(choice, value))) {
+      issues.push(new QgisSdkValidationIssue([...path], "enum"));
+    }
+    return;
+  }
+  const declared = schema.type;
+  if (declared === undefined) {
+    throw new QgisSdkDeclarationError(`${where(path)}: a schema needs a type, anyOf or enum`);
+  }
+  if (typeof declared !== "string" || !PRIMITIVES.has(declared)) {
+    throw new QgisSdkDeclarationError(`${where(path)}: unsupported type ${JSON.stringify(declared)}`);
+  }
+  switch (declared) {
+    case "string":
+      checkString(value, schema, path, issues);
+      return;
+    case "boolean":
+      if (typeof value !== "boolean") {
+        issues.push(new QgisSdkValidationIssue([...path], "type"));
+      }
+      return;
+    case "integer":
+      if (typeof value !== "number" || !Number.isInteger(value)) {
+        issues.push(new QgisSdkValidationIssue([...path], "type"));
+        return;
+      }
+      checkBounds(value, schema, path, issues);
+      return;
+    case "number":
+      if (typeof value !== "number") {
+        issues.push(new QgisSdkValidationIssue([...path], "type"));
+        return;
+      }
+      if (!Number.isFinite(value)) {
+        issues.push(new QgisSdkValidationIssue([...path], "not_finite"));
+        return;
+      }
+      checkBounds(value, schema, path, issues);
+      return;
+    case "null":
+      if (value !== null) {
+        issues.push(new QgisSdkValidationIssue([...path], "type"));
+      }
+      return;
+    case "array":
+      checkArray(value, schema, path, allowUnknown, issues);
+      return;
+    default:
+      checkObject(value, schema, path, allowUnknown, issues);
+  }
+}
+function checkString(value, schema, path, issues) {
+  if (typeof value !== "string") {
+    issues.push(new QgisSdkValidationIssue([...path], "type"));
+    return;
+  }
+  const pattern = schema.pattern;
+  if (pattern === undefined || pattern === null) {
+    return;
+  }
+  if (typeof pattern !== "string") {
+    throw new QgisSdkDeclarationError(`${where(path)}: pattern must be a string`);
+  }
+  let expression;
+  try {
+    expression = new RegExp(`^(?:${pattern})$`, "u");
+  } catch (error) {
+    throw new QgisSdkDeclarationError(`${where(path)}: pattern ${JSON.stringify(pattern)} is unusable: ${String(error)}`);
+  }
+  if (!expression.test(value)) {
+    issues.push(new QgisSdkValidationIssue([...path], "pattern"));
+  }
+}
+function checkBounds(value, schema, path, issues) {
+  const minimum = schema.minimum;
+  if (typeof minimum === "number" && value < minimum) {
+    issues.push(new QgisSdkValidationIssue([...path], "minimum"));
+  }
+  const maximum = schema.maximum;
+  if (typeof maximum === "number" && value > maximum) {
+    issues.push(new QgisSdkValidationIssue([...path], "maximum"));
+  }
+}
+function checkArray(value, schema, path, allowUnknown, issues) {
+  if (!Array.isArray(value)) {
+    issues.push(new QgisSdkValidationIssue([...path], "type"));
+    return;
+  }
+  const items = schema.items;
+  if (items === undefined || items === null) {
+    return;
+  }
+  value.forEach((item, index) => {
+    check(item, items, [...path, index], allowUnknown, issues);
+  });
+}
+function checkObject(value, schema, path, allowUnknown, issues) {
+  if (!isPlainRecord(value)) {
+    issues.push(new QgisSdkValidationIssue([...path], "type"));
+    return;
+  }
+  const properties = schema.properties ?? {};
+  if (!isPlainRecord(properties)) {
+    throw new QgisSdkDeclarationError(`${where(path)}: properties must be an object`);
+  }
+  const required = schema.required ?? [];
+  if (!Array.isArray(required)) {
+    throw new QgisSdkDeclarationError(`${where(path)}: required must be a list`);
+  }
+  for (const key of required) {
+    if (typeof key === "string" && !(key in value)) {
+      issues.push(new QgisSdkValidationIssue([...path, key], "required"));
+    }
+  }
+  const strict = schema.additionalProperties === false && !allowUnknown;
+  for (const [key, item] of Object.entries(value)) {
+    if (Object.hasOwn(properties, key)) {
+      check(item, properties[key], [...path, key], allowUnknown, issues);
+    } else if (strict) {
+      issues.push(new QgisSdkValidationIssue([...path, key], "unknown_property"));
+    }
+  }
+}
+function sameJson(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (typeof a !== typeof b || a === null || b === null) {
+    return false;
+  }
+  if (Array.isArray(a)) {
+    return Array.isArray(b) && a.length === b.length && a.every((item, index) => sameJson(item, b[index]));
+  }
+  if (isPlainRecord(a) && isPlainRecord(b)) {
+    const keys = Object.keys(a);
+    return keys.length === Object.keys(b).length && keys.every((key) => Object.hasOwn(b, key) && sameJson(a[key], b[key]));
+  }
+  return false;
+}
+function where(path) {
+  return path.length === 0 ? "value" : path.join(".");
+}
+
+// src/webchannel.ts
+class QgisSdkWebChannelError extends QgisSdkError2 {
+  constructor(message) {
+    super(message, "no_web_channel");
+  }
+}
+function scope() {
+  return globalThis;
+}
+function insideQgis() {
+  const page = scope();
+  return page.qt !== undefined && typeof page.QWebChannel === "function";
+}
+function createWebChannelTransport(objectName = "bridge") {
+  const page = scope();
+  const qt = page.qt;
+  const QWebChannel = page.QWebChannel;
+  if (qt === undefined || typeof QWebChannel !== "function") {
+    throw new QgisSdkWebChannelError("not inside a QGIS web view: window.qt is missing");
+  }
+  const listeners = new Set;
+  const queue = [];
+  let object = null;
+  let failure = null;
+  let closed = false;
+  const forward = (text) => {
+    if (closed) {
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      return;
+    }
+    for (const listener of [...listeners]) {
+      listener(parsed);
+    }
+  };
+  const ready = new Promise((resolve, reject) => {
+    new QWebChannel(qt.webChannelTransport, (channel) => {
+      const found = channel.objects[objectName];
+      if (found === undefined) {
+        failure = new QgisSdkWebChannelError(`the host registered no ${JSON.stringify(objectName)} channel object`);
+        queue.length = 0;
+        reject(failure);
+        return;
+      }
+      if (closed) {
+        resolve();
+        return;
+      }
+      object = found;
+      found.message.connect(forward);
+      for (const text of queue.splice(0)) {
+        found.receive(text);
+      }
+      resolve();
+    });
+  });
+  return {
+    ready,
+    send(message) {
+      if (closed) {
+        throw new QgisSdkWebChannelError("the web channel transport is closed");
+      }
+      if (failure !== null) {
+        throw failure;
+      }
+      const text = JSON.stringify(message);
+      if (object === null) {
+        queue.push(text);
+        return;
+      }
+      object.receive(text);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    close() {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      queue.length = 0;
+      listeners.clear();
+      object?.message.disconnect(forward);
+    }
+  };
+}
+
+// src/qgis-sdk.ts
+var QGIS_SDK_MEMBERS = Object.freeze([
+  "client",
+  "host",
+  "schema",
+  "ready",
+  "close"
+]);
+var HOST_IDS = new Set(HOST_OPERATIONS2);
+function parseHandshake(value) {
+  if (!isPlainRecord(value) || !Array.isArray(value.operations)) {
+    throw new QgisSdkBridgeProtocolError2("The handshake reply carries no operations list");
+  }
+  const operations = [];
+  for (const operation of value.operations) {
+    if (isPlainRecord(operation) && typeof operation.id === "string") {
+      operations.push(operation.id);
+    }
+  }
+  return { operations };
+}
+function unwrapRequest(operation, request) {
+  if (request === undefined) {
+    return {};
+  }
+  if (!isPlainRecord(request)) {
+    throw new QgisSdkContractError(operation, "request", [
+      ...validateAgainstSchema(request, { type: "object" })
+    ]);
+  }
+  return request;
+}
+function checkedRequest(description, request) {
+  const payload = unwrapRequest(description.id, request);
+  const issues = validateAgainstSchema(payload, description.request);
+  if (issues.length > 0) {
+    throw new QgisSdkContractError(description.id, "request", issues);
+  }
+  return payload;
+}
+function operationMethod(client, action) {
+  return async (request, options) => {
+    const payload = checkedRequest(action, request);
+    const value = await client.invoke(action.id, payload, options);
+    const issues = validateAgainstSchema(value, action.result, {
+      allowUnknown: true
+    });
+    if (issues.length > 0) {
+      throw new QgisSdkContractError(action.id, "result", issues);
+    }
+    return value;
+  };
+}
+function streamMethod(client, stream) {
+  return async (request, handlers, options) => {
+    const payload = checkedRequest(stream, request);
+    let ended = false;
+    let violated = false;
+    let handle = null;
+    const end = (terminal) => {
+      if (ended) {
+        return;
+      }
+      ended = true;
+      handlers.onTerminal?.(terminal);
+    };
+    handle = await client.subscribe(stream.id, payload, {
+      onEvent: (event) => {
+        if (ended) {
+          return;
+        }
+        const declared = stream.events[event.kind];
+        const issues = declared === undefined ? undefined : validateAgainstSchema(event.payload, declared, {
+          allowUnknown: true,
+          path: ["payload"]
+        });
+        if (issues !== undefined && issues.length === 0) {
+          handlers.onEvent?.(event);
+          return;
+        }
+        const error = new QgisSdkContractError(stream.id, "event", issues ?? []);
+        end({ kind: "error", message: error.message });
+        if (handle === null) {
+          violated = true;
+        } else {
+          handle.close();
+        }
+      },
+      onTerminal: end
+    }, options);
+    if (violated) {
+      handle.close();
+    }
+    return handle;
+  };
+}
+function buildHost(client, granted) {
+  const host = createHost2(client);
+  return Object.freeze({
+    ...host,
+    get granted() {
+      return granted();
+    }
+  });
+}
+function build(schema, options) {
+  if (options.client !== undefined && options.transport !== undefined) {
+    throw new QgisSdkDeclarationError("QgisSdk.fromBridgeSchema takes a client or a transport, not both");
+  }
+  const owned = options.client === undefined;
+  const transport = options.transport ?? (options.client === undefined ? createWebChannelTransport(options.channelObject ?? "bridge") : undefined);
+  const client = options.client ?? new BridgeClient2(transport, options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs });
+  let granted = Object.freeze([]);
+  const ready = client.handshake().then((value) => {
+    const handshake = parseHandshake(value);
+    granted = Object.freeze(handshake.operations.filter((id) => HOST_IDS.has(id)));
+  });
+  ready.catch(() => {
+    return;
+  });
+  const members = {
+    schema,
+    client,
+    host: buildHost(client, () => granted),
+    ready,
+    close: () => {
+      if (owned) {
+        client.close();
+      }
+    }
+  };
+  const namespaces = [];
+  for (const action of schema.actions) {
+    place(members, namespaces, action.id, operationMethod(client, action));
+  }
+  for (const stream of schema.streams) {
+    place(members, namespaces, stream.id, streamMethod(client, stream));
+  }
+  for (const namespace of namespaces) {
+    Object.freeze(namespace);
+  }
+  return Object.freeze(members);
+}
+function place(members, namespaces, id, method) {
+  const segments = id.split(".");
+  if (segments.some((segment) => segment === "")) {
+    throw new QgisSdkDeclarationError(`${id}: an operation id may not have an empty segment`);
+  }
+  const head = segments[0];
+  if (QGIS_SDK_MEMBERS.includes(head)) {
+    throw new QgisSdkDeclarationError(`${id}: an operation id may not start with a QgisSdk member (${QGIS_SDK_MEMBERS.join(", ")})`);
+  }
+  let node = members;
+  for (const [index, segment] of segments.entries()) {
+    const prefix = segments.slice(0, index + 1).join(".");
+    const existing = node[segment];
+    if (index === segments.length - 1) {
+      if (existing !== undefined) {
+        throw new QgisSdkDeclarationError(typeof existing === "function" ? `${id}: duplicate operation id` : `${id}: an operation id may not be a prefix of another declared id`);
+      }
+      node[segment] = method;
+      return;
+    }
+    if (existing === undefined) {
+      const namespace = {};
+      namespaces.push(namespace);
+      node[segment] = namespace;
+      node = namespace;
+    } else if (typeof existing === "function") {
+      throw new QgisSdkDeclarationError(`${id}: ${prefix} is already an operation id; an id may not extend another`);
+    } else {
+      node = existing;
+    }
+  }
+}
+var QgisSdk;
+((QgisSdk) => {
+  function fromBridgeSchema(schema, options = {}) {
+    return build(schema, options);
+  }
+  QgisSdk.fromBridgeSchema = fromBridgeSchema;
+})(QgisSdk ||= {});
+// src/schema.ts
+function defineBridgeSchema(input) {
+  return parsePluginDescription(input);
+}
+export {
+  BRIDGE_PROTOCOL_VERSION2 as BRIDGE_PROTOCOL_VERSION,
+  BridgeClient2 as BridgeClient,
+  MAX_CALL_ID_LENGTH2 as MAX_CALL_ID_LENGTH,
+  MAX_SAFE_INTEGER,
+  MIN_SAFE_INTEGER,
+  PLUGIN_DESCRIPTION_SCHEMA_VERSION,
+  QGIS_SDK_MEMBERS,
+  QgisSdk,
+  QgisSdkBridgeAbortedError2 as QgisSdkBridgeAbortedError,
+  QgisSdkBridgeClosedError2 as QgisSdkBridgeClosedError,
+  QgisSdkBridgeProtocolError2 as QgisSdkBridgeProtocolError,
+  QgisSdkBridgeRemoteError2 as QgisSdkBridgeRemoteError,
+  QgisSdkBridgeSequenceError2 as QgisSdkBridgeSequenceError,
+  QgisSdkBridgeStreamEndedError2 as QgisSdkBridgeStreamEndedError,
+  QgisSdkBridgeTimeoutError2 as QgisSdkBridgeTimeoutError,
+  QgisSdkContractError,
+  QgisSdkContractValidationError,
+  QgisSdkDeclarationError,
+  QgisSdkError2 as QgisSdkError,
+  QgisSdkValidationIssue,
+  QgisSdkWebChannelError,
+  createWebChannelTransport,
+  defineBridgeSchema,
+  insideQgis,
+  isSafeJsonInteger,
+  parseInvokeReply2 as parseInvokeReply,
+  parsePluginDescription,
+  parseStreamFrame2 as parseStreamFrame,
+  validateAgainstSchema
+};
+
+//# debugId=7555C93DA5D57B1A64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/declarations.ts", "src/validate.ts", "src/webchannel.ts", "src/qgis-sdk.ts", "src/schema.ts"],
  "sourcesContent": [
    "/**\n * The version 1 plugin-description contract and its wire limits.\n *\n * Mirrors the QGIS-free `qgis_sdk.models` and `qgis_sdk.declarations`\n * (`schema_version = 1`) contracts without importing browser or Qt globals.\n * `parsePluginDescription` is the browser-side reader of what\n * `describe_plugin(cls).to_json()` emits; `qgis-sdk bridge generate` is the\n * build-time one.\n */\n\nimport { QgisSdkError } from \"./errors\";\nimport { isPlainRecord, STREAM_EVENT_KINDS } from \"./internal\";\n\nexport const MAX_SAFE_INTEGER: number = 9_007_199_254_740_991;\nexport const MIN_SAFE_INTEGER: number = -9_007_199_254_740_991;\nexport const PLUGIN_DESCRIPTION_SCHEMA_VERSION: 1 = 1;\n\nexport type ValidationDirection = \"request\" | \"result\";\n\nexport interface SerializedValidationIssue {\n\treadonly path: (string | number)[];\n\treadonly code: string;\n}\n\nexport interface SerializedContractValidationError {\n\treadonly code: string;\n\treadonly direction: ValidationDirection;\n\treadonly issues: SerializedValidationIssue[];\n}\n\nexport interface ActionDescription {\n\treadonly id: string;\n\treadonly title: string;\n\treadonly handler: string;\n\treadonly request: Readonly<Record<string, unknown>>;\n\treadonly result: Readonly<Record<string, unknown>>;\n}\n\n/** The event kinds a stream may declare; the frame carries the same three. */\nexport type StreamEventKind = \"data\" | \"progress\" | \"state\";\n\n/**\n * A declared stream (decision-28): a request in, one payload schema per\n * declared event kind out. There is no `result`: the reply to a subscription is\n * the protocol's acknowledgement, not something an author declares.\n */\nexport interface StreamDescription {\n\treadonly id: string;\n\treadonly title: string;\n\treadonly handler: string;\n\treadonly request: Readonly<Record<string, unknown>>;\n\treadonly events: Readonly<\n\t\tPartial<Record<StreamEventKind, Readonly<Record<string, unknown>>>>\n\t>;\n}\n\nexport interface PluginDescription {\n\treadonly schema_version: 1;\n\treadonly id: string;\n\treadonly title: string;\n\treadonly actions: readonly ActionDescription[];\n\t/** Declared streams; a description from a host that predates them is empty. */\n\treadonly streams: readonly StreamDescription[];\n}\n\n/**\n * Return whether `value` is a finite integer within the JavaScript-safe wire range.\n */\nexport function isSafeJsonInteger(value: unknown): value is number {\n\treturn typeof value === \"number\" && Number.isSafeInteger(value);\n}\n\n/**\n * A declaration cannot be represented or parsed in the versioned contract.\n */\nexport class QgisSdkDeclarationError extends QgisSdkError {\n\tpublic constructor(message: string) {\n\t\tsuper(message, \"invalid_declaration\");\n\t}\n}\n\n/**\n * Safe, structured location and category for a rejected contract value.\n */\nexport class QgisSdkValidationIssue {\n\tpublic readonly path: readonly (string | number)[];\n\tpublic readonly code: string;\n\n\tpublic constructor(path: readonly (string | number)[], code: string) {\n\t\tthis.path = Object.freeze([...path]);\n\t\tthis.code = code;\n\t}\n\n\tpublic toJSON(): SerializedValidationIssue {\n\t\treturn {\n\t\t\tpath: [...this.path],\n\t\t\tcode: this.code,\n\t\t};\n\t}\n}\n\n/**\n * A request or result did not satisfy its declared wire contract.\n */\nexport class QgisSdkContractValidationError extends QgisSdkError {\n\tpublic readonly direction: ValidationDirection;\n\tpublic readonly issues: readonly QgisSdkValidationIssue[];\n\n\tpublic constructor(\n\t\tdirection: ValidationDirection,\n\t\tissues: readonly QgisSdkValidationIssue[],\n\t) {\n\t\tconst prefix = direction === \"request\" ? \"Request\" : \"Result\";\n\t\tsuper(`${prefix} contract validation failed`, \"contract_validation_failed\");\n\t\tthis.direction = direction;\n\t\tthis.issues = Object.freeze([...issues]);\n\t}\n\n\tpublic toJSON(): SerializedContractValidationError {\n\t\treturn {\n\t\t\tcode: this.code,\n\t\t\tdirection: this.direction,\n\t\t\tissues: this.issues.map((issue) => issue.toJSON()),\n\t\t};\n\t}\n}\n\nconst DECLARATION_ID_PATTERN = /^[a-zA-Z][a-zA-Z0-9_.-]*$/;\nconst PYTHON_IDENTIFIER_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;\n\nfunction validateDeclarationId(value: unknown, label: string): string {\n\tif (typeof value !== \"string\" || !DECLARATION_ID_PATTERN.test(value)) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`Invalid ${label} id: expected [a-zA-Z][a-zA-Z0-9_.-]*`,\n\t\t);\n\t}\n\treturn value;\n}\n\nfunction validateNonBlankTitle(value: unknown, id: string): string {\n\tif (typeof value !== \"string\" || value.trim().length === 0) {\n\t\tthrow new QgisSdkDeclarationError(`${id}: title must be a nonempty string`);\n\t}\n\treturn value;\n}\n\nfunction parseOperationHead(\n\traw: unknown,\n\tlabel: string,\n): {\n\treadonly raw: Record<string, unknown>;\n\treadonly id: string;\n\treadonly title: string;\n\treadonly handler: string;\n\treadonly request: Readonly<Record<string, unknown>>;\n} {\n\tif (!isPlainRecord(raw)) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${label[0]?.toUpperCase()}${label.slice(1)} description must be an object`,\n\t\t);\n\t}\n\tconst id = validateDeclarationId(raw.id, label);\n\tconst title = validateNonBlankTitle(raw.title, id);\n\tif (\n\t\ttypeof raw.handler !== \"string\" ||\n\t\t!PYTHON_IDENTIFIER_PATTERN.test(raw.handler)\n\t) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${id}: handler must be a valid Python identifier`,\n\t\t);\n\t}\n\tif (!isPlainRecord(raw.request)) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${id}: request schema must be an object`,\n\t\t);\n\t}\n\treturn {\n\t\traw,\n\t\tid,\n\t\ttitle,\n\t\thandler: raw.handler,\n\t\trequest: Object.freeze({ ...raw.request }),\n\t};\n}\n\nfunction parseActionDescription(raw: unknown): ActionDescription {\n\tconst head = parseOperationHead(raw, \"action\");\n\tif (!isPlainRecord(head.raw.result)) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${head.id}: result schema must be an object`,\n\t\t);\n\t}\n\treturn Object.freeze({\n\t\tid: head.id,\n\t\ttitle: head.title,\n\t\thandler: head.handler,\n\t\trequest: head.request,\n\t\tresult: Object.freeze({ ...head.raw.result }),\n\t});\n}\n\nfunction parseStreamDescription(raw: unknown): StreamDescription {\n\tconst head = parseOperationHead(raw, \"stream\");\n\tconst declared = head.raw.events;\n\tif (!isPlainRecord(declared) || Object.keys(declared).length === 0) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${head.id}: events must map at least one event kind to a schema`,\n\t\t);\n\t}\n\tconst events: Partial<\n\t\tRecord<StreamEventKind, Readonly<Record<string, unknown>>>\n\t> = {};\n\tfor (const [kind, schema] of Object.entries(declared)) {\n\t\tif (!STREAM_EVENT_KINDS.includes(kind as StreamEventKind)) {\n\t\t\tthrow new QgisSdkDeclarationError(\n\t\t\t\t`${head.id}: ${kind} is not a stream event kind`,\n\t\t\t);\n\t\t}\n\t\tif (!isPlainRecord(schema)) {\n\t\t\tthrow new QgisSdkDeclarationError(\n\t\t\t\t`${head.id}: events.${kind} schema must be an object`,\n\t\t\t);\n\t\t}\n\t\tevents[kind as StreamEventKind] = Object.freeze({ ...schema });\n\t}\n\treturn Object.freeze({\n\t\tid: head.id,\n\t\ttitle: head.title,\n\t\thandler: head.handler,\n\t\trequest: head.request,\n\t\tevents: Object.freeze(events),\n\t});\n}\n\n/**\n * Parse and validate a version 1 `PluginDescription` emitted by `describe_plugin`.\n */\nexport function parsePluginDescription(\n\tinput: string | Readonly<Record<string, unknown>>,\n): PluginDescription {\n\tlet parsed: unknown = input;\n\tif (typeof input === \"string\") {\n\t\ttry {\n\t\t\tparsed = JSON.parse(input);\n\t\t} catch {\n\t\t\tthrow new QgisSdkDeclarationError(\"Plugin description is not valid JSON\");\n\t\t}\n\t}\n\tif (!isPlainRecord(parsed)) {\n\t\tthrow new QgisSdkDeclarationError(\"Plugin description must be an object\");\n\t}\n\tif (parsed.schema_version !== PLUGIN_DESCRIPTION_SCHEMA_VERSION) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`Unsupported plugin description schema_version: ${String(parsed.schema_version)}`,\n\t\t);\n\t}\n\tconst id = validateDeclarationId(parsed.id, \"plugin\");\n\tconst title = validateNonBlankTitle(parsed.title, id);\n\tif (!Array.isArray(parsed.actions)) {\n\t\tthrow new QgisSdkDeclarationError(`${id}: actions must be an array`);\n\t}\n\tconst declaredStreams = parsed.streams ?? [];\n\tif (!Array.isArray(declaredStreams)) {\n\t\tthrow new QgisSdkDeclarationError(`${id}: streams must be an array`);\n\t}\n\t// Actions and streams share one id namespace (decision-28).\n\tconst seenIds = new Set<string>();\n\tconst claim = (operationId: string, label: string): void => {\n\t\tif (seenIds.has(operationId)) {\n\t\t\tthrow new QgisSdkDeclarationError(\n\t\t\t\t`${id}: duplicate ${label} id ${operationId}`,\n\t\t\t);\n\t\t}\n\t\tseenIds.add(operationId);\n\t};\n\tconst actions: ActionDescription[] = [];\n\tfor (const item of parsed.actions) {\n\t\tconst action = parseActionDescription(item);\n\t\tclaim(action.id, \"action\");\n\t\tactions.push(action);\n\t}\n\tconst streams: StreamDescription[] = [];\n\tfor (const item of declaredStreams) {\n\t\tconst stream = parseStreamDescription(item);\n\t\tclaim(stream.id, \"stream\");\n\t\tstreams.push(stream);\n\t}\n\tconst byId = (\n\t\tleft: { readonly id: string },\n\t\tright: { readonly id: string },\n\t): number => (left.id < right.id ? -1 : 1);\n\tactions.sort(byId);\n\tstreams.sort(byId);\n\treturn Object.freeze({\n\t\tschema_version: PLUGIN_DESCRIPTION_SCHEMA_VERSION,\n\t\tid,\n\t\ttitle,\n\t\tactions: Object.freeze(actions),\n\t\tstreams: Object.freeze(streams),\n\t});\n}\n",
    "/**\n * Validate a value against the schema subset `describe_plugin` emits.\n *\n * This is the TypeScript side of `qgis_sdk.bridge.schema`: the same closed\n * dialect (objects with `properties`/`required`/`additionalProperties`, arrays\n * with `items`, the five JSON primitives, `anyOf` and `enum`, the integer\n * bounds and `pattern`) checked the same way, so `QgisSdk` refuses on the page\n * exactly what the host would refuse a message later. Anything outside the\n * dialect is a declaration fault and throws; a value that does not fit is an\n * issue the caller reports.\n *\n * The two asymmetries of decision-22 hold here too: a request is checked\n * strictly (an unknown property is an issue when the schema closes the\n * object), a result or an event leniently (`allowUnknown`), so a host may add\n * a field without breaking an older page while a missing or mistyped field is\n * still caught.\n */\n\nimport {\n\tQgisSdkDeclarationError,\n\tQgisSdkValidationIssue,\n\ttype SerializedValidationIssue,\n} from \"./declarations\";\nimport { QgisSdkError } from \"./errors\";\nimport { isPlainRecord } from \"./internal\";\n\n/** One schema of the declared dialect, as the description carries it. */\nexport type DeclaredSchema = Readonly<Record<string, unknown>>;\n\n/** Options for {@link validateAgainstSchema}. */\nexport interface ValidateOptions {\n\t/** Ignore properties the schema does not name (results and events). */\n\treadonly allowUnknown?: boolean;\n\t/** Where the value sits, prefixed to every issue's path. */\n\treadonly path?: readonly (string | number)[];\n}\n\n/** Which side of a call a contract issue belongs to. */\nexport type ContractDirection = \"request\" | \"result\" | \"event\";\n\n/** The JSON form of {@link QgisSdkContractError}. */\nexport interface SerializedContractError {\n\treadonly code: string;\n\treadonly operation: string;\n\treadonly direction: ContractDirection;\n\treadonly issues: SerializedValidationIssue[];\n}\n\n/**\n * An argument, a reply or an event does not match the declared contract.\n *\n * The code is the one both languages use for this category, so a page that\n * already matches `contract_validation_failed` needs no second branch.\n */\nexport class QgisSdkContractError extends QgisSdkError {\n\tpublic readonly operation: string;\n\tpublic readonly direction: ContractDirection;\n\tpublic readonly issues: readonly QgisSdkValidationIssue[];\n\n\tpublic constructor(\n\t\toperation: string,\n\t\tdirection: ContractDirection,\n\t\tissues: readonly QgisSdkValidationIssue[],\n\t) {\n\t\tconst detail = issues[0] === undefined ? \"\" : `: ${describe(issues[0])}`;\n\t\tsuper(\n\t\t\t`${operation}: the ${direction} does not match the declared contract${detail}`,\n\t\t\t\"contract_validation_failed\",\n\t\t);\n\t\tthis.operation = operation;\n\t\tthis.direction = direction;\n\t\tthis.issues = Object.freeze([...issues]);\n\t}\n\n\tpublic toJSON(): SerializedContractError {\n\t\treturn {\n\t\t\tcode: this.code,\n\t\t\toperation: this.operation,\n\t\t\tdirection: this.direction,\n\t\t\tissues: this.issues.map((issue) => issue.toJSON()),\n\t\t};\n\t}\n}\n\nfunction describe(issue: QgisSdkValidationIssue): string {\n\tconst where = issue.path.length === 0 ? \"value\" : issue.path.join(\".\");\n\treturn `${where} ${issue.code}`;\n}\n\nconst PRIMITIVES: ReadonlySet<string> = new Set([\n\t\"string\",\n\t\"boolean\",\n\t\"integer\",\n\t\"number\",\n\t\"null\",\n\t\"array\",\n\t\"object\",\n]);\n\nconst KNOWN_KEYWORDS: ReadonlySet<string> = new Set([\n\t\"type\",\n\t\"properties\",\n\t\"required\",\n\t\"additionalProperties\",\n\t\"items\",\n\t\"anyOf\",\n\t\"enum\",\n\t\"minimum\",\n\t\"maximum\",\n\t\"pattern\",\n\t\"title\",\n\t\"description\",\n]);\n\ntype Path = readonly (string | number)[];\n\n/**\n * Return every issue `value` has against `schema`; an empty array is a match.\n *\n * Throws {@link QgisSdkDeclarationError} when `schema` leaves the declared\n * dialect, because that is a fault in the declaration, never in the value.\n */\nexport function validateAgainstSchema(\n\tvalue: unknown,\n\tschema: DeclaredSchema,\n\toptions: ValidateOptions = {},\n): QgisSdkValidationIssue[] {\n\tconst issues: QgisSdkValidationIssue[] = [];\n\tcheck(\n\t\tvalue,\n\t\tschema,\n\t\toptions.path ?? [],\n\t\toptions.allowUnknown === true,\n\t\tissues,\n\t);\n\treturn issues;\n}\n\nfunction check(\n\tvalue: unknown,\n\tschema: unknown,\n\tpath: Path,\n\tallowUnknown: boolean,\n\tissues: QgisSdkValidationIssue[],\n): void {\n\tif (!isPlainRecord(schema)) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${where(path)}: a schema must be an object`,\n\t\t);\n\t}\n\tconst unknown = Object.keys(schema).filter((key) => !KNOWN_KEYWORDS.has(key));\n\tif (unknown.length > 0) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${where(path)}: unsupported schema keyword(s) ${unknown.sort().join(\", \")}`,\n\t\t);\n\t}\n\tif (\"anyOf\" in schema) {\n\t\tconst branches = schema.anyOf;\n\t\tif (!Array.isArray(branches) || branches.length === 0) {\n\t\t\tthrow new QgisSdkDeclarationError(\n\t\t\t\t`${where(path)}: anyOf must be a nonempty list`,\n\t\t\t);\n\t\t}\n\t\tfor (const branch of branches) {\n\t\t\tconst attempt: QgisSdkValidationIssue[] = [];\n\t\t\tcheck(value, branch, path, allowUnknown, attempt);\n\t\t\tif (attempt.length === 0) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t\tissues.push(new QgisSdkValidationIssue([...path], \"any_of\"));\n\t\treturn;\n\t}\n\tif (\"enum\" in schema) {\n\t\tconst choices = schema.enum;\n\t\tif (!Array.isArray(choices)) {\n\t\t\tthrow new QgisSdkDeclarationError(`${where(path)}: enum must be a list`);\n\t\t}\n\t\tif (!choices.some((choice) => sameJson(choice, value))) {\n\t\t\tissues.push(new QgisSdkValidationIssue([...path], \"enum\"));\n\t\t}\n\t\treturn;\n\t}\n\tconst declared = schema.type;\n\tif (declared === undefined) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${where(path)}: a schema needs a type, anyOf or enum`,\n\t\t);\n\t}\n\tif (typeof declared !== \"string\" || !PRIMITIVES.has(declared)) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${where(path)}: unsupported type ${JSON.stringify(declared)}`,\n\t\t);\n\t}\n\tswitch (declared) {\n\t\tcase \"string\":\n\t\t\tcheckString(value, schema, path, issues);\n\t\t\treturn;\n\t\tcase \"boolean\":\n\t\t\tif (typeof value !== \"boolean\") {\n\t\t\t\tissues.push(new QgisSdkValidationIssue([...path], \"type\"));\n\t\t\t}\n\t\t\treturn;\n\t\tcase \"integer\":\n\t\t\tif (typeof value !== \"number\" || !Number.isInteger(value)) {\n\t\t\t\tissues.push(new QgisSdkValidationIssue([...path], \"type\"));\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tcheckBounds(value, schema, path, issues);\n\t\t\treturn;\n\t\tcase \"number\":\n\t\t\tif (typeof value !== \"number\") {\n\t\t\t\tissues.push(new QgisSdkValidationIssue([...path], \"type\"));\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (!Number.isFinite(value)) {\n\t\t\t\tissues.push(new QgisSdkValidationIssue([...path], \"not_finite\"));\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tcheckBounds(value, schema, path, issues);\n\t\t\treturn;\n\t\tcase \"null\":\n\t\t\tif (value !== null) {\n\t\t\t\tissues.push(new QgisSdkValidationIssue([...path], \"type\"));\n\t\t\t}\n\t\t\treturn;\n\t\tcase \"array\":\n\t\t\tcheckArray(value, schema, path, allowUnknown, issues);\n\t\t\treturn;\n\t\tdefault:\n\t\t\tcheckObject(value, schema, path, allowUnknown, issues);\n\t}\n}\n\nfunction checkString(\n\tvalue: unknown,\n\tschema: DeclaredSchema,\n\tpath: Path,\n\tissues: QgisSdkValidationIssue[],\n): void {\n\tif (typeof value !== \"string\") {\n\t\tissues.push(new QgisSdkValidationIssue([...path], \"type\"));\n\t\treturn;\n\t}\n\tconst pattern = schema.pattern;\n\tif (pattern === undefined || pattern === null) {\n\t\treturn;\n\t}\n\tif (typeof pattern !== \"string\") {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${where(path)}: pattern must be a string`,\n\t\t);\n\t}\n\tlet expression: RegExp;\n\ttry {\n\t\t// Python's re.fullmatch: the whole string, with the unicode flag the\n\t\t// declaration side already assumes.\n\t\texpression = new RegExp(`^(?:${pattern})$`, \"u\");\n\t} catch (error) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${where(path)}: pattern ${JSON.stringify(pattern)} is unusable: ${String(error)}`,\n\t\t);\n\t}\n\tif (!expression.test(value)) {\n\t\tissues.push(new QgisSdkValidationIssue([...path], \"pattern\"));\n\t}\n}\n\nfunction checkBounds(\n\tvalue: number,\n\tschema: DeclaredSchema,\n\tpath: Path,\n\tissues: QgisSdkValidationIssue[],\n): void {\n\tconst minimum = schema.minimum;\n\tif (typeof minimum === \"number\" && value < minimum) {\n\t\tissues.push(new QgisSdkValidationIssue([...path], \"minimum\"));\n\t}\n\tconst maximum = schema.maximum;\n\tif (typeof maximum === \"number\" && value > maximum) {\n\t\tissues.push(new QgisSdkValidationIssue([...path], \"maximum\"));\n\t}\n}\n\nfunction checkArray(\n\tvalue: unknown,\n\tschema: DeclaredSchema,\n\tpath: Path,\n\tallowUnknown: boolean,\n\tissues: QgisSdkValidationIssue[],\n): void {\n\tif (!Array.isArray(value)) {\n\t\tissues.push(new QgisSdkValidationIssue([...path], \"type\"));\n\t\treturn;\n\t}\n\tconst items = schema.items;\n\tif (items === undefined || items === null) {\n\t\treturn;\n\t}\n\tvalue.forEach((item, index) => {\n\t\tcheck(item, items, [...path, index], allowUnknown, issues);\n\t});\n}\n\nfunction checkObject(\n\tvalue: unknown,\n\tschema: DeclaredSchema,\n\tpath: Path,\n\tallowUnknown: boolean,\n\tissues: QgisSdkValidationIssue[],\n): void {\n\tif (!isPlainRecord(value)) {\n\t\tissues.push(new QgisSdkValidationIssue([...path], \"type\"));\n\t\treturn;\n\t}\n\tconst properties = schema.properties ?? {};\n\tif (!isPlainRecord(properties)) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${where(path)}: properties must be an object`,\n\t\t);\n\t}\n\tconst required = schema.required ?? [];\n\tif (!Array.isArray(required)) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${where(path)}: required must be a list`,\n\t\t);\n\t}\n\tfor (const key of required) {\n\t\tif (typeof key === \"string\" && !(key in value)) {\n\t\t\tissues.push(new QgisSdkValidationIssue([...path, key], \"required\"));\n\t\t}\n\t}\n\tconst strict = schema.additionalProperties === false && !allowUnknown;\n\tfor (const [key, item] of Object.entries(value)) {\n\t\tif (Object.hasOwn(properties, key)) {\n\t\t\tcheck(item, properties[key], [...path, key], allowUnknown, issues);\n\t\t} else if (strict) {\n\t\t\tissues.push(\n\t\t\t\tnew QgisSdkValidationIssue([...path, key], \"unknown_property\"),\n\t\t\t);\n\t\t}\n\t}\n}\n\n/** JSON equality: `true` is not `1`, and `1` is `1.0`. */\nfunction sameJson(a: unknown, b: unknown): boolean {\n\tif (a === b) {\n\t\treturn true;\n\t}\n\tif (typeof a !== typeof b || a === null || b === null) {\n\t\treturn false;\n\t}\n\tif (Array.isArray(a)) {\n\t\treturn (\n\t\t\tArray.isArray(b) &&\n\t\t\ta.length === b.length &&\n\t\t\ta.every((item, index) => sameJson(item, b[index]))\n\t\t);\n\t}\n\tif (isPlainRecord(a) && isPlainRecord(b)) {\n\t\tconst keys = Object.keys(a);\n\t\treturn (\n\t\t\tkeys.length === Object.keys(b).length &&\n\t\t\tkeys.every((key) => Object.hasOwn(b, key) && sameJson(a[key], b[key]))\n\t\t);\n\t}\n\treturn false;\n}\n\nfunction where(path: Path): string {\n\treturn path.length === 0 ? \"value\" : path.join(\".\");\n}\n",
    "/**\n * The default transport: Qt's WebChannel, as a QGIS web view injects it.\n *\n * QGIS registers one object on the channel (the example names it \"bridge\";\n * see `create_channel_object` in the Python runtime). Its `receive` slot takes\n * a JSON envelope and its `message` signal carries every reply and stream\n * frame back. The channel becomes ready on a later turn, so this transport\n * is lazy: a `QgisSdk` built in the first statement of a page can send at\n * once, and what it sent is delivered when the channel reports ready.\n *\n * This is the one module of the root entry point that reads a browser global,\n * and it only does so when called: importing it touches nothing, and a page\n * that is not inside QGIS gets a synchronous, named refusal instead of a hang.\n */\n\nimport type { WireTransport } from \"./bridge\";\nimport { QgisSdkError } from \"./errors\";\n\ninterface ChannelObject {\n\treceive(text: string): void;\n\treadonly message: {\n\t\tconnect(listener: (text: string) => void): void;\n\t\tdisconnect(listener: (text: string) => void): void;\n\t};\n}\n\ninterface Channel {\n\treadonly objects: Readonly<Record<string, ChannelObject | undefined>>;\n}\n\ninterface QtScope {\n\treadonly qt?: { readonly webChannelTransport: unknown };\n\treadonly QWebChannel?: new (\n\t\ttransport: unknown,\n\t\tready: (channel: Channel) => void,\n\t) => unknown;\n}\n\n/** The web view did not provide a usable channel. */\nexport class QgisSdkWebChannelError extends QgisSdkError {\n\tpublic constructor(message: string) {\n\t\tsuper(message, \"no_web_channel\");\n\t}\n}\n\n/** The transport {@link createWebChannelTransport} returns. */\nexport interface WebChannelTransport extends WireTransport {\n\t/** Resolves once the channel object answered; rejects when it never will. */\n\treadonly ready: Promise<void>;\n\t/** Stop forwarding messages; sends after this throw. */\n\tclose(): void;\n}\n\nfunction scope(): QtScope {\n\treturn globalThis as unknown as QtScope;\n}\n\n/** True inside a QGIS web view, where Qt injected its transport and script. */\nexport function insideQgis(): boolean {\n\tconst page = scope();\n\treturn page.qt !== undefined && typeof page.QWebChannel === \"function\";\n}\n\n/**\n * Connect to the channel object `objectName` and return a transport on it.\n *\n * Throws {@link QgisSdkWebChannelError} synchronously outside a QGIS web view,\n * so a page learns in its first statement that it has no host to talk to.\n * Inside one, messages sent before the channel is ready are queued and\n * delivered in order once it is; `ready` rejects (and queued sends are\n * dropped) when the host registered no object under that name.\n */\nexport function createWebChannelTransport(\n\tobjectName = \"bridge\",\n): WebChannelTransport {\n\tconst page = scope();\n\tconst qt = page.qt;\n\tconst QWebChannel = page.QWebChannel;\n\tif (qt === undefined || typeof QWebChannel !== \"function\") {\n\t\tthrow new QgisSdkWebChannelError(\n\t\t\t\"not inside a QGIS web view: window.qt is missing\",\n\t\t);\n\t}\n\tconst listeners = new Set<(message: unknown) => void>();\n\tconst queue: string[] = [];\n\tlet object: ChannelObject | null = null;\n\tlet failure: QgisSdkWebChannelError | null = null;\n\tlet closed = false;\n\tconst forward = (text: string): void => {\n\t\tif (closed) {\n\t\t\treturn;\n\t\t}\n\t\tlet parsed: unknown;\n\t\ttry {\n\t\t\tparsed = JSON.parse(text);\n\t\t} catch {\n\t\t\treturn;\n\t\t}\n\t\tfor (const listener of [...listeners]) {\n\t\t\tlistener(parsed);\n\t\t}\n\t};\n\tconst ready = new Promise<void>((resolve, reject) => {\n\t\tnew QWebChannel(qt.webChannelTransport, (channel) => {\n\t\t\tconst found = channel.objects[objectName];\n\t\t\tif (found === undefined) {\n\t\t\t\tfailure = new QgisSdkWebChannelError(\n\t\t\t\t\t`the host registered no ${JSON.stringify(objectName)} channel object`,\n\t\t\t\t);\n\t\t\t\tqueue.length = 0;\n\t\t\t\treject(failure);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (closed) {\n\t\t\t\tresolve();\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tobject = found;\n\t\t\tfound.message.connect(forward);\n\t\t\tfor (const text of queue.splice(0)) {\n\t\t\t\tfound.receive(text);\n\t\t\t}\n\t\t\tresolve();\n\t\t});\n\t});\n\treturn {\n\t\tready,\n\t\tsend(message: unknown): void {\n\t\t\tif (closed) {\n\t\t\t\tthrow new QgisSdkWebChannelError(\"the web channel transport is closed\");\n\t\t\t}\n\t\t\tif (failure !== null) {\n\t\t\t\tthrow failure;\n\t\t\t}\n\t\t\tconst text = JSON.stringify(message);\n\t\t\tif (object === null) {\n\t\t\t\tqueue.push(text);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tobject.receive(text);\n\t\t},\n\t\tsubscribe(listener: (message: unknown) => void): () => void {\n\t\t\tlisteners.add(listener);\n\t\t\treturn () => {\n\t\t\t\tlisteners.delete(listener);\n\t\t\t};\n\t\t},\n\t\tclose(): void {\n\t\t\tif (closed) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tclosed = true;\n\t\t\tqueue.length = 0;\n\t\t\tlisteners.clear();\n\t\t\tobject?.message.disconnect(forward);\n\t\t},\n\t};\n}\n",
    "/**\n * `QgisSdk`: the page-side object a plugin's web view talks to QGIS through.\n *\n * Three statements connect a page (decision-44):\n *\n * ```ts\n * import schema from \"./bridge.schema\";\n * const qgis = QgisSdk.fromBridgeSchema(schema);\n * await qgis.sites.summary({ layer_id });\n * ```\n *\n * The schema is the generated `bridge.schema.ts`: the plugin description plus\n * its `Operations` and `Streams` types. From the description the SDK builds\n * one method per declared action and stream, nested under the segments of its\n * id (`sites.summary` is `qgis.sites.summary`, `buffer` is `qgis.buffer`),\n * and checks every argument, reply and event against the declared schemas\n * with the same rules the host applies (`validate.ts`). From the types it gives those\n * methods their signatures, so a wrong argument shape or an unknown operation\n * is a compile error and a value outside the schema at run time is a\n * {@link QgisSdkContractError}.\n *\n * `host` is the curated host surface of decision-27, built on the same client,\n * plus `granted`: the host operation ids the handshake advertised for this\n * view. A call outside the grants is not refused here - the host refuses it,\n * and the page sees the host's `not_authorized` - but a page can read `granted`\n * after `ready` to hide what it may not use.\n */\n\nimport {\n\tBridgeClient,\n\ttype BridgeStreamTerminal,\n\ttype BridgeSubscription,\n\ttype InvokeOptions,\n\tQgisSdkBridgeProtocolError,\n\ttype WireTransport,\n} from \"./bridge\";\nimport {\n\ttype ActionDescription,\n\tQgisSdkDeclarationError,\n\ttype StreamDescription,\n} from \"./declarations\";\nimport {\n\tcreateHost,\n\tHOST_OPERATIONS,\n\ttype HostOperationId,\n\ttype HostOperations,\n} from \"./generated/host\";\nimport { isPlainRecord } from \"./internal\";\nimport type {\n\tBridgeSchema,\n\tOperationMap,\n\tOperationShape,\n\tStreamMap,\n\tStreamShape,\n} from \"./schema\";\nimport { QgisSdkContractError, validateAgainstSchema } from \"./validate\";\nimport { createWebChannelTransport } from \"./webchannel\";\n\n/** Options for {@link QgisSdk.fromBridgeSchema}. */\nexport interface QgisSdkOptions {\n\t/** A transport to speak through; defaults to the page's QWebChannel. */\n\treadonly transport?: WireTransport;\n\t/** A client the caller owns; `close()` leaves it open. Excludes `transport`. */\n\treadonly client?: BridgeClient;\n\t/** Per-call timeout for an owned client. */\n\treadonly timeoutMs?: number;\n\t/** The channel object's name when the default transport is used. */\n\treadonly channelObject?: string;\n}\n\n/** Handlers for a typed stream: events as declared, then exactly one end. */\nexport interface StreamHandlers<E> {\n\treadonly onEvent?: (event: E) => void;\n\treadonly onTerminal?: (terminal: BridgeStreamTerminal) => void;\n}\n\n/** A live stream, as the caller holds it. */\nexport type StreamHandle = BridgeSubscription;\n\n/** The method one declared action becomes; an empty request may be omitted. */\nexport type OperationMethod<Op extends OperationShape> =\n\t// biome-ignore lint/complexity/noBannedTypes: `{}` is the test for \"nothing required\"\n\t{} extends Op[\"request\"]\n\t\t? (\n\t\t\t\trequest?: Op[\"request\"],\n\t\t\t\toptions?: InvokeOptions,\n\t\t\t) => Promise<Op[\"result\"]>\n\t\t: (\n\t\t\t\trequest: Op[\"request\"],\n\t\t\t\toptions?: InvokeOptions,\n\t\t\t) => Promise<Op[\"result\"]>;\n\n/** The method one declared stream becomes. */\nexport type StreamMethod<St extends StreamShape> = (\n\trequest: St[\"request\"],\n\thandlers: StreamHandlers<St[\"event\"]>,\n\toptions?: InvokeOptions,\n) => Promise<StreamHandle>;\n\n/** What the handshake told this page about the host (decision-27). */\nexport interface QgisSdkHost extends HostOperations {\n\t/**\n\t * The host operation ids the handshake advertised for this view; empty\n\t * until {@link QgisSdkCore.ready} has resolved.\n\t */\n\treadonly granted: readonly HostOperationId[];\n}\n\n/** The members every `QgisSdk` has, whatever its schema declares. */\nexport interface QgisSdkCore<O = OperationMap, S = StreamMap> {\n\t/** The schema this instance was built from. */\n\treadonly schema: BridgeSchema<O, S>;\n\t/** The client under the methods, for what a method does not cover. */\n\treadonly client: BridgeClient;\n\t/** The curated host surface, and what this view was granted of it. */\n\treadonly host: QgisSdkHost;\n\t/** Resolves once the handshake answered; rejects when the host refused it. */\n\treadonly ready: Promise<void>;\n\t/** Close an owned client; a client the caller passed in is left alone. */\n\tclose(): void;\n}\n\n/** The first segment of a dotted id, or the whole id when it has none. */\ntype Head<K extends string> = K extends `${infer H}.${string}` ? H : K;\n\n/** The members of `M` under one head, keyed by the rest of their ids. */\ntype Under<M, H extends string> = {\n\t[K in keyof M & string as K extends `${H}.${infer Rest}`\n\t\t? Rest\n\t\t: never]: M[K];\n};\n\n/**\n * The declared actions as a tree: a plain id is a method, a dotted id nests\n * one object per segment. An id that is both a leaf and a prefix of another\n * is refused at run time, so the type need not say what it would mean.\n */\nexport type OperationTree<O> = {\n\treadonly [H in Head<keyof O & string>]: H extends keyof O\n\t\t? O[H] extends OperationShape\n\t\t\t? OperationMethod<O[H]>\n\t\t\t: never\n\t\t: OperationTree<Under<O, H>>;\n};\n\n/** The declared streams as the same tree, with a stream method at each leaf. */\nexport type StreamTree<S> = {\n\treadonly [H in Head<keyof S & string>]: H extends keyof S\n\t\t? S[H] extends StreamShape\n\t\t\t? StreamMethod<S[H]>\n\t\t\t: never\n\t\t: StreamTree<Under<S, H>>;\n};\n\n/**\n * A page's handle on QGIS: the core, plus one method per declared operation\n * nested under the segments of its id.\n */\nexport type QgisSdk<O = OperationMap, S = StreamMap> = QgisSdkCore<O, S> &\n\tOperationTree<O> &\n\tStreamTree<S>;\n\n/** Names {@link QgisSdkCore} keeps; a declared id may not start with one. */\nexport const QGIS_SDK_MEMBERS: readonly string[] = Object.freeze([\n\t\"client\",\n\t\"host\",\n\t\"schema\",\n\t\"ready\",\n\t\"close\",\n]);\n\nconst HOST_IDS: ReadonlySet<string> = new Set<string>(HOST_OPERATIONS);\n\n/** The handshake, as far as this module reads it. */\ninterface Handshake {\n\treadonly operations: readonly string[];\n}\n\nfunction parseHandshake(value: unknown): Handshake {\n\tif (!isPlainRecord(value) || !Array.isArray(value.operations)) {\n\t\tthrow new QgisSdkBridgeProtocolError(\n\t\t\t\"The handshake reply carries no operations list\",\n\t\t);\n\t}\n\tconst operations: string[] = [];\n\tfor (const operation of value.operations) {\n\t\tif (isPlainRecord(operation) && typeof operation.id === \"string\") {\n\t\t\toperations.push(operation.id);\n\t\t}\n\t}\n\treturn { operations };\n}\n\nfunction unwrapRequest(\n\toperation: string,\n\trequest: unknown,\n): Record<string, unknown> {\n\tif (request === undefined) {\n\t\treturn {};\n\t}\n\tif (!isPlainRecord(request)) {\n\t\tthrow new QgisSdkContractError(operation, \"request\", [\n\t\t\t...validateAgainstSchema(request, { type: \"object\" }),\n\t\t]);\n\t}\n\treturn request;\n}\n\nfunction checkedRequest(\n\tdescription: ActionDescription | StreamDescription,\n\trequest: unknown,\n): Record<string, unknown> {\n\tconst payload = unwrapRequest(description.id, request);\n\tconst issues = validateAgainstSchema(payload, description.request);\n\tif (issues.length > 0) {\n\t\tthrow new QgisSdkContractError(description.id, \"request\", issues);\n\t}\n\treturn payload;\n}\n\nfunction operationMethod(\n\tclient: BridgeClient,\n\taction: ActionDescription,\n): (request?: unknown, options?: InvokeOptions) => Promise<unknown> {\n\treturn async (request, options) => {\n\t\tconst payload = checkedRequest(action, request);\n\t\tconst value = await client.invoke(action.id, payload, options);\n\t\tconst issues = validateAgainstSchema(value, action.result, {\n\t\t\tallowUnknown: true,\n\t\t});\n\t\tif (issues.length > 0) {\n\t\t\tthrow new QgisSdkContractError(action.id, \"result\", issues);\n\t\t}\n\t\treturn value;\n\t};\n}\n\nfunction streamMethod(\n\tclient: BridgeClient,\n\tstream: StreamDescription,\n): (\n\trequest: unknown,\n\thandlers: StreamHandlers<unknown>,\n\toptions?: InvokeOptions,\n) => Promise<StreamHandle> {\n\treturn async (request, handlers, options) => {\n\t\tconst payload = checkedRequest(stream, request);\n\t\t// The typed stream ends exactly once, like the subscription under it: a\n\t\t// contract violation ends it here, closes the subscription, and the\n\t\t// `disposed` the client then reports is not delivered a second time.\n\t\tlet ended = false;\n\t\tlet violated = false;\n\t\tlet handle: StreamHandle | null = null;\n\t\tconst end = (terminal: BridgeStreamTerminal): void => {\n\t\t\tif (ended) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tended = true;\n\t\t\thandlers.onTerminal?.(terminal);\n\t\t};\n\t\thandle = await client.subscribe(\n\t\t\tstream.id,\n\t\t\tpayload,\n\t\t\t{\n\t\t\t\tonEvent: (event) => {\n\t\t\t\t\tif (ended) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tconst declared = stream.events[event.kind];\n\t\t\t\t\tconst issues =\n\t\t\t\t\t\tdeclared === undefined\n\t\t\t\t\t\t\t? undefined\n\t\t\t\t\t\t\t: validateAgainstSchema(event.payload, declared, {\n\t\t\t\t\t\t\t\t\tallowUnknown: true,\n\t\t\t\t\t\t\t\t\tpath: [\"payload\"],\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\tif (issues !== undefined && issues.length === 0) {\n\t\t\t\t\t\thandlers.onEvent?.(event);\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tconst error = new QgisSdkContractError(\n\t\t\t\t\t\tstream.id,\n\t\t\t\t\t\t\"event\",\n\t\t\t\t\t\tissues ?? [],\n\t\t\t\t\t);\n\t\t\t\t\tend({ kind: \"error\", message: error.message });\n\t\t\t\t\tif (handle === null) {\n\t\t\t\t\t\tviolated = true;\n\t\t\t\t\t} else {\n\t\t\t\t\t\thandle.close();\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\tonTerminal: end,\n\t\t\t},\n\t\t\toptions,\n\t\t);\n\t\tif (violated) {\n\t\t\thandle.close();\n\t\t}\n\t\treturn handle;\n\t};\n}\n\nfunction buildHost(\n\tclient: BridgeClient,\n\tgranted: () => readonly HostOperationId[],\n): QgisSdkHost {\n\tconst host = createHost(client);\n\treturn Object.freeze({\n\t\t...host,\n\t\tget granted(): readonly HostOperationId[] {\n\t\t\treturn granted();\n\t\t},\n\t});\n}\n\nfunction build<O, S>(\n\tschema: BridgeSchema<O, S>,\n\toptions: QgisSdkOptions,\n): QgisSdk<O, S> {\n\tif (options.client !== undefined && options.transport !== undefined) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t\"QgisSdk.fromBridgeSchema takes a client or a transport, not both\",\n\t\t);\n\t}\n\tconst owned = options.client === undefined;\n\tconst transport =\n\t\toptions.transport ??\n\t\t(options.client === undefined\n\t\t\t? createWebChannelTransport(options.channelObject ?? \"bridge\")\n\t\t\t: undefined);\n\tconst client =\n\t\toptions.client ??\n\t\tnew BridgeClient(\n\t\t\ttransport as WireTransport,\n\t\t\toptions.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs },\n\t\t);\n\tlet granted: readonly HostOperationId[] = Object.freeze([]);\n\tconst ready = client.handshake().then((value) => {\n\t\tconst handshake = parseHandshake(value);\n\t\tgranted = Object.freeze(\n\t\t\thandshake.operations.filter((id): id is HostOperationId =>\n\t\t\t\tHOST_IDS.has(id),\n\t\t\t),\n\t\t);\n\t});\n\t// A page that never awaits `ready` still sees every call fail on its own;\n\t// the rejection is not left unobserved on top of that.\n\tready.catch(() => undefined);\n\tconst members: Record<string, unknown> = {\n\t\tschema,\n\t\tclient,\n\t\thost: buildHost(client, () => granted),\n\t\tready,\n\t\tclose: (): void => {\n\t\t\tif (owned) {\n\t\t\t\tclient.close();\n\t\t\t}\n\t\t},\n\t};\n\tconst namespaces: Record<string, unknown>[] = [];\n\tfor (const action of schema.actions) {\n\t\tplace(members, namespaces, action.id, operationMethod(client, action));\n\t}\n\tfor (const stream of schema.streams) {\n\t\tplace(members, namespaces, stream.id, streamMethod(client, stream));\n\t}\n\tfor (const namespace of namespaces) {\n\t\tObject.freeze(namespace);\n\t}\n\treturn Object.freeze(members) as unknown as QgisSdk<O, S>;\n}\n\n/**\n * Put one method where its id says: `a.b.c` becomes `members.a.b.c`, building\n * the objects on the way. Two ids cannot both be honest when one is a prefix\n * of the other - `sites` cannot be a method and hold `sites.summary` - and a\n * first segment that is a core member would hide it, so both are refused.\n */\nfunction place(\n\tmembers: Record<string, unknown>,\n\tnamespaces: Record<string, unknown>[],\n\tid: string,\n\tmethod: unknown,\n): void {\n\tconst segments = id.split(\".\");\n\tif (segments.some((segment) => segment === \"\")) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${id}: an operation id may not have an empty segment`,\n\t\t);\n\t}\n\tconst head = segments[0] as string;\n\tif (QGIS_SDK_MEMBERS.includes(head)) {\n\t\tthrow new QgisSdkDeclarationError(\n\t\t\t`${id}: an operation id may not start with a QgisSdk member (${QGIS_SDK_MEMBERS.join(\", \")})`,\n\t\t);\n\t}\n\tlet node = members;\n\tfor (const [index, segment] of segments.entries()) {\n\t\tconst prefix = segments.slice(0, index + 1).join(\".\");\n\t\tconst existing = node[segment];\n\t\tif (index === segments.length - 1) {\n\t\t\tif (existing !== undefined) {\n\t\t\t\tthrow new QgisSdkDeclarationError(\n\t\t\t\t\ttypeof existing === \"function\"\n\t\t\t\t\t\t? `${id}: duplicate operation id`\n\t\t\t\t\t\t: `${id}: an operation id may not be a prefix of another declared id`,\n\t\t\t\t);\n\t\t\t}\n\t\t\tnode[segment] = method;\n\t\t\treturn;\n\t\t}\n\t\tif (existing === undefined) {\n\t\t\tconst namespace: Record<string, unknown> = {};\n\t\t\tnamespaces.push(namespace);\n\t\t\tnode[segment] = namespace;\n\t\t\tnode = namespace;\n\t\t} else if (typeof existing === \"function\") {\n\t\t\tthrow new QgisSdkDeclarationError(\n\t\t\t\t`${id}: ${prefix} is already an operation id; an id may not extend another`,\n\t\t\t);\n\t\t} else {\n\t\t\tnode = existing as Record<string, unknown>;\n\t\t}\n\t}\n}\n\n/**\n * The entry point: `QgisSdk.fromBridgeSchema(schema)`.\n *\n * A namespace rather than a constant so the value and the instance type share\n * one name through every declaration bundler.\n */\nexport namespace QgisSdk {\n\t/**\n\t * Build a `QgisSdk` on a generated schema.\n\t *\n\t * Without options it connects to the page's QWebChannel object named\n\t * \"bridge\", which is what the Python runtime registers; a test passes the\n\t * harness from `@archont561/qgis-sdk/testing` as `transport` instead.\n\t */\n\texport function fromBridgeSchema<\n\t\tO extends Record<keyof O, OperationShape>,\n\t\tS extends Record<keyof S, StreamShape>,\n\t>(schema: BridgeSchema<O, S>, options: QgisSdkOptions = {}): QgisSdk<O, S> {\n\t\treturn build(schema, options);\n\t}\n}\n",
    "/**\n * The bridge schema: a plugin description that also carries its types.\n *\n * `qgis-sdk bridge generate` writes one `bridge.schema.ts` per plugin\n * (decision-44). That module has no code of its own: it declares the value\n * interfaces, two maps - `Operations` and `Streams`, keyed by operation id -\n * and ends in `defineBridgeSchema<Operations, Streams>({ ...description })`.\n * The two type parameters never exist at run time; they ride on the returned\n * object so `QgisSdk.fromBridgeSchema(schema)` can infer them, and the\n * description itself is what the SDK validates against.\n */\n\nimport { type PluginDescription, parsePluginDescription } from \"./declarations\";\n\n/** What one declared action promises: an object in, a value out. */\nexport interface OperationShape {\n\treadonly request: object;\n\treadonly result: unknown;\n}\n\n/** What one declared stream promises: an object in, discriminated events out. */\nexport interface StreamShape {\n\treadonly request: object;\n\treadonly event: { readonly kind: string; readonly payload: unknown };\n}\n\n/** The default, untyped map: any id, any shape. */\nexport type OperationMap = { readonly [id: string]: OperationShape };\n\n/** The default, untyped map: any id, any shape. */\nexport type StreamMap = { readonly [id: string]: StreamShape };\n\n/**\n * A parsed plugin description carrying its `Operations` and `Streams` types.\n *\n * The `\"~types\"` member is compile-time only: it is never set, and a schema is\n * a frozen {@link PluginDescription} and nothing more at run time. It is a\n * string key, not a unique symbol, so the type stays structurally the same\n * across the package's entry points.\n */\nexport interface BridgeSchema<O = OperationMap, S = StreamMap>\n\textends PluginDescription {\n\treadonly \"~types\"?: {\n\t\treadonly operations: O;\n\t\treadonly streams: S;\n\t};\n}\n\n/** The `Operations` map a schema carries. */\nexport type OperationsOf<Schema> =\n\tSchema extends BridgeSchema<infer O, unknown> ? O : never;\n\n/** The `Streams` map a schema carries. */\nexport type StreamsOf<Schema> =\n\tSchema extends BridgeSchema<unknown, infer S> ? S : never;\n\n/**\n * Parse a description and type it; the generated module is the only caller.\n *\n * The description is checked the way any description is (`schema_version`,\n * ids, handlers, declared streams), so a hand-edited or stale module fails\n * here, at import, rather than on the first call.\n */\nexport function defineBridgeSchema<\n\tO extends Record<keyof O, OperationShape>,\n\tS extends Record<keyof S, StreamShape>,\n>(input: string | Readonly<Record<string, unknown>>): BridgeSchema<O, S> {\n\treturn parsePluginDescription(input) as BridgeSchema<O, S>;\n}\n"
  ],
  "mappings": "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",
  "debugId": "7555C93DA5D57B1A64756E2164756E21",
  "names": []
}