@archont561/qgis-sdk 0.5.0 → 0.6.0

package/dist/shared/chunk-72sjmz60.js

@@ -0,0 +1,902 @@
+import {
+  STREAM_EVENT_KINDS,
+  isPlainRecord,
+  QgisSdkBridgeAbortedError2
+} from "./chunk-xg5ntw1c.js";
+import {
+  QgisSdkError2
+} from "./chunk-2hwva3a3.js";
+
+// src/declarations.ts
+var MAX_SAFE_INTEGER2 = 9007199254740991;
+var MIN_SAFE_INTEGER2 = -9007199254740991;
+var PLUGIN_DESCRIPTION_SCHEMA_VERSION2 = 1;
+function isSafeJsonInteger2(value) {
+  return typeof value === "number" && Number.isSafeInteger(value);
+}
+
+class QgisSdkDeclarationError2 extends QgisSdkError2 {
+  constructor(message) {
+    super(message, "invalid_declaration");
+  }
+}
+
+class QgisSdkValidationIssue2 {
+  path;
+  code;
+  constructor(path, code) {
+    this.path = Object.freeze([...path]);
+    this.code = code;
+  }
+  toJSON() {
+    return {
+      path: [...this.path],
+      code: this.code
+    };
+  }
+}
+
+class QgisSdkContractValidationError2 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 QgisSdkDeclarationError2(`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 QgisSdkDeclarationError2(`${id}: title must be a nonempty string`);
+  }
+  return value;
+}
+function parseOperationHead(raw, label) {
+  if (!isPlainRecord(raw)) {
+    throw new QgisSdkDeclarationError2(`${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 QgisSdkDeclarationError2(`${id}: handler must be a valid Python identifier`);
+  }
+  if (!isPlainRecord(raw.request)) {
+    throw new QgisSdkDeclarationError2(`${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 QgisSdkDeclarationError2(`${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 QgisSdkDeclarationError2(`${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 QgisSdkDeclarationError2(`${head.id}: ${kind} is not a stream event kind`);
+    }
+    if (!isPlainRecord(schema)) {
+      throw new QgisSdkDeclarationError2(`${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 parsePluginDescription2(input) {
+  let parsed = input;
+  if (typeof input === "string") {
+    try {
+      parsed = JSON.parse(input);
+    } catch {
+      throw new QgisSdkDeclarationError2("Plugin description is not valid JSON");
+    }
+  }
+  if (!isPlainRecord(parsed)) {
+    throw new QgisSdkDeclarationError2("Plugin description must be an object");
+  }
+  if (parsed.schema_version !== PLUGIN_DESCRIPTION_SCHEMA_VERSION2) {
+    throw new QgisSdkDeclarationError2(`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 QgisSdkDeclarationError2(`${id}: actions must be an array`);
+  }
+  const declaredStreams = parsed.streams ?? [];
+  if (!Array.isArray(declaredStreams)) {
+    throw new QgisSdkDeclarationError2(`${id}: streams must be an array`);
+  }
+  const seenIds = new Set;
+  const claim = (operationId, label) => {
+    if (seenIds.has(operationId)) {
+      throw new QgisSdkDeclarationError2(`${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_VERSION2,
+    id,
+    title,
+    actions: Object.freeze(actions),
+    streams: Object.freeze(streams)
+  });
+}
+
+// src/validate.ts
+class QgisSdkContractError2 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",
+  "x-qgis-sdk"
+]);
+function validateAgainstSchema2(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 QgisSdkDeclarationError2(`${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 QgisSdkDeclarationError2(`${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 QgisSdkDeclarationError2(`${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 QgisSdkValidationIssue2([...path], "any_of"));
+    return;
+  }
+  if ("enum" in schema) {
+    const choices = schema.enum;
+    if (!Array.isArray(choices)) {
+      throw new QgisSdkDeclarationError2(`${where(path)}: enum must be a list`);
+    }
+    if (!choices.some((choice) => sameJson(choice, value))) {
+      issues.push(new QgisSdkValidationIssue2([...path], "enum"));
+    }
+    return;
+  }
+  const declared = schema.type;
+  if (declared === undefined) {
+    throw new QgisSdkDeclarationError2(`${where(path)}: a schema needs a type, anyOf or enum`);
+  }
+  if (typeof declared !== "string" || !PRIMITIVES.has(declared)) {
+    throw new QgisSdkDeclarationError2(`${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 QgisSdkValidationIssue2([...path], "type"));
+      }
+      return;
+    case "integer":
+      if (typeof value !== "number" || !Number.isInteger(value)) {
+        issues.push(new QgisSdkValidationIssue2([...path], "type"));
+        return;
+      }
+      checkBounds(value, schema, path, issues);
+      return;
+    case "number":
+      if (typeof value !== "number") {
+        issues.push(new QgisSdkValidationIssue2([...path], "type"));
+        return;
+      }
+      if (!Number.isFinite(value)) {
+        issues.push(new QgisSdkValidationIssue2([...path], "not_finite"));
+        return;
+      }
+      checkBounds(value, schema, path, issues);
+      return;
+    case "null":
+      if (value !== null) {
+        issues.push(new QgisSdkValidationIssue2([...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 QgisSdkValidationIssue2([...path], "type"));
+    return;
+  }
+  const pattern = schema.pattern;
+  if (pattern === undefined || pattern === null) {
+    return;
+  }
+  if (typeof pattern !== "string") {
+    throw new QgisSdkDeclarationError2(`${where(path)}: pattern must be a string`);
+  }
+  let expression;
+  try {
+    expression = new RegExp(`^(?:${pattern})$`, "u");
+  } catch (error) {
+    throw new QgisSdkDeclarationError2(`${where(path)}: pattern ${JSON.stringify(pattern)} is unusable: ${String(error)}`);
+  }
+  if (!expression.test(value)) {
+    issues.push(new QgisSdkValidationIssue2([...path], "pattern"));
+  }
+}
+function checkBounds(value, schema, path, issues) {
+  const minimum = schema.minimum;
+  if (typeof minimum === "number" && value < minimum) {
+    issues.push(new QgisSdkValidationIssue2([...path], "minimum"));
+  }
+  const maximum = schema.maximum;
+  if (typeof maximum === "number" && value > maximum) {
+    issues.push(new QgisSdkValidationIssue2([...path], "maximum"));
+  }
+}
+function checkArray(value, schema, path, allowUnknown, issues) {
+  if (!Array.isArray(value)) {
+    issues.push(new QgisSdkValidationIssue2([...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 QgisSdkValidationIssue2([...path], "type"));
+    return;
+  }
+  const properties = schema.properties ?? {};
+  if (!isPlainRecord(properties)) {
+    throw new QgisSdkDeclarationError2(`${where(path)}: properties must be an object`);
+  }
+  const required = schema.required ?? [];
+  if (!Array.isArray(required)) {
+    throw new QgisSdkDeclarationError2(`${where(path)}: required must be a list`);
+  }
+  for (const key of required) {
+    if (typeof key === "string" && !(key in value)) {
+      issues.push(new QgisSdkValidationIssue2([...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 QgisSdkValidationIssue2([...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/stores/base.ts
+class QgisSdkStoreError2 extends QgisSdkError2 {
+  constructor(message) {
+    super(message, "store_binding");
+  }
+}
+
+class BaseStore {
+  snapshot;
+  listeners = new Set;
+  constructor(initial) {
+    this.snapshot = initial;
+  }
+  getSnapshot = () => this.snapshot;
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    listener(this.snapshot);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  publish(next) {
+    if (Object.is(next, this.snapshot)) {
+      return;
+    }
+    this.snapshot = next;
+    for (const listener of [...this.listeners]) {
+      listener(next);
+    }
+  }
+}
+function asError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+// src/stores/operation.ts
+var IDLE = Object.freeze({ status: "idle" });
+var PENDING = Object.freeze({ status: "pending" });
+
+class OperationStore2 extends BaseStore {
+  operation;
+  generation = 0;
+  controller = null;
+  constructor(operation) {
+    super(IDLE);
+    this.operation = operation;
+  }
+  abort = () => {
+    this.generation += 1;
+    this.controller?.abort();
+    this.controller = null;
+  };
+  reset = () => {
+    this.abort();
+    this.publish(IDLE);
+  };
+  run = async (input) => {
+    this.abort();
+    const mine = this.generation;
+    const controller = new AbortController;
+    this.controller = controller;
+    this.publish(PENDING);
+    try {
+      const value = await this.operation(input, { signal: controller.signal });
+      if (this.generation !== mine) {
+        return;
+      }
+      this.publish({ status: "ok", value });
+      return value;
+    } catch (error) {
+      if (this.generation !== mine || error instanceof QgisSdkBridgeAbortedError2) {
+        return;
+      }
+      this.publish({ status: "error", error: asError(error) });
+      return;
+    } finally {
+      if (this.controller === controller) {
+        this.controller = null;
+      }
+    }
+  };
+}
+
+// src/stores/form.ts
+var FIELD_KINDS = new Set([
+  "text",
+  "integer",
+  "number",
+  "boolean",
+  "choice",
+  "layer",
+  "crs",
+  "metres",
+  "file",
+  "directory",
+  "field",
+  "range",
+  "colour"
+]);
+var PRIMITIVE_KINDS = {
+  string: "text",
+  integer: "integer",
+  number: "number",
+  boolean: "boolean"
+};
+var NUMERIC_KINDS = new Set([
+  "integer",
+  "number",
+  "metres",
+  "range"
+]);
+var DETAIL_KEYS = ["minimum", "maximum", "step", "of", "filters", "alpha"];
+function labelFor2(name) {
+  const spaced = name.replace(/_/g, " ").trim();
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1).toLowerCase();
+}
+function concrete(schema) {
+  const branches = schema.anyOf;
+  if (!Array.isArray(branches)) {
+    return [schema, false];
+  }
+  const nonNull = branches.filter((branch) => isPlainRecord(branch) && branch.type !== "null");
+  if (nonNull.length === 1 && nonNull.length !== branches.length) {
+    return [nonNull[0], true];
+  }
+  throw new QgisSdkStoreError2("a union field must be one type or that type plus null to be rendered");
+}
+function kindFor(owner, name, schema) {
+  const intent = schema["x-qgis-sdk"];
+  const marked = isPlainRecord(intent) ? intent.kind : undefined;
+  if (typeof marked === "string") {
+    if (!FIELD_KINDS.has(marked)) {
+      throw new QgisSdkStoreError2(`${owner}: field ${name} has unknown kind ${JSON.stringify(marked)}`);
+    }
+    return marked;
+  }
+  if ("enum" in schema) {
+    return "choice";
+  }
+  const kind = PRIMITIVE_KINDS[String(schema.type)];
+  if (kind === undefined) {
+    throw new QgisSdkStoreError2(`${owner}: field ${name} has no input for its schema; declare a primitive, an enum or a kind`);
+  }
+  return kind;
+}
+function schemaFields2(schema, owner = "form") {
+  const properties = schema.properties;
+  if (!isPlainRecord(properties)) {
+    return Object.freeze([]);
+  }
+  const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+  return Object.freeze(Object.entries(properties).map(([name, property]) => {
+    if (!isPlainRecord(property)) {
+      throw new QgisSdkStoreError2(`${owner}: field ${name} is not a schema`);
+    }
+    const [shape, nullable] = concrete(property);
+    const kind = kindFor(owner, name, shape);
+    const intent = isPlainRecord(shape["x-qgis-sdk"]) ? shape["x-qgis-sdk"] : {};
+    const merged = { ...shape, ...intent };
+    const details = kind === "integer" ? {} : Object.fromEntries(DETAIL_KEYS.filter((key) => (key in merged)).map((key) => [
+      key,
+      merged[key]
+    ]));
+    return Object.freeze({
+      name,
+      label: labelFor2(name),
+      kind,
+      required: required.has(name) && !nullable,
+      nullable,
+      choices: Object.freeze(kind === "choice" && Array.isArray(shape.enum) ? [...shape.enum] : []),
+      details: Object.freeze(details),
+      schema: property
+    });
+  }));
+}
+function operationOf(qgis, id) {
+  let node = qgis;
+  for (const segment of id.split(".")) {
+    node = isPlainRecord(node) || typeof node === "function" ? node[segment] : undefined;
+  }
+  if (typeof node !== "function") {
+    throw new QgisSdkStoreError2(`${id} is not an operation of this QgisSdk`);
+  }
+  return node;
+}
+function coerce(field, value) {
+  if (value === "" && field.kind !== "text") {
+    return;
+  }
+  if (NUMERIC_KINDS.has(field.kind) && typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed !== "" && /^[-+]?(\d+\.?\d*|\.\d+)([eE][-+]?\d+)?$/.test(trimmed)) {
+      const number = Number(trimmed);
+      if (field.kind !== "integer" || Number.isInteger(number)) {
+        return number;
+      }
+    }
+  }
+  return value;
+}
+
+class FormStore2 extends BaseStore {
+  id;
+  title;
+  fields;
+  byName;
+  request;
+  initial;
+  operation;
+  unsubscribe;
+  constructor(qgis, id, options = {}) {
+    const action = qgis.schema.actions.find((candidate) => candidate.id === id);
+    if (action === undefined) {
+      throw new QgisSdkStoreError2(`${id} is not a declared action of this schema`);
+    }
+    const fields = schemaFields2(action.request, `form ${id}`);
+    const initial = FormStore2.defaults(options.initial ?? {});
+    super(FormStore2.evaluate(initial, action.request, false, false, IDLE));
+    this.id = id;
+    this.title = action.title;
+    this.fields = fields;
+    this.byName = new Map(fields.map((field) => [field.name, field]));
+    this.request = action.request;
+    this.initial = initial;
+    this.operation = new OperationStore2(operationOf(qgis, id));
+    let first = true;
+    this.unsubscribe = this.operation.subscribe((submission) => {
+      if (first) {
+        first = false;
+        return;
+      }
+      const current = this.getSnapshot();
+      this.publish({ ...current, submission });
+    });
+  }
+  static describe(qgis, id) {
+    return qgis.schema.actions.find((candidate) => candidate.id === id);
+  }
+  static defaults(initial) {
+    return Object.freeze(Object.fromEntries(Object.entries(initial).filter(([, value]) => value !== undefined)));
+  }
+  static evaluate(values, request, dirty, submitted, submission) {
+    const issues = validateAgainstSchema2(values, request);
+    const errors = {};
+    for (const issue of issues) {
+      const [head] = issue.path;
+      const name = typeof head === "string" ? head : "";
+      if (!(name in errors)) {
+        errors[name] = issue.code;
+      }
+    }
+    return Object.freeze({
+      values,
+      issues: Object.freeze(issues),
+      errors: Object.freeze(errors),
+      valid: issues.length === 0,
+      dirty,
+      submitted,
+      submission
+    });
+  }
+  set = (name, value) => {
+    this.setValues({ [name]: value });
+  };
+  setValues = (changes) => {
+    const current = this.getSnapshot();
+    const values = { ...current.values };
+    for (const [name, raw] of Object.entries(changes)) {
+      const field = this.byName.get(name);
+      if (field === undefined) {
+        throw new QgisSdkStoreError2(`${this.id} has no field ${name}`);
+      }
+      const value = coerce(field, raw);
+      if (value === undefined) {
+        delete values[name];
+      } else {
+        values[name] = value;
+      }
+    }
+    this.publish(FormStore2.evaluate(Object.freeze(values), this.request, true, current.submitted, current.submission));
+  };
+  field(name) {
+    const field = this.byName.get(name);
+    if (field === undefined) {
+      throw new QgisSdkStoreError2(`${this.id} has no field ${name}`);
+    }
+    return field;
+  }
+  reset = () => {
+    this.operation.reset();
+    this.publish(FormStore2.evaluate(this.initial, this.request, false, false, IDLE));
+  };
+  abort = () => {
+    this.operation.abort();
+  };
+  submit = async () => {
+    const current = this.getSnapshot();
+    if (!current.valid) {
+      this.publish({ ...current, submitted: true });
+      return;
+    }
+    if (!current.submitted) {
+      this.publish({ ...current, submitted: true });
+    }
+    return this.operation.run(current.values);
+  };
+  dispose() {
+    this.operation.abort();
+    this.unsubscribe();
+  }
+}
+function formStore2(qgis, id, options) {
+  return new FormStore2(qgis, id, options);
+}
+
+// src/stores/host-query.ts
+var IDLE_QUERY = Object.freeze({ status: "idle" });
+
+class HostQueryStore2 extends BaseStore {
+  qgis;
+  operation;
+  loader;
+  generation = 0;
+  controller = null;
+  constructor(qgis, operation, loader) {
+    super(IDLE_QUERY);
+    this.qgis = qgis;
+    this.operation = operation;
+    this.loader = loader;
+  }
+  abort = () => {
+    this.generation += 1;
+    this.controller?.abort();
+    this.controller = null;
+  };
+  reset = () => {
+    this.abort();
+    this.publish(IDLE_QUERY);
+  };
+  refresh = async () => {
+    this.abort();
+    const mine = this.generation;
+    const controller = new AbortController;
+    this.controller = controller;
+    this.publish({ status: "loading" });
+    try {
+      await this.qgis.ready;
+      if (this.generation !== mine) {
+        return;
+      }
+      if (!this.qgis.host.granted.includes(this.operation)) {
+        this.publish({
+          status: "refused",
+          operation: this.operation,
+          message: `this view was not granted ${this.operation}`
+        });
+        return;
+      }
+      const value = await this.loader(this.qgis.host, {
+        signal: controller.signal
+      });
+      if (this.generation !== mine) {
+        return;
+      }
+      this.publish({ status: "ok", value });
+      return value;
+    } catch (error) {
+      if (this.generation !== mine || error instanceof QgisSdkBridgeAbortedError2) {
+        return;
+      }
+      this.publish({ status: "error", error: asError(error) });
+      return;
+    } finally {
+      if (this.controller === controller) {
+        this.controller = null;
+      }
+    }
+  };
+}
+function layersQuery2(qgis, options = {}) {
+  return new HostQueryStore2(qgis, "layers.list", async (host, { signal }) => {
+    const items = [];
+    let cursor;
+    do {
+      const page = await host.layers.list({
+        ...cursor === undefined ? {} : { cursor },
+        ...options.pageSize === undefined ? {} : { limit: options.pageSize }
+      }, { signal });
+      items.push(...page.items);
+      cursor = page.next_cursor;
+    } while (cursor !== undefined);
+    return Object.freeze(items);
+  });
+}
+function layerFieldsQuery2(qgis, layerId) {
+  return new HostQueryStore2(qgis, "layers.get", async (host, { signal }) => {
+    const layer = await host.layers.get({ layer_id: layerId }, { signal });
+    return Object.freeze([...layer.field_names]);
+  });
+}
+
+// src/stores/stream.ts
+var IDLE_STREAM = Object.freeze({
+  status: "idle",
+  lastEvent: null,
+  terminal: null,
+  error: null
+});
+function stableKey2(value) {
+  return JSON.stringify(value, (_key, item) => isPlainRecord(item) ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) : item);
+}
+
+class StreamStore2 extends BaseStore {
+  open;
+  handlers;
+  key = null;
+  cancel = null;
+  constructor(open, handlers = {}) {
+    super(IDLE_STREAM);
+    this.open = open;
+    this.handlers = handlers;
+  }
+  setHandlers(handlers) {
+    this.handlers = handlers;
+  }
+  setInput = (input) => {
+    const key = input === null ? null : stableKey2(input);
+    if (key === this.key) {
+      return;
+    }
+    this.cancel?.();
+    this.cancel = null;
+    this.key = key;
+    if (input === null || key === null) {
+      this.publish(IDLE_STREAM);
+      return;
+    }
+    this.cancel = this.start(input);
+  };
+  close = () => {
+    this.setInput(null);
+  };
+  start(input) {
+    let cancelled = false;
+    let handle = null;
+    const update = (change) => {
+      if (!cancelled) {
+        this.publish(change(this.getSnapshot()));
+      }
+    };
+    this.publish({
+      status: "opening",
+      lastEvent: null,
+      terminal: null,
+      error: null
+    });
+    this.open(input, {
+      onEvent: (event) => {
+        if (cancelled) {
+          return;
+        }
+        this.handlers.onEvent?.(event);
+        update((previous) => ({ ...previous, lastEvent: event }));
+      },
+      onTerminal: (terminal) => {
+        if (cancelled) {
+          return;
+        }
+        this.handlers.onTerminal?.(terminal);
+        update((previous) => ({ ...previous, status: "ended", terminal }));
+      }
+    }).then((opened) => {
+      if (cancelled) {
+        opened.close();
+        return;
+      }
+      handle = opened;
+      update((previous) => previous.status === "ended" ? previous : { ...previous, status: "open" });
+    }, (error) => {
+      update(() => ({
+        status: "failed",
+        lastEvent: null,
+        terminal: null,
+        error: asError(error)
+      }));
+    });
+    return () => {
+      cancelled = true;
+      handle?.close();
+    };
+  }
+}
+export { MAX_SAFE_INTEGER2, MIN_SAFE_INTEGER2, PLUGIN_DESCRIPTION_SCHEMA_VERSION2, isSafeJsonInteger2, QgisSdkDeclarationError2, QgisSdkValidationIssue2, QgisSdkContractValidationError2, parsePluginDescription2, QgisSdkContractError2, validateAgainstSchema2, QgisSdkStoreError2, OperationStore2, labelFor2, schemaFields2, FormStore2, formStore2, HostQueryStore2, layersQuery2, layerFieldsQuery2, stableKey2, StreamStore2 };
+
+//# debugId=DD645B0085B7656764756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/declarations.ts", "src/validate.ts", "src/stores/base.ts", "src/stores/operation.ts", "src/stores/form.ts", "src/stores/host-query.ts", "src/stores/stream.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(app).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(app)`.\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(app)` 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\t// The input kind a describer annotated (`{ kind: \"layer\" }`); forms and\n\t// pages read it, validation reads past it.\n\t\"x-qgis-sdk\",\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",
    "/** The store contract and the base every store extends (see `../stores.ts`). */\n\nimport { QgisSdkError } from \"../errors\";\n\n/** A store was built or driven outside the shape it needs. */\nexport class QgisSdkStoreError extends QgisSdkError {\n\tpublic constructor(message: string) {\n\t\tsuper(message, \"store_binding\");\n\t}\n}\n\n// ---------------------------------------------------------------------------\n// The contract\n// ---------------------------------------------------------------------------\n\n/** What a listener receives: the whole snapshot, never a diff. */\nexport type StoreListener<T> = (snapshot: T) => void;\n\n/**\n * The contract every store honours, and the one `useSyncExternalStore`,\n * Vue's `shallowRef` wiring and Svelte's `$store` all read.\n */\nexport interface Store<T> {\n\t/** The current value; the same object until the next change. Bound. */\n\treadonly getSnapshot: () => T;\n\t/**\n\t * Call `listener` now and after every change; the returned function\n\t * stops the calls. Bound. Svelte passes a second `invalidate` argument,\n\t * which is ignored.\n\t */\n\treadonly subscribe: (listener: StoreListener<T>) => () => void;\n}\n\nexport abstract class BaseStore<T> implements Store<T> {\n\tprivate snapshot: T;\n\tprivate readonly listeners = new Set<StoreListener<T>>();\n\n\tprotected constructor(initial: T) {\n\t\tthis.snapshot = initial;\n\t}\n\n\t// Bound, so `useSyncExternalStore(store.subscribe, store.getSnapshot)`\n\t// needs no wrapper.\n\tpublic readonly getSnapshot = (): T => this.snapshot;\n\n\tpublic readonly subscribe = (listener: StoreListener<T>): (() => void) => {\n\t\tthis.listeners.add(listener);\n\t\tlistener(this.snapshot);\n\t\treturn () => {\n\t\t\tthis.listeners.delete(listener);\n\t\t};\n\t};\n\n\tprotected publish(next: T): void {\n\t\tif (Object.is(next, this.snapshot)) {\n\t\t\treturn;\n\t\t}\n\t\tthis.snapshot = next;\n\t\tfor (const listener of [...this.listeners]) {\n\t\t\tlistener(next);\n\t\t}\n\t}\n}\n\nexport function asError(error: unknown): Error {\n\treturn error instanceof Error ? error : new Error(String(error));\n}\n",
    "/** {@link OperationStore}: one generated operation, latest run wins. */\n\nimport { QgisSdkBridgeAbortedError } from \"../bridge\";\nimport { asError, BaseStore } from \"./base\";\n\n// ---------------------------------------------------------------------------\n// OperationStore\n// ---------------------------------------------------------------------------\n\n/** Where one invocation stands. */\nexport type OperationState<R> =\n\t| { readonly status: \"idle\" }\n\t| { readonly status: \"pending\" }\n\t| { readonly status: \"ok\"; readonly value: R }\n\t| { readonly status: \"error\"; readonly error: Error };\n\n/** An operation member of a generated map: input, optional signal, promise. */\nexport type Operation<I, R> = (\n\tinput: I,\n\toptions?: { readonly signal?: AbortSignal },\n) => Promise<R>;\n\nexport const IDLE: OperationState<never> = Object.freeze({ status: \"idle\" });\nconst PENDING: OperationState<never> = Object.freeze({ status: \"pending\" });\n\n/**\n * Run one generated operation.\n *\n * `run` resolves with the value, or with `undefined` when the call failed,\n * was aborted or was superseded by a later run - the state carries the error,\n * so the promise never rejects into an event handler. Only the latest run can\n * change the state. `abort` ends the in-flight call locally (the host may\n * still run it); `reset` aborts and returns to `idle`. The methods are bound,\n * so they can be passed around without the store.\n */\nexport class OperationStore<I, R> extends BaseStore<OperationState<R>> {\n\tprivate generation = 0;\n\tprivate controller: AbortController | null = null;\n\n\tpublic constructor(private readonly operation: Operation<I, R>) {\n\t\tsuper(IDLE);\n\t}\n\n\tpublic readonly abort = (): void => {\n\t\tthis.generation += 1;\n\t\tthis.controller?.abort();\n\t\tthis.controller = null;\n\t};\n\n\tpublic readonly reset = (): void => {\n\t\tthis.abort();\n\t\tthis.publish(IDLE);\n\t};\n\n\tpublic readonly run = async (input: I): Promise<R | undefined> => {\n\t\tthis.abort();\n\t\tconst mine = this.generation;\n\t\tconst controller = new AbortController();\n\t\tthis.controller = controller;\n\t\tthis.publish(PENDING);\n\t\ttry {\n\t\t\tconst value = await this.operation(input, { signal: controller.signal });\n\t\t\tif (this.generation !== mine) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tthis.publish({ status: \"ok\", value });\n\t\t\treturn value;\n\t\t} catch (error) {\n\t\t\tif (\n\t\t\t\tthis.generation !== mine ||\n\t\t\t\terror instanceof QgisSdkBridgeAbortedError\n\t\t\t) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tthis.publish({ status: \"error\", error: asError(error) });\n\t\t\treturn undefined;\n\t\t} finally {\n\t\t\tif (this.controller === controller) {\n\t\t\t\tthis.controller = null;\n\t\t\t}\n\t\t}\n\t};\n}\n",
    "/** {@link FormStore}: one declared action's request bound to its schema. */\n\nimport type {\n\tActionDescription,\n\tQgisSdkValidationIssue,\n} from \"../declarations\";\nimport { isPlainRecord } from \"../internal\";\nimport type { QgisSdkCore } from \"../qgis-sdk\";\nimport type { OperationShape } from \"../schema\";\nimport { type DeclaredSchema, validateAgainstSchema } from \"../validate\";\nimport { BaseStore, QgisSdkStoreError } from \"./base\";\nimport {\n\tIDLE,\n\ttype Operation,\n\ttype OperationState,\n\tOperationStore,\n} from \"./operation\";\n\n// ---------------------------------------------------------------------------\n// FormStore\n// ---------------------------------------------------------------------------\n\n/**\n * The input families a declared request can ask for: the same names the\n * Python `qgis_sdk.ui` catalogue draws, so a form on either side of the\n * bridge renders one declaration the same way.\n */\nexport type FormFieldKind =\n\t| \"text\"\n\t| \"integer\"\n\t| \"number\"\n\t| \"boolean\"\n\t| \"choice\"\n\t| \"layer\"\n\t| \"crs\"\n\t| \"metres\"\n\t| \"file\"\n\t| \"directory\"\n\t| \"field\"\n\t| \"range\"\n\t| \"colour\";\n\nconst FIELD_KINDS: ReadonlySet<string> = new Set<FormFieldKind>([\n\t\"text\",\n\t\"integer\",\n\t\"number\",\n\t\"boolean\",\n\t\"choice\",\n\t\"layer\",\n\t\"crs\",\n\t\"metres\",\n\t\"file\",\n\t\"directory\",\n\t\"field\",\n\t\"range\",\n\t\"colour\",\n]);\nconst PRIMITIVE_KINDS: Readonly<Record<string, FormFieldKind>> = {\n\tstring: \"text\",\n\tinteger: \"integer\",\n\tnumber: \"number\",\n\tboolean: \"boolean\",\n};\nconst NUMERIC_KINDS: ReadonlySet<FormFieldKind> = new Set<FormFieldKind>([\n\t\"integer\",\n\t\"number\",\n\t\"metres\",\n\t\"range\",\n]);\nconst DETAIL_KEYS = [\"minimum\", \"maximum\", \"step\", \"of\", \"filters\", \"alpha\"];\n\n/** One input of a declared action, as a page should render it. */\nexport interface FormField {\n\treadonly name: string;\n\t/** `buffer_distance` -> `Buffer distance`. */\n\treadonly label: string;\n\treadonly kind: FormFieldKind;\n\treadonly required: boolean;\n\treadonly nullable: boolean;\n\t/** The `enum` of a `choice` field; empty otherwise. */\n\treadonly choices: readonly unknown[];\n\t/** Bounds, a parent input, picker filters: what the kind needs beyond a name. */\n\treadonly details: Readonly<Record<string, unknown>>;\n\t/** The property schema the value is validated against. */\n\treadonly schema: DeclaredSchema;\n}\n\n/** Render a field name as a label. */\nexport function labelFor(name: string): string {\n\tconst spaced = name.replace(/_/g, \" \").trim();\n\treturn spaced.charAt(0).toUpperCase() + spaced.slice(1).toLowerCase();\n}\n\nfunction concrete(schema: DeclaredSchema): [DeclaredSchema, boolean] {\n\tconst branches = schema.anyOf;\n\tif (!Array.isArray(branches)) {\n\t\treturn [schema, false];\n\t}\n\tconst nonNull = branches.filter(\n\t\t(branch): branch is DeclaredSchema =>\n\t\t\tisPlainRecord(branch) && branch.type !== \"null\",\n\t);\n\tif (nonNull.length === 1 && nonNull.length !== branches.length) {\n\t\treturn [nonNull[0] as DeclaredSchema, true];\n\t}\n\tthrow new QgisSdkStoreError(\n\t\t\"a union field must be one type or that type plus null to be rendered\",\n\t);\n}\n\nfunction kindFor(\n\towner: string,\n\tname: string,\n\tschema: DeclaredSchema,\n): FormFieldKind {\n\tconst intent = schema[\"x-qgis-sdk\"];\n\tconst marked = isPlainRecord(intent) ? intent.kind : undefined;\n\tif (typeof marked === \"string\") {\n\t\tif (!FIELD_KINDS.has(marked)) {\n\t\t\tthrow new QgisSdkStoreError(\n\t\t\t\t`${owner}: field ${name} has unknown kind ${JSON.stringify(marked)}`,\n\t\t\t);\n\t\t}\n\t\treturn marked as FormFieldKind;\n\t}\n\tif (\"enum\" in schema) {\n\t\treturn \"choice\";\n\t}\n\tconst kind = PRIMITIVE_KINDS[String(schema.type)];\n\tif (kind === undefined) {\n\t\tthrow new QgisSdkStoreError(\n\t\t\t`${owner}: field ${name} has no input for its schema; declare a primitive, an enum or a kind`,\n\t\t);\n\t}\n\treturn kind;\n}\n\n/**\n * The fields of a declared request schema, in declaration order: the\n * TypeScript twin of `qgis_sdk.ui.schema_fields`.\n */\nexport function schemaFields(\n\tschema: DeclaredSchema,\n\towner = \"form\",\n): readonly FormField[] {\n\tconst properties = schema.properties;\n\tif (!isPlainRecord(properties)) {\n\t\treturn Object.freeze([]);\n\t}\n\tconst required = new Set(\n\t\tArray.isArray(schema.required) ? (schema.required as string[]) : [],\n\t);\n\treturn Object.freeze(\n\t\tObject.entries(properties).map(([name, property]) => {\n\t\t\tif (!isPlainRecord(property)) {\n\t\t\t\tthrow new QgisSdkStoreError(`${owner}: field ${name} is not a schema`);\n\t\t\t}\n\t\t\tconst [shape, nullable] = concrete(property);\n\t\t\tconst kind = kindFor(owner, name, shape);\n\t\t\tconst intent = isPlainRecord(shape[\"x-qgis-sdk\"])\n\t\t\t\t? shape[\"x-qgis-sdk\"]\n\t\t\t\t: {};\n\t\t\tconst merged: Record<string, unknown> = { ...shape, ...intent };\n\t\t\tconst details =\n\t\t\t\tkind === \"integer\"\n\t\t\t\t\t? {}\n\t\t\t\t\t: Object.fromEntries(\n\t\t\t\t\t\t\tDETAIL_KEYS.filter((key) => key in merged).map((key) => [\n\t\t\t\t\t\t\t\tkey,\n\t\t\t\t\t\t\t\tmerged[key],\n\t\t\t\t\t\t\t]),\n\t\t\t\t\t\t);\n\t\t\treturn Object.freeze({\n\t\t\t\tname,\n\t\t\t\tlabel: labelFor(name),\n\t\t\t\tkind,\n\t\t\t\trequired: required.has(name) && !nullable,\n\t\t\t\tnullable,\n\t\t\t\tchoices: Object.freeze(\n\t\t\t\t\tkind === \"choice\" && Array.isArray(shape.enum) ? [...shape.enum] : [],\n\t\t\t\t),\n\t\t\t\tdetails: Object.freeze(details),\n\t\t\t\tschema: property,\n\t\t\t});\n\t\t}),\n\t);\n}\n\n/** The values a form holds: one entry per field the user or the schema set. */\nexport type FormValues = Readonly<Record<string, unknown>>;\n\n/** Where one form stands. */\nexport interface FormState<R> {\n\treadonly values: FormValues;\n\t/** Every issue the current values have against the request schema. */\n\treadonly issues: readonly QgisSdkValidationIssue[];\n\t/** The first issue code per field name, for a label to show. */\n\treadonly errors: Readonly<Record<string, string>>;\n\treadonly valid: boolean;\n\t/** A value changed since construction or the last `reset`. */\n\treadonly dirty: boolean;\n\t/** `submit` was attempted since construction or the last `reset`. */\n\treadonly submitted: boolean;\n\t/** The latest submission, as an operation store reports it. */\n\treadonly submission: OperationState<R>;\n}\n\n/** Options for {@link FormStore}. */\nexport interface FormOptions {\n\t/** Values to start from; the declared dialect has no defaults of its own. */\n\treadonly initial?: FormValues;\n}\n\ntype RequestOf<O, K extends keyof O> = O[K] extends OperationShape\n\t? O[K][\"request\"]\n\t: never;\ntype ResultOf<O, K extends keyof O> = O[K] extends OperationShape\n\t? O[K][\"result\"]\n\t: never;\n\n/**\n * Walk `qgis` by the dotted id to the method a declared action became.\n */\nfunction operationOf<I, R>(\n\tqgis: QgisSdkCore<unknown, unknown>,\n\tid: string,\n): Operation<I, R> {\n\tlet node: unknown = qgis;\n\tfor (const segment of id.split(\".\")) {\n\t\tnode =\n\t\t\tisPlainRecord(node) || typeof node === \"function\"\n\t\t\t\t? (node as Record<string, unknown>)[segment]\n\t\t\t\t: undefined;\n\t}\n\tif (typeof node !== \"function\") {\n\t\tthrow new QgisSdkStoreError(`${id} is not an operation of this QgisSdk`);\n\t}\n\treturn node as Operation<I, R>;\n}\n\nfunction coerce(field: FormField, value: unknown): unknown {\n\tif (value === \"\" && field.kind !== \"text\") {\n\t\treturn undefined;\n\t}\n\tif (NUMERIC_KINDS.has(field.kind) && typeof value === \"string\") {\n\t\tconst trimmed = value.trim();\n\t\tif (\n\t\t\ttrimmed !== \"\" &&\n\t\t\t/^[-+]?(\\d+\\.?\\d*|\\.\\d+)([eE][-+]?\\d+)?$/.test(trimmed)\n\t\t) {\n\t\t\tconst number = Number(trimmed);\n\t\t\tif (field.kind !== \"integer\" || Number.isInteger(number)) {\n\t\t\t\treturn number;\n\t\t\t}\n\t\t}\n\t}\n\treturn value;\n}\n\n/**\n * Bind the request of one declared action to its schema.\n *\n * The fields come from the declaration, so a page renders `form.fields`\n * instead of guessing; `set` coerces what an `<input>` yields (`\"3\"` for a\n * numeric field, `\"\"` for an unset one) and re-validates; `submit` refuses\n * invalid values without a call and otherwise runs the operation through an\n * {@link OperationStore}, whose state is `submission`.\n */\nexport class FormStore<Req extends object, R> extends BaseStore<FormState<R>> {\n\tpublic readonly id: string;\n\tpublic readonly title: string;\n\tpublic readonly fields: readonly FormField[];\n\tprivate readonly byName: ReadonlyMap<string, FormField>;\n\tprivate readonly request: DeclaredSchema;\n\tprivate readonly initial: FormValues;\n\tprivate readonly operation: OperationStore<Req, R>;\n\tprivate readonly unsubscribe: () => void;\n\n\tpublic constructor(\n\t\tqgis: QgisSdkCore<unknown, unknown>,\n\t\tid: string,\n\t\toptions: FormOptions = {},\n\t) {\n\t\tconst action = qgis.schema.actions.find((candidate) => candidate.id === id);\n\t\tif (action === undefined) {\n\t\t\tthrow new QgisSdkStoreError(\n\t\t\t\t`${id} is not a declared action of this schema`,\n\t\t\t);\n\t\t}\n\t\tconst fields = schemaFields(action.request, `form ${id}`);\n\t\tconst initial = FormStore.defaults(options.initial ?? {});\n\t\tsuper(FormStore.evaluate(initial, action.request, false, false, IDLE));\n\t\tthis.id = id;\n\t\tthis.title = action.title;\n\t\tthis.fields = fields;\n\t\tthis.byName = new Map(fields.map((field) => [field.name, field]));\n\t\tthis.request = action.request;\n\t\tthis.initial = initial;\n\t\tthis.operation = new OperationStore(operationOf<Req, R>(qgis, id));\n\t\tlet first = true;\n\t\tthis.unsubscribe = this.operation.subscribe((submission) => {\n\t\t\tif (first) {\n\t\t\t\tfirst = false;\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tconst current = this.getSnapshot();\n\t\t\tthis.publish({ ...current, submission });\n\t\t});\n\t}\n\n\t/** The declaration the form was built from, for a page that renders more. */\n\tpublic static describe(\n\t\tqgis: QgisSdkCore<unknown, unknown>,\n\t\tid: string,\n\t): ActionDescription | undefined {\n\t\treturn qgis.schema.actions.find((candidate) => candidate.id === id);\n\t}\n\n\tprivate static defaults(initial: FormValues): FormValues {\n\t\t// The declared dialect carries no `default` keyword: what a form starts\n\t\t// from is the page's choice, and an unset required field is an issue\n\t\t// the page shows once `submitted` is true.\n\t\treturn Object.freeze(\n\t\t\tObject.fromEntries(\n\t\t\t\tObject.entries(initial).filter(([, value]) => value !== undefined),\n\t\t\t),\n\t\t);\n\t}\n\n\tprivate static evaluate<R>(\n\t\tvalues: FormValues,\n\t\trequest: DeclaredSchema,\n\t\tdirty: boolean,\n\t\tsubmitted: boolean,\n\t\tsubmission: OperationState<R>,\n\t): FormState<R> {\n\t\tconst issues = validateAgainstSchema(values, request);\n\t\tconst errors: Record<string, string> = {};\n\t\tfor (const issue of issues) {\n\t\t\tconst [head] = issue.path;\n\t\t\tconst name = typeof head === \"string\" ? head : \"\";\n\t\t\tif (!(name in errors)) {\n\t\t\t\terrors[name] = issue.code;\n\t\t\t}\n\t\t}\n\t\treturn Object.freeze({\n\t\t\tvalues,\n\t\t\tissues: Object.freeze(issues),\n\t\t\terrors: Object.freeze(errors),\n\t\t\tvalid: issues.length === 0,\n\t\t\tdirty,\n\t\t\tsubmitted,\n\t\t\tsubmission,\n\t\t});\n\t}\n\n\t/** Set one field; `undefined` unsets it. */\n\tpublic readonly set = (name: string, value: unknown): void => {\n\t\tthis.setValues({ [name]: value });\n\t};\n\n\t/** Set several fields at once. */\n\tpublic readonly setValues = (changes: FormValues): void => {\n\t\tconst current = this.getSnapshot();\n\t\tconst values: Record<string, unknown> = { ...current.values };\n\t\tfor (const [name, raw] of Object.entries(changes)) {\n\t\t\tconst field = this.byName.get(name);\n\t\t\tif (field === undefined) {\n\t\t\t\tthrow new QgisSdkStoreError(`${this.id} has no field ${name}`);\n\t\t\t}\n\t\t\tconst value = coerce(field, raw);\n\t\t\tif (value === undefined) {\n\t\t\t\tdelete values[name];\n\t\t\t} else {\n\t\t\t\tvalues[name] = value;\n\t\t\t}\n\t\t}\n\t\tthis.publish(\n\t\t\tFormStore.evaluate(\n\t\t\t\tObject.freeze(values),\n\t\t\t\tthis.request,\n\t\t\t\ttrue,\n\t\t\t\tcurrent.submitted,\n\t\t\t\tcurrent.submission,\n\t\t\t),\n\t\t);\n\t};\n\n\t/** The declared field, for a renderer working from a name. */\n\tpublic field(name: string): FormField {\n\t\tconst field = this.byName.get(name);\n\t\tif (field === undefined) {\n\t\t\tthrow new QgisSdkStoreError(`${this.id} has no field ${name}`);\n\t\t}\n\t\treturn field;\n\t}\n\n\t/** Back to the initial values and an idle submission; aborts a call in flight. */\n\tpublic readonly reset = (): void => {\n\t\tthis.operation.reset();\n\t\tthis.publish(\n\t\t\tFormStore.evaluate(this.initial, this.request, false, false, IDLE),\n\t\t);\n\t};\n\n\t/** Abort a submission in flight; the values stay. */\n\tpublic readonly abort = (): void => {\n\t\tthis.operation.abort();\n\t};\n\n\t/**\n\t * Validate, then run the action with the current values. Resolves with the\n\t * result, or `undefined` when the values are invalid (no call is made) or\n\t * the call failed, was aborted or superseded - `submission` says which.\n\t */\n\tpublic readonly submit = async (): Promise<R | undefined> => {\n\t\tconst current = this.getSnapshot();\n\t\tif (!current.valid) {\n\t\t\tthis.publish({ ...current, submitted: true });\n\t\t\treturn undefined;\n\t\t}\n\t\tif (!current.submitted) {\n\t\t\tthis.publish({ ...current, submitted: true });\n\t\t}\n\t\treturn this.operation.run(current.values as Req);\n\t};\n\n\t/** Stop following the submission; for an adapter tearing the form down. */\n\tpublic dispose(): void {\n\t\tthis.operation.abort();\n\t\tthis.unsubscribe();\n\t}\n}\n\n/**\n * The form for `qgis.<id>`, typed from the schema: the request names the\n * fields, the result types the submission.\n */\nexport function formStore<O, K extends keyof O & string>(\n\tqgis: QgisSdkCore<O, unknown>,\n\tid: K,\n\toptions?: FormOptions,\n): FormStore<RequestOf<O, K> & object, ResultOf<O, K>> {\n\treturn new FormStore(qgis as QgisSdkCore<unknown, unknown>, id, options);\n}\n",
    "/** {@link HostQueryStore}: reads of the curated host surface, refused before any call. */\n\nimport { QgisSdkBridgeAbortedError } from \"../bridge\";\nimport type {\n\tHostOperationId,\n\tLayerPage,\n\tVectorLayerInfo,\n} from \"../generated/host\";\nimport type { QgisSdkCore, QgisSdkHost } from \"../qgis-sdk\";\nimport { asError, BaseStore } from \"./base\";\n\n// ---------------------------------------------------------------------------\n// HostQueryStore\n// ---------------------------------------------------------------------------\n\n/** Where one host query stands. */\nexport type HostQueryState<T> =\n\t| { readonly status: \"idle\" }\n\t| { readonly status: \"loading\" }\n\t| { readonly status: \"ok\"; readonly value: T }\n\t| { readonly status: \"error\"; readonly error: Error }\n\t| {\n\t\t\t/** The handshake did not grant `operation`; no call was made. */\n\t\t\treadonly status: \"refused\";\n\t\t\treadonly operation: HostOperationId;\n\t\t\treadonly message: string;\n\t  };\n\nconst IDLE_QUERY: HostQueryState<never> = Object.freeze({ status: \"idle\" });\n\n/** What a host query runs once the grant is confirmed. */\nexport type HostQueryLoader<T> = (\n\thost: QgisSdkHost,\n\toptions: { readonly signal: AbortSignal },\n) => Promise<T>;\n\n/**\n * Read the curated host surface, grant first.\n *\n * `refresh` waits for the handshake, then - when `qgis.host.granted` lacks\n * the operation the query needs - settles on `refused` without a call, so a\n * page can show \"ask the plugin author for `layers.read`\" instead of a\n * `not_authorized` fault. Otherwise the loader runs with latest-wins\n * semantics like an operation store.\n */\nexport class HostQueryStore<T> extends BaseStore<HostQueryState<T>> {\n\tprivate generation = 0;\n\tprivate controller: AbortController | null = null;\n\n\tpublic constructor(\n\t\tprivate readonly qgis: QgisSdkCore<unknown, unknown>,\n\t\tpublic readonly operation: HostOperationId,\n\t\tprivate readonly loader: HostQueryLoader<T>,\n\t) {\n\t\tsuper(IDLE_QUERY);\n\t}\n\n\tpublic readonly abort = (): void => {\n\t\tthis.generation += 1;\n\t\tthis.controller?.abort();\n\t\tthis.controller = null;\n\t};\n\n\tpublic readonly reset = (): void => {\n\t\tthis.abort();\n\t\tthis.publish(IDLE_QUERY);\n\t};\n\n\tpublic readonly refresh = async (): Promise<T | undefined> => {\n\t\tthis.abort();\n\t\tconst mine = this.generation;\n\t\tconst controller = new AbortController();\n\t\tthis.controller = controller;\n\t\tthis.publish({ status: \"loading\" });\n\t\ttry {\n\t\t\tawait this.qgis.ready;\n\t\t\tif (this.generation !== mine) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tif (!this.qgis.host.granted.includes(this.operation)) {\n\t\t\t\tthis.publish({\n\t\t\t\t\tstatus: \"refused\",\n\t\t\t\t\toperation: this.operation,\n\t\t\t\t\tmessage: `this view was not granted ${this.operation}`,\n\t\t\t\t});\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tconst value = await this.loader(this.qgis.host, {\n\t\t\t\tsignal: controller.signal,\n\t\t\t});\n\t\t\tif (this.generation !== mine) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tthis.publish({ status: \"ok\", value });\n\t\t\treturn value;\n\t\t} catch (error) {\n\t\t\tif (\n\t\t\t\tthis.generation !== mine ||\n\t\t\t\terror instanceof QgisSdkBridgeAbortedError\n\t\t\t) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tthis.publish({ status: \"error\", error: asError(error) });\n\t\t\treturn undefined;\n\t\t} finally {\n\t\t\tif (this.controller === controller) {\n\t\t\t\tthis.controller = null;\n\t\t\t}\n\t\t}\n\t};\n}\n\n/** Options for {@link layersQuery}. */\nexport interface LayersQueryOptions {\n\t/** Items per page while following `next_cursor`; the host's default otherwise. */\n\treadonly pageSize?: number;\n}\n\n/**\n * Every vector layer of the project, following `layers.list` pages to the\n * end: what a layer picker binds to. Needs the `layers.read` grant.\n */\nexport function layersQuery(\n\tqgis: QgisSdkCore<unknown, unknown>,\n\toptions: LayersQueryOptions = {},\n): HostQueryStore<readonly VectorLayerInfo[]> {\n\treturn new HostQueryStore(qgis, \"layers.list\", async (host, { signal }) => {\n\t\tconst items: VectorLayerInfo[] = [];\n\t\tlet cursor: string | undefined;\n\t\tdo {\n\t\t\tconst page: LayerPage = await host.layers.list(\n\t\t\t\t{\n\t\t\t\t\t...(cursor === undefined ? {} : { cursor }),\n\t\t\t\t\t...(options.pageSize === undefined\n\t\t\t\t\t\t? {}\n\t\t\t\t\t\t: { limit: options.pageSize }),\n\t\t\t\t},\n\t\t\t\t{ signal },\n\t\t\t);\n\t\t\titems.push(...page.items);\n\t\t\tcursor = page.next_cursor;\n\t\t} while (cursor !== undefined);\n\t\treturn Object.freeze(items);\n\t});\n}\n\n/**\n * The field names of one vector layer, for a `field` input whose `of` names\n * a layer input: `layers.get` under the `layers.read` grant. A layer's CRS is\n * on the same reply; a project CRS query is not on the wire yet.\n */\nexport function layerFieldsQuery(\n\tqgis: QgisSdkCore<unknown, unknown>,\n\tlayerId: string,\n): HostQueryStore<readonly string[]> {\n\treturn new HostQueryStore(qgis, \"layers.get\", async (host, { signal }) => {\n\t\tconst layer = await host.layers.get({ layer_id: layerId }, { signal });\n\t\treturn Object.freeze([...layer.field_names]);\n\t});\n}\n",
    "/** {@link StreamStore}: one generated stream held open while its input is non-null. */\n\nimport { isPlainRecord } from \"../internal\";\nimport { asError, BaseStore } from \"./base\";\n\n// ---------------------------------------------------------------------------\n// StreamStore\n// ---------------------------------------------------------------------------\n\n/** How a stream ended, as the generated module reports it. */\nexport interface StreamTerminalLike {\n\treadonly kind: string;\n\treadonly message?: string;\n\treadonly dropped?: number;\n}\n\n/** The handle a generated stream member resolves with. */\nexport interface StreamHandleLike {\n\treadonly id: string;\n\treadonly closed: boolean;\n\tclose(): void;\n}\n\n/** Handlers for a stream, as a generated module types them. */\nexport interface StreamHandlersLike<E> {\n\treadonly onEvent?: (event: E) => void;\n\treadonly onTerminal?: (terminal: StreamTerminalLike) => void;\n}\n\n/** A stream member of a generated map. */\nexport type Stream<I, E> = (\n\tinput: I,\n\thandlers: StreamHandlersLike<E>,\n\toptions?: { readonly signal?: AbortSignal },\n) => Promise<StreamHandleLike>;\n\n/** Where one subscription stands. */\nexport interface StreamState<E> {\n\t/** `idle` with a null input, `failed` when the host refused to open it. */\n\treadonly status: \"idle\" | \"opening\" | \"open\" | \"ended\" | \"failed\";\n\treadonly lastEvent: E | null;\n\treadonly terminal: StreamTerminalLike | null;\n\treadonly error: Error | null;\n}\n\nconst IDLE_STREAM: StreamState<never> = Object.freeze({\n\tstatus: \"idle\",\n\tlastEvent: null,\n\tterminal: null,\n\terror: null,\n});\n\n/**\n * Return a key that is equal for two inputs with the same content, whatever\n * the order their fields were written in.\n */\nexport function stableKey(value: unknown): string {\n\treturn JSON.stringify(value, (_key, item: unknown) =>\n\t\tisPlainRecord(item)\n\t\t\t? Object.fromEntries(\n\t\t\t\t\tObject.entries(item).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)),\n\t\t\t\t)\n\t\t\t: item,\n\t);\n}\n\n/**\n * Hold one generated stream open while its input is non-null.\n *\n * `setInput` follows the *content* of the input: a new object with the same\n * fields changes nothing, a different one closes the old stream and opens a\n * new one, `null` closes it. Handlers are read fresh on every frame, so\n * `setHandlers` with a new closure reopens nothing. `close` is safe before the\n * host has acknowledged the stream: the handle is closed the moment it\n * arrives.\n */\nexport class StreamStore<I, E> extends BaseStore<StreamState<E>> {\n\tprivate key: string | null = null;\n\tprivate cancel: (() => void) | null = null;\n\n\tpublic constructor(\n\t\tprivate readonly open: Stream<I, E>,\n\t\tprivate handlers: StreamHandlersLike<E> = {},\n\t) {\n\t\tsuper(IDLE_STREAM);\n\t}\n\n\t/** Replace the handlers the next frames reach; nothing reopens. */\n\tpublic setHandlers(handlers: StreamHandlersLike<E>): void {\n\t\tthis.handlers = handlers;\n\t}\n\n\tpublic readonly setInput = (input: I | null): void => {\n\t\tconst key = input === null ? null : stableKey(input);\n\t\tif (key === this.key) {\n\t\t\treturn;\n\t\t}\n\t\tthis.cancel?.();\n\t\tthis.cancel = null;\n\t\tthis.key = key;\n\t\tif (input === null || key === null) {\n\t\t\tthis.publish(IDLE_STREAM);\n\t\t\treturn;\n\t\t}\n\t\tthis.cancel = this.start(input);\n\t};\n\n\tpublic readonly close = (): void => {\n\t\tthis.setInput(null);\n\t};\n\n\tprivate start(input: I): () => void {\n\t\tlet cancelled = false;\n\t\tlet handle: StreamHandleLike | null = null;\n\t\tconst update = (change: (previous: StreamState<E>) => StreamState<E>) => {\n\t\t\tif (!cancelled) {\n\t\t\t\tthis.publish(change(this.getSnapshot()));\n\t\t\t}\n\t\t};\n\t\tthis.publish({\n\t\t\tstatus: \"opening\",\n\t\t\tlastEvent: null,\n\t\t\tterminal: null,\n\t\t\terror: null,\n\t\t});\n\t\tthis.open(input, {\n\t\t\tonEvent: (event) => {\n\t\t\t\tif (cancelled) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tthis.handlers.onEvent?.(event);\n\t\t\t\tupdate((previous) => ({ ...previous, lastEvent: event }));\n\t\t\t},\n\t\t\tonTerminal: (terminal) => {\n\t\t\t\tif (cancelled) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tthis.handlers.onTerminal?.(terminal);\n\t\t\t\tupdate((previous) => ({ ...previous, status: \"ended\", terminal }));\n\t\t\t},\n\t\t}).then(\n\t\t\t(opened) => {\n\t\t\t\tif (cancelled) {\n\t\t\t\t\topened.close();\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\thandle = opened;\n\t\t\t\tupdate((previous) =>\n\t\t\t\t\tprevious.status === \"ended\"\n\t\t\t\t\t\t? previous\n\t\t\t\t\t\t: { ...previous, status: \"open\" },\n\t\t\t\t);\n\t\t\t},\n\t\t\t(error: unknown) => {\n\t\t\t\tupdate(() => ({\n\t\t\t\t\tstatus: \"failed\",\n\t\t\t\t\tlastEvent: null,\n\t\t\t\t\tterminal: null,\n\t\t\t\t\terror: asError(error),\n\t\t\t\t}));\n\t\t\t},\n\t\t);\n\t\treturn () => {\n\t\t\tcancelled = true;\n\t\t\thandle?.close();\n\t\t};\n\t}\n}\n"
  ],
  "mappings": "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",
  "debugId": "DD645B0085B7656764756E2164756E21",
  "names": []
}